@actuarial-ts/core 0.6.0 → 0.7.0

package/src/diagnosticDefinitions.ts

@@ -1,5 +1,6 @@
 import {
   MAX_DIAGNOSTIC_DEFINITION_EXPRESSION_NODES,
+  MAX_DIAGNOSTIC_EXPRESSION_NODES,
   walkDiagnosticExpression,
   type DiagnosticClaimExpression,
   type DiagnosticMeasureExpression,
@@ -18,6 +19,14 @@ import {
   type DiagnosticValidationIssueCode,
 } from "./types.js";
 import { canonicalJson } from "./canonical.js";
+import { normalizeDiagnosticPeriodWithAxis } from "./diagnosticPeriodAxis.js";
+import {
+  diagnosticJsonPreflight,
+  hasDiagnosticOwn,
+  isDiagnosticPlainRecord,
+  isDiagnosticToken,
+  isWellFormedDiagnosticString,
+} from "./diagnosticRuntime.js";
 
 export type DiagnosticMeasureKind = "count" | "amount" | "exposure";
 export type DiagnosticMeasureSource = "loss" | "exposure" | "derived";
@@ -38,12 +47,11 @@ export type JsonValue =
   | readonly JsonValue[]
   | { readonly [key: string]: JsonValue };
 
-export type DiagnosticDeepReadonly<T> =
-  T extends readonly (infer U)[]
-    ? readonly DiagnosticDeepReadonly<U>[]
-    : T extends object
-      ? { readonly [K in keyof T]: DiagnosticDeepReadonly<T[K]> }
-      : T;
+export type DiagnosticDeepReadonly<T> = T extends readonly (infer U)[]
+  ? readonly DiagnosticDeepReadonly<U>[]
+  : T extends object
+    ? { readonly [K in keyof T]: DiagnosticDeepReadonly<T[K]> }
+    : T;
 
 export interface DiagnosticMeasureDefinition {
   id: string;
@@ -238,7 +246,10 @@ export type DiagnosticControlTotalProjection =
   | { kind: "latest-valuation-per-origin" }
   | { kind: "all-cells" };
 
-export type DiagnosticReviewFilter = Omit<DiagnosticsFilter, "outputGroups" | "instanceIds">;
+export type DiagnosticReviewFilter = Omit<
+  DiagnosticsFilter,
+  "outputGroups" | "instanceIds"
+>;
 
 export type DiagnosticReviewRule =
   | (DiagnosticReviewRuleBase & {
@@ -306,7 +317,9 @@ export interface DiagnosticMeasureStats {
   readonly structural: number;
 }
 
-const compiledDiagnosticDefinitionBrand: unique symbol = Symbol("compiled-diagnostic-definition");
+const compiledDiagnosticDefinitionBrand: unique symbol = Symbol(
+  "compiled-diagnostic-definition",
+);
 
 export interface CompiledDiagnosticDefinition {
   readonly [compiledDiagnosticDefinitionBrand]: true;
@@ -317,21 +330,37 @@ export interface CompiledDiagnosticDefinition {
 }
 
 export interface CompiledDiagnosticDefinitionInternals {
-  readonly formulasById: ReadonlyMap<string, NormalizedDiagnosticFormulaIdentity>;
+  readonly formulasById: ReadonlyMap<
+    string,
+    NormalizedDiagnosticFormulaIdentity
+  >;
   readonly measuresById: ReadonlyMap<string, DiagnosticMeasureDefinition>;
-  readonly calculationScopesByInstanceId: ReadonlyMap<string, NormalizedDiagnosticCalculationScope>;
-  readonly calculationDependenciesByInstanceId: ReadonlyMap<string, readonly string[]>;
-  readonly evaluationDependenciesByInstanceId: ReadonlyMap<string, readonly string[]>;
-  readonly derivationsByOutputMeasureId: ReadonlyMap<string, DiagnosticDerivedMeasureDefinition>;
+  readonly calculationScopesByInstanceId: ReadonlyMap<
+    string,
+    NormalizedDiagnosticCalculationScope
+  >;
+  readonly calculationDependenciesByInstanceId: ReadonlyMap<
+    string,
+    readonly string[]
+  >;
+  readonly evaluationDependenciesByInstanceId: ReadonlyMap<
+    string,
+    readonly string[]
+  >;
+  readonly derivationsByOutputMeasureId: ReadonlyMap<
+    string,
+    DiagnosticDerivedMeasureDefinition
+  >;
 }
 
 const authenticCompiledDefinitions = new WeakSet<object>();
-const compiledInternals = new WeakMap<object, CompiledDiagnosticDefinitionInternals>();
+const compiledInternals = new WeakMap<
+  object,
+  CompiledDiagnosticDefinitionInternals
+>();
 
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype: unknown = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+  return isDiagnosticPlainRecord(value);
 }
 
 function propertyPath(parent: string, key: string): string {
@@ -349,17 +378,79 @@ function pushIssue(
   issues.push({ domain: "definition", code, path, message });
 }
 
-function hasWellFormedUtf16(value: string): boolean {
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code === 0) return false;
-    if (code >= 0xd800 && code <= 0xdbff) {
-      const next = value.charCodeAt(index + 1);
-      if (!(next >= 0xdc00 && next <= 0xdfff)) return false;
-      index++;
-    } else if (code >= 0xdc00 && code <= 0xdfff) return false;
+function validateAllowedKeys(
+  value: Record<string, unknown>,
+  allowed: readonly string[],
+  path: string,
+  issues: DiagnosticValidationIssue[],
+): void {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key)) {
+      pushIssue(
+        issues,
+        "unknown-key",
+        propertyPath(path, key),
+        `Unknown key ${key}`,
+      );
+    } else if (value[key] === undefined) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        propertyPath(path, key),
+        "Explicit undefined is not allowed",
+      );
+    }
+  }
+}
+
+function validateScalarAttributes(
+  value: unknown,
+  path: string,
+  issues: DiagnosticValidationIssue[],
+): void {
+  if (value === undefined) return;
+  if (!isPlainRecord(value)) {
+    pushIssue(
+      issues,
+      "invalid-type",
+      path,
+      "Attributes must be a plain object",
+    );
+    return;
+  }
+  for (const [key, scalar] of Object.entries(value)) {
+    validateToken(key, propertyPath(path, key), "Attribute key", issues);
+    if (
+      scalar !== null &&
+      typeof scalar !== "string" &&
+      typeof scalar !== "number" &&
+      typeof scalar !== "boolean"
+    ) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        propertyPath(path, key),
+        "Attribute value must be a string, finite number, boolean, or null",
+      );
+    } else if (typeof scalar === "number") {
+      validateFinite(
+        scalar,
+        propertyPath(path, key),
+        "Attribute number",
+        issues,
+      );
+    } else if (
+      typeof scalar === "string" &&
+      !isWellFormedDiagnosticString(scalar)
+    ) {
+      pushIssue(
+        issues,
+        "invalid-string",
+        propertyPath(path, key),
+        "Attribute string contains invalid Unicode",
+      );
+    }
   }
-  return true;
 }
 
 function validateToken(
@@ -372,12 +463,22 @@ function validateToken(
     pushIssue(issues, "invalid-type", path, `${label} must be a string`);
     return false;
   }
-  if (!hasWellFormedUtf16(value)) {
-    pushIssue(issues, "invalid-string", path, `${label} contains an invalid Unicode string`);
+  if (!isWellFormedDiagnosticString(value)) {
+    pushIssue(
+      issues,
+      "invalid-string",
+      path,
+      `${label} contains an invalid Unicode string`,
+    );
     return false;
   }
-  if (value.length === 0 || /^[\u0009-\u000d\u0020]|[\u0009-\u000d\u0020]$/.test(value)) {
-    pushIssue(issues, "invalid-string", path, `${label} must be nonempty without surrounding ASCII whitespace`);
+  if (!isDiagnosticToken(value)) {
+    pushIssue(
+      issues,
+      "invalid-string",
+      path,
+      `${label} must be nonempty without surrounding ASCII whitespace`,
+    );
     return false;
   }
   return true;
@@ -396,67 +497,11 @@ function validateFinite(
   return true;
 }
 
-interface JsonFrame {
-  readonly value: unknown;
-  readonly path: string;
-  readonly exiting: boolean;
-}
-
-function validateJsonValue(value: unknown, issues: DiagnosticValidationIssue[]): void {
-  const active = new WeakSet<object>();
-  const stack: JsonFrame[] = [{ value, path: "$", exiting: false }];
-  while (stack.length > 0) {
-    const frame = stack.pop()!;
-    if (frame.value === null || typeof frame.value === "boolean") continue;
-    if (typeof frame.value === "string") {
-      if (!hasWellFormedUtf16(frame.value)) {
-        pushIssue(issues, "invalid-json-value", frame.path, "String is not well-formed UTF-16 or contains U+0000");
-      }
-      continue;
-    }
-    if (typeof frame.value === "number") {
-      if (!Number.isFinite(frame.value)) {
-        pushIssue(issues, "invalid-json-value", frame.path, "JSON numeric value must be finite");
-      }
-      continue;
-    }
-    if (typeof frame.value !== "object" || frame.value === undefined) {
-      pushIssue(issues, "invalid-json-value", frame.path, "Value is not plain JSON data");
-      continue;
-    }
-    const object = frame.value as object;
-    if (frame.exiting) {
-      active.delete(object);
-      continue;
-    }
-    if (active.has(object)) {
-      pushIssue(issues, "cycle", frame.path, "JSON value contains a cycle");
-      continue;
-    }
-    if (!Array.isArray(object) && !isPlainRecord(object)) {
-      pushIssue(issues, "invalid-json-value", frame.path, "Value must use a plain object or array prototype");
-      continue;
-    }
-    active.add(object);
-    stack.push({ value: object, path: frame.path, exiting: true });
-    if (Array.isArray(object)) {
-      for (let index = object.length - 1; index >= 0; index--) {
-        stack.push({ value: object[index], path: `${frame.path}[${index}]`, exiting: false });
-      }
-    } else {
-      for (const key of Object.keys(object).sort().reverse()) {
-        if (!hasWellFormedUtf16(key)) {
-          pushIssue(issues, "invalid-json-value", propertyPath(frame.path, key), "Object key is not well-formed UTF-16 or contains U+0000");
-        }
-        const descriptor = Object.getOwnPropertyDescriptor(object, key);
-        if (!descriptor || !("value" in descriptor)) {
-          pushIssue(issues, "invalid-json-value", propertyPath(frame.path, key), "JSON objects may contain only data properties");
-          continue;
-        }
-        stack.push({ value: descriptor.value, path: propertyPath(frame.path, key), exiting: false });
-      }
-    }
-  }
+function validateJsonValue(
+  value: unknown,
+  issues: DiagnosticValidationIssue[],
+): void {
+  issues.push(...diagnosticJsonPreflight(value, "definition"));
 }
 
 function requireArray(
@@ -489,7 +534,8 @@ function collectCatalog<T extends { readonly id: string }>(
 
 function semanticReference(measure: DiagnosticMeasureDefinition): string {
   if (measure.kind === "amount") return `amount:${measure.basisId ?? ""}`;
-  if (measure.kind === "count") return `count:${measure.countPopulationId ?? ""}`;
+  if (measure.kind === "count")
+    return `count:${measure.countPopulationId ?? ""}`;
   return `exposure:${measure.exposureBasisId ?? ""}`;
 }
 
@@ -505,7 +551,10 @@ function transitiveMeasureIds(
     result.add(id);
     const derivation = derivations.get(id);
     if (derivation) {
-      stack.push(...walkDiagnosticExpression(derivation.expression, "claim", "$", []).dependencies);
+      stack.push(
+        ...walkDiagnosticExpression(derivation.expression, "claim", "$", [])
+          .dependencies,
+      );
     }
   }
   return [...result].sort();
@@ -524,11 +573,15 @@ interface ProjectedClaimSemantics {
   readonly amountBasis?: ProjectedAmountBasis;
 }
 
-function projectedAmountBasis(basis: AmountBasisDefinition): ProjectedAmountBasis {
+function projectedAmountBasis(
+  basis: AmountBasisDefinition,
+): ProjectedAmountBasis {
   return {
     currency: basis.currency,
     perspective: basis.perspective,
-    components: [...basis.components].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
+    components: [...basis.components].sort((left, right) =>
+      left.id < right.id ? -1 : left.id > right.id ? 1 : 0,
+    ),
   };
 }
 
@@ -547,23 +600,49 @@ function projectClaimExpression(
     const measure = measures.get(expression.measureId);
     if (!measure) return null;
     if (measure.kind !== "amount") {
-      return { kind: measure.kind, unit: measure.unit, reference: semanticReference(measure) };
+      return {
+        kind: measure.kind,
+        unit: measure.unit,
+        reference: semanticReference(measure),
+      };
     }
-    const basis = measure.basisId ? amountBases.get(measure.basisId) : undefined;
+    const basis = measure.basisId
+      ? amountBases.get(measure.basisId)
+      : undefined;
     return basis
-      ? { kind: "amount", unit: measure.unit, reference: `amount:${measure.basisId}`, amountBasis: projectedAmountBasis(basis) }
+      ? {
+          kind: "amount",
+          unit: measure.unit,
+          reference: `amount:${measure.basisId}`,
+          amountBasis: projectedAmountBasis(basis),
+        }
       : null;
   }
   if (expression.op === "claim-layer") {
     const measure = measures.get(expression.measureId);
     if (!measure || measure.kind !== "amount" || !measure.basisId) {
-      pushIssue(issues, "incompatible-semantics", path, "Claim layers require an amount measure");
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        path,
+        "Claim layers require an amount measure",
+      );
       return null;
     }
     const basis = amountBases.get(measure.basisId);
     const component = basis?.components[0];
-    if (!basis || basis.components.length !== 1 || component?.treatment !== "included" || component.limitation.kind !== "unlimited") {
-      pushIssue(issues, "incompatible-semantics", path, "Claim layers require one included unlimited source component");
+    if (
+      !basis ||
+      basis.components.length !== 1 ||
+      component?.treatment !== "included" ||
+      component.limitation.kind !== "unlimited"
+    ) {
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        path,
+        "Claim layers require one included unlimited source component",
+      );
       return null;
     }
     return {
@@ -573,56 +652,97 @@ function projectClaimExpression(
       amountBasis: {
         currency: basis.currency,
         perspective: basis.perspective,
-        components: [{
-          id: component.id,
-          treatment: "included",
-          limitation: {
-            kind: "layer",
-            attachment: expression.attachment,
-            limit: expression.limit,
-            application: "claim",
-            derivation: { kind: "sdk" },
+        components: [
+          {
+            id: component.id,
+            treatment: "included",
+            limitation: {
+              kind: "layer",
+              attachment: expression.attachment,
+              limit: expression.limit,
+              application: "claim",
+              derivation: { kind: "sdk" },
+            },
           },
-        }],
+        ],
       },
     };
   }
-  const children = expression.op === "add" ? expression.terms : [expression.left, expression.right];
-  const projected = children.map((child, index) => projectClaimExpression(
-    child,
-    expression.op === "add" ? `${path}.terms[${index}]` : `${path}.${index === 0 ? "left" : "right"}`,
-    measures,
-    amountBases,
-    issues,
-  ));
+  const children =
+    expression.op === "add"
+      ? expression.terms
+      : [expression.left, expression.right];
+  const projected = children.map((child, index) =>
+    projectClaimExpression(
+      child,
+      expression.op === "add"
+        ? `${path}.terms[${index}]`
+        : `${path}.${index === 0 ? "left" : "right"}`,
+      measures,
+      amountBases,
+      issues,
+    ),
+  );
   if (projected.some((item) => item === null)) return null;
   const present = projected as ProjectedClaimSemantics[];
   if (expression.op === "subtract") {
     const [left, right] = present;
-    if (left!.kind !== right!.kind || left!.unit !== right!.unit ||
-        (left!.kind === "amount"
-          ? projectedBasisKey(left!.amountBasis!) !== projectedBasisKey(right!.amountBasis!)
-          : left!.reference !== right!.reference)) {
-      pushIssue(issues, "incompatible-semantics", path, "Claim subtraction requires one exact semantic basis");
+    if (
+      left!.kind !== right!.kind ||
+      left!.unit !== right!.unit ||
+      (left!.kind === "amount"
+        ? projectedBasisKey(left!.amountBasis!) !==
+          projectedBasisKey(right!.amountBasis!)
+        : left!.reference !== right!.reference)
+    ) {
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        path,
+        "Claim subtraction requires one exact semantic basis",
+      );
       return null;
     }
     return left!;
   }
   const first = present[0]!;
-  if (present.some((item) => item.kind !== first.kind || item.unit !== first.unit)) {
-    pushIssue(issues, "incompatible-semantics", path, "Claim addition requires one kind and unit");
+  if (
+    present.some((item) => item.kind !== first.kind || item.unit !== first.unit)
+  ) {
+    pushIssue(
+      issues,
+      "incompatible-semantics",
+      path,
+      "Claim addition requires one kind and unit",
+    );
     return null;
   }
   if (first.kind !== "amount") {
     if (present.some((item) => item.reference !== first.reference)) {
-      pushIssue(issues, "incompatible-semantics", path, "Claim addition requires one exact semantic basis");
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        path,
+        "Claim addition requires one exact semantic basis",
+      );
       return null;
     }
     return first;
   }
   const bases = present.map((item) => item.amountBasis!);
-  if (bases.some((basis) => basis.currency !== bases[0]!.currency || basis.perspective !== bases[0]!.perspective)) {
-    pushIssue(issues, "incompatible-semantics", path, "Amount addition cannot mix currency or perspective");
+  if (
+    bases.some(
+      (basis) =>
+        basis.currency !== bases[0]!.currency ||
+        basis.perspective !== bases[0]!.perspective,
+    )
+  ) {
+    pushIssue(
+      issues,
+      "incompatible-semantics",
+      path,
+      "Amount addition cannot mix currency or perspective",
+    );
     return null;
   }
   const componentIds = new Set<string>();
@@ -630,7 +750,12 @@ function projectClaimExpression(
   for (const basis of bases) {
     for (const component of basis.components) {
       if (componentIds.has(component.id)) {
-        pushIssue(issues, "incompatible-semantics", path, `Amount addition overlaps component ${component.id}`);
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          path,
+          `Amount addition overlaps component ${component.id}`,
+        );
         return null;
       }
       componentIds.add(component.id);
@@ -640,9 +765,16 @@ function projectClaimExpression(
   const amountBasis = {
     currency: bases[0]!.currency,
     perspective: bases[0]!.perspective,
-    components: components.sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
+    components: components.sort((left, right) =>
+      left.id < right.id ? -1 : left.id > right.id ? 1 : 0,
+    ),
+  };
+  return {
+    kind: "amount",
+    unit: first.unit,
+    reference: "amount:projected",
+    amountBasis,
   };
-  return { kind: "amount", unit: first.unit, reference: "amount:projected", amountBasis };
 }
 
 function expressionSemantics(
@@ -650,21 +782,40 @@ function expressionSemantics(
   path: string,
   measures: ReadonlyMap<string, DiagnosticMeasureDefinition>,
   issues: DiagnosticValidationIssue[],
-): { readonly measureIds: readonly string[]; readonly signature: string | null } {
-  const walked = walkDiagnosticExpression(expression, "measure", path, issues);
+  initialDepth = 1,
+): {
+  readonly measureIds: readonly string[];
+  readonly signature: string | null;
+} {
+  const walked = walkDiagnosticExpression(
+    expression,
+    "measure",
+    path,
+    issues,
+    initialDepth,
+  );
   const found = walked.dependencies
     .map((id) => measures.get(id))
-    .filter((value): value is DiagnosticMeasureDefinition => value !== undefined);
+    .filter(
+      (value): value is DiagnosticMeasureDefinition => value !== undefined,
+    );
   for (const id of walked.dependencies) {
     if (!measures.has(id)) {
       pushIssue(issues, "unknown-reference", path, `Unknown measure ${id}`);
     }
   }
-  const signatures = new Set(found.map((measure) =>
-    `${measure.kind}\u0000${measure.unit}\u0000${semanticReference(measure)}`,
-  ));
+  const signatures = new Set(
+    found.map((measure) =>
+      canonicalJson([measure.kind, measure.unit, semanticReference(measure)]),
+    ),
+  );
   if (signatures.size > 1) {
-    pushIssue(issues, "incompatible-semantics", path, "Expression combines incompatible measure semantics");
+    pushIssue(
+      issues,
+      "incompatible-semantics",
+      path,
+      "Expression combines incompatible measure semantics",
+    );
   }
   return {
     measureIds: walked.dependencies,
@@ -680,60 +831,600 @@ function validateTolerance(
   for (const key of ["absolute", "relative"] as const) {
     const component = value?.[key];
     if (component === undefined) continue;
-    if (!validateFinite(component, `${path}.${key}`, `${key} tolerance`, issues)) continue;
+    if (
+      !validateFinite(component, `${path}.${key}`, `${key} tolerance`, issues)
+    )
+      continue;
     if (component < 0) {
-      pushIssue(issues, "invalid-number", `${path}.${key}`, `${key} tolerance must be nonnegative`);
+      pushIssue(
+        issues,
+        "invalid-number",
+        `${path}.${key}`,
+        `${key} tolerance must be nonnegative`,
+      );
+    }
+  }
+}
+
+function validateReviewFilter(
+  value: unknown,
+  path: string,
+  axis: DiagnosticPeriodAxis,
+  issues: DiagnosticValidationIssue[],
+): void {
+  if (!isPlainRecord(value)) {
+    pushIssue(issues, "invalid-type", path, "Review filter must be an object");
+    return;
+  }
+  const periodCoordinates = new Map<string, number>();
+  const validatePeriods = (
+    key: "origins" | "valuations",
+    side: "origin" | "valuation",
+  ) => {
+    const raw = value[key];
+    if (raw === undefined) return;
+    const entries = requireArray(raw, `${path}.${key}`, issues);
+    entries.forEach((entry, index) => {
+      const entryPath = `${path}.${key}[${index}]`;
+      if (!validateToken(entry, entryPath, `${side} period`, issues)) return;
+      const normalized = normalizeDiagnosticPeriodWithAxis(axis, side, entry);
+      if (!normalized)
+        pushIssue(
+          issues,
+          "invalid-period",
+          entryPath,
+          `Unknown ${side} period ${JSON.stringify(entry)}`,
+        );
+    });
+  };
+  const validateEndpoint = (
+    key: "originFrom" | "originThrough" | "valuationFrom" | "valuationThrough",
+    side: "origin" | "valuation",
+  ) => {
+    const raw = value[key];
+    if (raw === undefined) return;
+    if (!validateToken(raw, `${path}.${key}`, `${side} period`, issues)) return;
+    const normalized = normalizeDiagnosticPeriodWithAxis(axis, side, raw);
+    if (!normalized)
+      pushIssue(
+        issues,
+        "invalid-period",
+        `${path}.${key}`,
+        `Unknown ${side} period ${JSON.stringify(raw)}`,
+      );
+    else periodCoordinates.set(key, normalized.coordinate);
+  };
+  if (value.sourceGroups !== undefined)
+    requireArray(value.sourceGroups, `${path}.sourceGroups`, issues).forEach(
+      (item, index) => {
+        validateToken(
+          item,
+          `${path}.sourceGroups[${index}]`,
+          "Source group",
+          issues,
+        );
+      },
+    );
+  validatePeriods("origins", "origin");
+  validateEndpoint("originFrom", "origin");
+  validateEndpoint("originThrough", "origin");
+  validatePeriods("valuations", "valuation");
+  validateEndpoint("valuationFrom", "valuation");
+  validateEndpoint("valuationThrough", "valuation");
+  for (const key of ["minDevelopmentAge", "maxDevelopmentAge"] as const) {
+    const raw = value[key];
+    if (raw === undefined) continue;
+    if (
+      !validateFinite(raw, `${path}.${key}`, key, issues) ||
+      !Number.isSafeInteger(raw) ||
+      raw < 0
+    ) {
+      pushIssue(
+        issues,
+        "invalid-number",
+        `${path}.${key}`,
+        `${key} must be a nonnegative safe integer`,
+      );
     }
   }
+  if (
+    (periodCoordinates.get("originFrom") ?? -Infinity) >
+    (periodCoordinates.get("originThrough") ?? Infinity)
+  ) {
+    pushIssue(
+      issues,
+      "invalid-input-relationship",
+      path,
+      "originFrom must not follow originThrough",
+    );
+  }
+  if (
+    (periodCoordinates.get("valuationFrom") ?? -Infinity) >
+    (periodCoordinates.get("valuationThrough") ?? Infinity)
+  ) {
+    pushIssue(
+      issues,
+      "invalid-input-relationship",
+      path,
+      "valuationFrom must not follow valuationThrough",
+    );
+  }
+  if (
+    typeof value.minDevelopmentAge === "number" &&
+    typeof value.maxDevelopmentAge === "number" &&
+    value.minDevelopmentAge > value.maxDevelopmentAge
+  ) {
+    pushIssue(
+      issues,
+      "invalid-input-relationship",
+      path,
+      "minDevelopmentAge must not exceed maxDevelopmentAge",
+    );
+  }
 }
 
-function validatePeriodAxis(axis: DiagnosticPeriodAxis, issues: DiagnosticValidationIssue[]): void {
+function measureExpressionBasis(
+  expression: DiagnosticMeasureExpression,
+  measures: ReadonlyMap<string, DiagnosticMeasureDefinition>,
+  amountBases: ReadonlyMap<string, AmountBasisDefinition>,
+): AmountBasisDefinition | null {
+  const ids = walkDiagnosticExpression(
+    expression,
+    "measure",
+    "$",
+    [],
+  ).dependencies;
+  const found = ids.map((id) => measures.get(id));
+  if (
+    found.length === 0 ||
+    found.some((measure) => measure?.kind !== "amount" || !measure.basisId)
+  )
+    return null;
+  const basisIds = new Set(found.map((measure) => measure!.basisId!));
+  return basisIds.size === 1
+    ? (amountBases.get([...basisIds][0]!) ?? null)
+    : null;
+}
+
+interface LayerComponentTrace {
+  readonly rawMeasureId: string;
+  readonly hasLayer: boolean;
+}
+
+function traceLayerComponents(
+  measureId: string,
+  measures: ReadonlyMap<string, DiagnosticMeasureDefinition>,
+  amountBases: ReadonlyMap<string, AmountBasisDefinition>,
+  derivations: ReadonlyMap<string, DiagnosticDerivedMeasureDefinition>,
+  seen = new Set<string>(),
+): ReadonlyMap<string, LayerComponentTrace> | null {
+  if (seen.has(measureId)) return null;
+  const derivation = derivations.get(measureId);
+  if (!derivation) {
+    const measure = measures.get(measureId);
+    const basis =
+      measure?.kind === "amount" && measure.basisId
+        ? amountBases.get(measure.basisId)
+        : undefined;
+    return basis
+      ? new Map(
+          basis.components.map((component) => [
+            component.id,
+            { rawMeasureId: measureId, hasLayer: false },
+          ]),
+        )
+      : null;
+  }
+  const nextSeen = new Set(seen).add(measureId);
+  const visit = (
+    expression: DiagnosticClaimExpression,
+  ): ReadonlyMap<string, LayerComponentTrace> | null => {
+    if (expression.op === "measure")
+      return traceLayerComponents(
+        expression.measureId,
+        measures,
+        amountBases,
+        derivations,
+        nextSeen,
+      );
+    if (expression.op === "claim-layer") {
+      const nested = traceLayerComponents(
+        expression.measureId,
+        measures,
+        amountBases,
+        derivations,
+        nextSeen,
+      );
+      if (!nested || nested.size !== 1) return null;
+      return new Map(
+        [...nested].map(([componentId, trace]) => [
+          componentId,
+          { ...trace, hasLayer: true },
+        ]),
+      );
+    }
+    if (expression.op === "subtract") return null;
+    const result = new Map<string, LayerComponentTrace>();
+    for (const term of expression.terms) {
+      const traced = visit(term);
+      if (!traced) return null;
+      for (const [componentId, trace] of traced) {
+        if (result.has(componentId)) return null;
+        result.set(componentId, trace);
+      }
+    }
+    return result;
+  };
+  return visit(derivation.expression);
+}
+
+function limitationInterval(limitation: AmountLimitation): {
+  readonly attachment: number;
+  readonly exhaustion: number;
+  readonly application: "claim" | "occurrence" | "policy" | null;
+} | null {
+  if (limitation.kind === "unlimited")
+    return { attachment: 0, exhaustion: Infinity, application: null };
+  if (
+    limitation.kind !== "layer" ||
+    limitation.derivation.kind !== "sdk" ||
+    limitation.application === "source-defined"
+  )
+    return null;
+  return {
+    attachment: limitation.attachment,
+    exhaustion:
+      limitation.limit === null
+        ? Infinity
+        : limitation.attachment + limitation.limit,
+    application: limitation.application,
+  };
+}
+
+function validateLayerComparability(
+  rule: Extract<DiagnosticReviewRule, { kind: "layer-order" }>,
+  path: string,
+  measures: ReadonlyMap<string, DiagnosticMeasureDefinition>,
+  amountBases: ReadonlyMap<string, AmountBasisDefinition>,
+  derivations: ReadonlyMap<string, DiagnosticDerivedMeasureDefinition>,
+  issues: DiagnosticValidationIssue[],
+): void {
+  const narrowerBasis = measureExpressionBasis(
+    rule.narrower,
+    measures,
+    amountBases,
+  );
+  const broaderBasis = measureExpressionBasis(
+    rule.broader,
+    measures,
+    amountBases,
+  );
+  if (
+    !narrowerBasis ||
+    !broaderBasis ||
+    narrowerBasis.currency !== broaderBasis.currency
+  ) {
+    pushIssue(
+      issues,
+      "incompatible-semantics",
+      path,
+      "Layer-order operands must be amounts with the same currency",
+    );
+    return;
+  }
+  if (rule.comparability.kind === "caller-asserted") return;
+  if (narrowerBasis.perspective !== broaderBasis.perspective) {
+    pushIssue(
+      issues,
+      "incompatible-semantics",
+      path,
+      "Compiler-proven layer order requires the same amount perspective",
+    );
+    return;
+  }
+  const proveMeasures = (
+    narrowerMeasureId: string,
+    broaderMeasureId: string,
+  ): { readonly valid: boolean; readonly hasLayer: boolean } => {
+    const narrowerMeasure = measures.get(narrowerMeasureId);
+    const broaderMeasure = measures.get(broaderMeasureId);
+    const narrowBasis =
+      narrowerMeasure?.kind === "amount" && narrowerMeasure.basisId
+        ? amountBases.get(narrowerMeasure.basisId)
+        : undefined;
+    const broadBasis =
+      broaderMeasure?.kind === "amount" && broaderMeasure.basisId
+        ? amountBases.get(broaderMeasure.basisId)
+        : undefined;
+    if (
+      !narrowBasis ||
+      !broadBasis ||
+      narrowBasis.currency !== broadBasis.currency ||
+      narrowBasis.perspective !== broadBasis.perspective
+    )
+      return { valid: false, hasLayer: false };
+    const narrowComponents = [...narrowBasis.components].sort((a, b) =>
+      a.id < b.id ? -1 : a.id > b.id ? 1 : 0,
+    );
+    const broadComponents = [...broadBasis.components].sort((a, b) =>
+      a.id < b.id ? -1 : a.id > b.id ? 1 : 0,
+    );
+    const narrowTraces = traceLayerComponents(
+      narrowerMeasureId,
+      measures,
+      amountBases,
+      derivations,
+    );
+    const broadTraces = traceLayerComponents(
+      broaderMeasureId,
+      measures,
+      amountBases,
+      derivations,
+    );
+    if (
+      !narrowTraces ||
+      !broadTraces ||
+      narrowComponents.length !== broadComponents.length
+    )
+      return { valid: false, hasLayer: false };
+    let hasLayer = false;
+    for (let index = 0; index < narrowComponents.length; index++) {
+      const narrower = narrowComponents[index]!;
+      const broader = broadComponents[index]!;
+      const narrowerInterval = limitationInterval(narrower.limitation);
+      const broaderInterval = limitationInterval(broader.limitation);
+      const narrowerTrace = narrowTraces.get(narrower.id);
+      const broaderTrace = broadTraces.get(broader.id);
+      if (
+        narrower.id !== broader.id ||
+        narrower.treatment !== broader.treatment ||
+        narrower.treatment === "unknown" ||
+        !narrowerInterval ||
+        !broaderInterval ||
+        !narrowerTrace ||
+        !broaderTrace ||
+        narrowerTrace.rawMeasureId !== broaderTrace.rawMeasureId ||
+        (broaderInterval.application !== null &&
+          narrowerInterval.application !== broaderInterval.application) ||
+        narrowerInterval.attachment < broaderInterval.attachment ||
+        narrowerInterval.exhaustion > broaderInterval.exhaustion
+      )
+        return { valid: false, hasLayer: false };
+      hasLayer ||= narrowerTrace.hasLayer || broaderTrace.hasLayer;
+    }
+    return { valid: true, hasLayer };
+  };
+  const proveExpressions = (
+    narrower: DiagnosticMeasureExpression,
+    broader: DiagnosticMeasureExpression,
+  ): { readonly valid: boolean; readonly hasLayer: boolean } => {
+    if (narrower.op === "measure" && broader.op === "measure")
+      return proveMeasures(narrower.measureId, broader.measureId);
+    if (
+      narrower.op !== "add" ||
+      broader.op !== "add" ||
+      narrower.terms.length !== broader.terms.length
+    )
+      return { valid: false, hasLayer: false };
+    const children = narrower.terms.map((term, index) =>
+      proveExpressions(term, broader.terms[index]!),
+    );
+    return {
+      valid: children.every((item) => item.valid),
+      hasLayer: children.some((item) => item.hasLayer),
+    };
+  };
+  const proof = proveExpressions(rule.narrower, rule.broader);
+  if (!proof.valid || !proof.hasLayer) {
+    pushIssue(
+      issues,
+      "incompatible-semantics",
+      path,
+      "Compiler metadata does not prove that the narrower layer is contained by the broader layer",
+    );
+  }
+}
+
+function validatePeriodAxis(
+  axis: DiagnosticPeriodAxis,
+  issues: DiagnosticValidationIssue[],
+): void {
   if (!isPlainRecord(axis)) {
-    pushIssue(issues, "invalid-type", "$.periodAxis", "Period axis must be an object");
+    pushIssue(
+      issues,
+      "invalid-type",
+      "$.periodAxis",
+      "Period axis must be an object",
+    );
     return;
   }
-  if (!validateFinite(axis.ageOffset, "$.periodAxis.ageOffset", "Period age offset", issues) ||
-      !Number.isSafeInteger(axis.ageOffset)) {
-    pushIssue(issues, "invalid-number", "$.periodAxis.ageOffset", "Period age offset must be a safe integer");
+  if (
+    !validateFinite(
+      axis.ageOffset,
+      "$.periodAxis.ageOffset",
+      "Period age offset",
+      issues,
+    ) ||
+    !Number.isSafeInteger(axis.ageOffset)
+  ) {
+    pushIssue(
+      issues,
+      "invalid-number",
+      "$.periodAxis.ageOffset",
+      "Period age offset must be a safe integer",
+    );
   }
   if (axis.kind === "calendar") {
+    validateAllowedKeys(
+      axis,
+      [
+        "kind",
+        "originCadence",
+        "valuationCadence",
+        "originAnchor",
+        "valuationAnchor",
+        "ageUnit",
+        "ageOffset",
+      ],
+      "$.periodAxis",
+      issues,
+    );
     if (!["month", "quarter", "year"].includes(axis.originCadence)) {
-      pushIssue(issues, "invalid-period", "$.periodAxis.originCadence", "Unknown origin cadence");
+      pushIssue(
+        issues,
+        "invalid-period",
+        "$.periodAxis.originCadence",
+        "Unknown origin cadence",
+      );
     }
     if (!["month", "quarter", "year"].includes(axis.valuationCadence)) {
-      pushIssue(issues, "invalid-period", "$.periodAxis.valuationCadence", "Unknown valuation cadence");
+      pushIssue(
+        issues,
+        "invalid-period",
+        "$.periodAxis.valuationCadence",
+        "Unknown valuation cadence",
+      );
+    }
+    if (axis.originAnchor !== "start" && axis.originAnchor !== "end") {
+      pushIssue(
+        issues,
+        "invalid-period",
+        "$.periodAxis.originAnchor",
+        "Unknown origin anchor",
+      );
+    }
+    if (axis.valuationAnchor !== "start" && axis.valuationAnchor !== "end") {
+      pushIssue(
+        issues,
+        "invalid-period",
+        "$.periodAxis.valuationAnchor",
+        "Unknown valuation anchor",
+      );
     }
     if (axis.ageUnit !== "month") {
-      pushIssue(issues, "invalid-period", "$.periodAxis.ageUnit", "Calendar axes use month age units");
+      pushIssue(
+        issues,
+        "invalid-period",
+        "$.periodAxis.ageUnit",
+        "Calendar axes use month age units",
+      );
     }
     return;
   }
+  validateAllowedKeys(
+    axis,
+    ["kind", "id", "version", "ageUnit", "ageOffset", "origins", "valuations"],
+    "$.periodAxis",
+    issues,
+  );
   if (axis.kind !== "ordered") {
-    pushIssue(issues, "invalid-period", "$.periodAxis.kind", "Unknown period-axis kind");
+    pushIssue(
+      issues,
+      "invalid-period",
+      "$.periodAxis.kind",
+      "Unknown period-axis kind",
+    );
     return;
   }
   validateToken(axis.id, "$.periodAxis.id", "Ordered-axis ID", issues);
-  validateToken(axis.version, "$.periodAxis.version", "Ordered-axis version", issues);
-  validateToken(axis.ageUnit, "$.periodAxis.ageUnit", "Ordered-axis age unit", issues);
+  validateToken(
+    axis.version,
+    "$.periodAxis.version",
+    "Ordered-axis version",
+    issues,
+  );
+  validateToken(
+    axis.ageUnit,
+    "$.periodAxis.ageUnit",
+    "Ordered-axis age unit",
+    issues,
+  );
   for (const side of ["origins", "valuations"] as const) {
-    const coordinates = requireArray(axis[side], `$.periodAxis.${side}`, issues) as readonly DiagnosticPeriodCoordinate[];
+    const coordinates = requireArray(
+      axis[side],
+      `$.periodAxis.${side}`,
+      issues,
+    ) as readonly DiagnosticPeriodCoordinate[];
     const names = new Set<string>();
     const coordinateValues = new Set<number>();
     coordinates.forEach((coordinate, index) => {
       const base = `$.periodAxis.${side}[${index}]`;
-      if (validateToken(coordinate?.label, `${base}.label`, "Period label", issues)) {
-        if (names.has(coordinate.label)) pushIssue(issues, "duplicate-id", `${base}.label`, `Duplicate period label or alias ${coordinate.label}`);
+      if (!isPlainRecord(coordinate)) {
+        pushIssue(
+          issues,
+          "invalid-type",
+          base,
+          "Period coordinate must be an object",
+        );
+        return;
+      }
+      validateAllowedKeys(
+        coordinate,
+        ["label", "aliases", "coordinate"],
+        base,
+        issues,
+      );
+      if (
+        validateToken(
+          coordinate?.label,
+          `${base}.label`,
+          "Period label",
+          issues,
+        )
+      ) {
+        if (names.has(coordinate.label))
+          pushIssue(
+            issues,
+            "duplicate-id",
+            `${base}.label`,
+            `Duplicate period label or alias ${coordinate.label}`,
+          );
         names.add(coordinate.label);
       }
-      if (!validateFinite(coordinate?.coordinate, `${base}.coordinate`, "Period coordinate", issues) ||
-          !Number.isSafeInteger(coordinate.coordinate)) {
-        pushIssue(issues, "invalid-number", `${base}.coordinate`, "Period coordinate must be a safe integer");
+      if (
+        !validateFinite(
+          coordinate?.coordinate,
+          `${base}.coordinate`,
+          "Period coordinate",
+          issues,
+        ) ||
+        !Number.isSafeInteger(coordinate.coordinate)
+      ) {
+        pushIssue(
+          issues,
+          "invalid-number",
+          `${base}.coordinate`,
+          "Period coordinate must be a safe integer",
+        );
       } else if (coordinateValues.has(coordinate.coordinate)) {
-        pushIssue(issues, "duplicate-id", `${base}.coordinate`, `Duplicate period coordinate ${coordinate.coordinate}`);
+        pushIssue(
+          issues,
+          "duplicate-id",
+          `${base}.coordinate`,
+          `Duplicate period coordinate ${coordinate.coordinate}`,
+        );
       } else coordinateValues.add(coordinate.coordinate);
-      for (const [aliasIndex, alias] of (coordinate?.aliases ?? []).entries()) {
-        if (!validateToken(alias, `${base}.aliases[${aliasIndex}]`, "Period alias", issues)) continue;
-        if (names.has(alias)) pushIssue(issues, "duplicate-id", `${base}.aliases[${aliasIndex}]`, `Duplicate period label or alias ${alias}`);
+      const aliases =
+        coordinate.aliases === undefined
+          ? []
+          : requireArray(coordinate.aliases, `${base}.aliases`, issues);
+      for (const [aliasIndex, alias] of aliases.entries()) {
+        if (
+          !validateToken(
+            alias,
+            `${base}.aliases[${aliasIndex}]`,
+            "Period alias",
+            issues,
+          )
+        )
+          continue;
+        if (names.has(alias))
+          pushIssue(
+            issues,
+            "duplicate-id",
+            `${base}.aliases[${aliasIndex}]`,
+            `Duplicate period label or alias ${alias}`,
+          );
         names.add(alias);
       }
     });
@@ -744,37 +1435,121 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
   const issues: DiagnosticValidationIssue[] = [];
   validateJsonValue(value, issues);
   if (!isPlainRecord(value)) {
-    pushIssue(issues, "invalid-type", "$", "Diagnostic definition must be a plain object");
+    pushIssue(
+      issues,
+      "invalid-type",
+      "$",
+      "Diagnostic definition must be a plain object",
+    );
     throw new DiagnosticValidationError(issues);
   }
   const definition = value as unknown as DiagnosticDefinition;
+  validateAllowedKeys(
+    value,
+    [
+      "diagnosticDefinitionVersion",
+      "id",
+      "version",
+      "lossRowGrain",
+      "measures",
+      "countPopulations",
+      "exposureBases",
+      "amountBases",
+      "derivedMeasures",
+      "formulas",
+      "instances",
+      "reviewRules",
+      "periodAxis",
+    ],
+    "$",
+    issues,
+  );
   if (definition.diagnosticDefinitionVersion !== "1.0.0") {
-    pushIssue(issues, "invalid-type", "$.diagnosticDefinitionVersion", "Diagnostic definition version must be 1.0.0");
+    pushIssue(
+      issues,
+      "invalid-type",
+      "$.diagnosticDefinitionVersion",
+      "Diagnostic definition version must be 1.0.0",
+    );
   }
   validateToken(definition.id, "$.id", "Definition ID", issues);
   validateToken(definition.version, "$.version", "Definition version", issues);
-  if (definition.lossRowGrain !== "claim" && definition.lossRowGrain !== "aggregate") {
-    pushIssue(issues, "invalid-type", "$.lossRowGrain", "Loss row grain must be claim or aggregate");
+  if (
+    definition.lossRowGrain !== "claim" &&
+    definition.lossRowGrain !== "aggregate"
+  ) {
+    pushIssue(
+      issues,
+      "invalid-type",
+      "$.lossRowGrain",
+      "Loss row grain must be claim or aggregate",
+    );
   }
 
-  const measures = requireArray(definition.measures, "$.measures", issues) as readonly DiagnosticMeasureDefinition[];
-  const populations = requireArray(definition.countPopulations, "$.countPopulations", issues) as readonly DiagnosticCountPopulationDefinition[];
-  const exposureBases = requireArray(definition.exposureBases, "$.exposureBases", issues) as readonly DiagnosticExposureBasisDefinition[];
-  const amountBases = requireArray(definition.amountBases, "$.amountBases", issues) as readonly AmountBasisDefinition[];
-  const derivations = requireArray(definition.derivedMeasures, "$.derivedMeasures", issues) as readonly DiagnosticDerivedMeasureDefinition[];
-  const formulas = requireArray(definition.formulas, "$.formulas", issues) as readonly DiagnosticFormulaTemplate[];
-  const instances = requireArray(definition.instances, "$.instances", issues) as readonly DiagnosticMetricInstance[];
-  const reviewRules = requireArray(definition.reviewRules, "$.reviewRules", issues) as readonly DiagnosticReviewRule[];
+  const measures = requireArray(
+    definition.measures,
+    "$.measures",
+    issues,
+  ) as readonly DiagnosticMeasureDefinition[];
+  const populations = requireArray(
+    definition.countPopulations,
+    "$.countPopulations",
+    issues,
+  ) as readonly DiagnosticCountPopulationDefinition[];
+  const exposureBases = requireArray(
+    definition.exposureBases,
+    "$.exposureBases",
+    issues,
+  ) as readonly DiagnosticExposureBasisDefinition[];
+  const amountBases = requireArray(
+    definition.amountBases,
+    "$.amountBases",
+    issues,
+  ) as readonly AmountBasisDefinition[];
+  const derivations = requireArray(
+    definition.derivedMeasures,
+    "$.derivedMeasures",
+    issues,
+  ) as readonly DiagnosticDerivedMeasureDefinition[];
+  const formulas = requireArray(
+    definition.formulas,
+    "$.formulas",
+    issues,
+  ) as readonly DiagnosticFormulaTemplate[];
+  const instances = requireArray(
+    definition.instances,
+    "$.instances",
+    issues,
+  ) as readonly DiagnosticMetricInstance[];
+  const reviewRules = requireArray(
+    definition.reviewRules,
+    "$.reviewRules",
+    issues,
+  ) as readonly DiagnosticReviewRule[];
 
   const measureMap = collectCatalog(measures, "$.measures", issues);
-  const populationMap = collectCatalog(populations, "$.countPopulations", issues);
-  const exposureBasisMap = collectCatalog(exposureBases, "$.exposureBases", issues);
+  const populationMap = collectCatalog(
+    populations,
+    "$.countPopulations",
+    issues,
+  );
+  const exposureBasisMap = collectCatalog(
+    exposureBases,
+    "$.exposureBases",
+    issues,
+  );
   const amountBasisMap = collectCatalog(amountBases, "$.amountBases", issues);
   collectCatalog(derivations, "$.derivedMeasures", issues);
-  const derivationsByOutput = new Map<string, DiagnosticDerivedMeasureDefinition>();
+  const derivationsByOutput = new Map<
+    string,
+    DiagnosticDerivedMeasureDefinition
+  >();
   for (const derivation of derivations) {
-    if (isPlainRecord(derivation) && typeof derivation.outputMeasureId === "string" &&
-        !derivationsByOutput.has(derivation.outputMeasureId)) {
+    if (
+      isPlainRecord(derivation) &&
+      typeof derivation.outputMeasureId === "string" &&
+      !derivationsByOutput.has(derivation.outputMeasureId)
+    ) {
       derivationsByOutput.set(derivation.outputMeasureId, derivation);
     }
   }
@@ -784,135 +1559,600 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
 
   populations.forEach((population, index) => {
     const base = `$.countPopulations[${index}]`;
-    validateToken(population.displayName, `${base}.displayName`, "Population display name", issues);
-    validateToken(population.description, `${base}.description`, "Population description", issues);
+    if (!isPlainRecord(population)) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        base,
+        "Count population must be an object",
+      );
+      return;
+    }
+    validateAllowedKeys(
+      population,
+      ["id", "displayName", "subject", "unit", "description", "attributes"],
+      base,
+      issues,
+    );
+    validateToken(
+      population.displayName,
+      `${base}.displayName`,
+      "Population display name",
+      issues,
+    );
+    validateToken(
+      population.description,
+      `${base}.description`,
+      "Population description",
+      issues,
+    );
     validateToken(population.unit, `${base}.unit`, "Population unit", issues);
-    if (!["claim", "claimant", "policy", "occurrence", "other", "unknown"].includes(population.subject)) {
-      pushIssue(issues, "invalid-type", `${base}.subject`, "Unknown count-population subject");
+    if (
+      ![
+        "claim",
+        "claimant",
+        "policy",
+        "occurrence",
+        "other",
+        "unknown",
+      ].includes(population.subject)
+    ) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.subject`,
+        "Unknown count-population subject",
+      );
     }
+    validateScalarAttributes(
+      population.attributes,
+      `${base}.attributes`,
+      issues,
+    );
   });
 
   exposureBases.forEach((basis, index) => {
     const base = `$.exposureBases[${index}]`;
-    validateToken(basis.displayName, `${base}.displayName`, "Exposure-basis display name", issues);
-    validateToken(basis.description, `${base}.description`, "Exposure-basis description", issues);
+    if (!isPlainRecord(basis)) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        base,
+        "Exposure basis must be an object",
+      );
+      return;
+    }
+    validateAllowedKeys(
+      basis,
+      [
+        "id",
+        "displayName",
+        "basis",
+        "unit",
+        "description",
+        "sourceDescription",
+        "attributes",
+      ],
+      base,
+      issues,
+    );
+    validateToken(
+      basis.displayName,
+      `${base}.displayName`,
+      "Exposure-basis display name",
+      issues,
+    );
+    validateToken(
+      basis.description,
+      `${base}.description`,
+      "Exposure-basis description",
+      issues,
+    );
     validateToken(basis.unit, `${base}.unit`, "Exposure-basis unit", issues);
-    if (basis.sourceDescription !== undefined) validateToken(basis.sourceDescription, `${base}.sourceDescription`, "Exposure source description", issues);
-    if (!["earned", "written", "in-force", "other", "unknown"].includes(basis.basis)) {
-      pushIssue(issues, "invalid-type", `${base}.basis`, "Unknown exposure basis");
+    if (basis.sourceDescription !== undefined)
+      validateToken(
+        basis.sourceDescription,
+        `${base}.sourceDescription`,
+        "Exposure source description",
+        issues,
+      );
+    if (
+      !["earned", "written", "in-force", "other", "unknown"].includes(
+        basis.basis,
+      )
+    ) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.basis`,
+        "Unknown exposure basis",
+      );
     }
+    validateScalarAttributes(basis.attributes, `${base}.attributes`, issues);
   });
 
   amountBases.forEach((basis, index) => {
     const base = `$.amountBases[${index}]`;
-    validateToken(basis.displayName, `${base}.displayName`, "Amount-basis display name", issues);
-    validateToken(basis.currency, `${base}.currency`, "Amount-basis currency", issues);
-    if (basis.sourceDescription !== undefined) validateToken(basis.sourceDescription, `${base}.sourceDescription`, "Amount source description", issues);
-    if (!["gross", "net", "ceded", "other", "unknown"].includes(basis.perspective)) {
-      pushIssue(issues, "invalid-type", `${base}.perspective`, "Unknown amount perspective");
+    if (!isPlainRecord(basis)) {
+      pushIssue(issues, "invalid-type", base, "Amount basis must be an object");
+      return;
+    }
+    validateAllowedKeys(
+      basis,
+      [
+        "id",
+        "displayName",
+        "currency",
+        "perspective",
+        "components",
+        "sourceDescription",
+        "attributes",
+      ],
+      base,
+      issues,
+    );
+    validateToken(
+      basis.displayName,
+      `${base}.displayName`,
+      "Amount-basis display name",
+      issues,
+    );
+    validateToken(
+      basis.currency,
+      `${base}.currency`,
+      "Amount-basis currency",
+      issues,
+    );
+    if (basis.sourceDescription !== undefined)
+      validateToken(
+        basis.sourceDescription,
+        `${base}.sourceDescription`,
+        "Amount source description",
+        issues,
+      );
+    if (
+      !["gross", "net", "ceded", "other", "unknown"].includes(basis.perspective)
+    ) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.perspective`,
+        "Unknown amount perspective",
+      );
     }
-    const components = requireArray(basis.components, `${base}.components`, issues) as readonly AmountBasisComponent[];
-    if (components.length === 0) pushIssue(issues, "missing-required", `${base}.components`, "Amount basis requires at least one component");
-    const componentIds = collectCatalog(components, `${base}.components`, issues);
-    if (componentIds.size > 0 && components.every((component) => component.treatment === "excluded")) {
-      pushIssue(issues, "incompatible-semantics", `${base}.components`, "Amount basis cannot exclude every component");
+    validateScalarAttributes(basis.attributes, `${base}.attributes`, issues);
+    const components = requireArray(
+      basis.components,
+      `${base}.components`,
+      issues,
+    ) as readonly AmountBasisComponent[];
+    if (components.length === 0)
+      pushIssue(
+        issues,
+        "missing-required",
+        `${base}.components`,
+        "Amount basis requires at least one component",
+      );
+    const componentIds = collectCatalog(
+      components,
+      `${base}.components`,
+      issues,
+    );
+    if (
+      componentIds.size > 0 &&
+      components.every((component) => component.treatment === "excluded")
+    ) {
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.components`,
+        "Amount basis cannot exclude every component",
+      );
     }
     components.forEach((component, componentIndex) => {
       const componentBase = `${base}.components[${componentIndex}]`;
       if (!isPlainRecord(component)) {
-        pushIssue(issues, "invalid-type", componentBase, "Amount-basis component must be an object");
+        pushIssue(
+          issues,
+          "invalid-type",
+          componentBase,
+          "Amount-basis component must be an object",
+        );
         return;
       }
+      validateAllowedKeys(
+        component,
+        ["id", "treatment", "limitation"],
+        componentBase,
+        issues,
+      );
       if (!["included", "excluded", "unknown"].includes(component.treatment)) {
-        pushIssue(issues, "invalid-type", `${componentBase}.treatment`, "Unknown component treatment");
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${componentBase}.treatment`,
+          "Unknown component treatment",
+        );
       }
       const limitation = component.limitation;
       if (!isPlainRecord(limitation)) {
-        pushIssue(issues, "invalid-type", `${componentBase}.limitation`, "Amount limitation must be an object");
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${componentBase}.limitation`,
+          "Amount limitation must be an object",
+        );
         return;
       }
       if (limitation.kind === "unknown") {
-        if (limitation.description !== undefined) validateToken(limitation.description, `${componentBase}.limitation.description`, "Unknown limitation description", issues);
-      } else if (limitation.kind === "layer" || limitation.kind === "pre-limited") {
-        if (validateFinite(limitation.attachment, `${componentBase}.limitation.attachment`, "Attachment", issues) && limitation.attachment < 0) {
-          pushIssue(issues, "invalid-number", `${componentBase}.limitation.attachment`, "Attachment must be nonnegative");
+        validateAllowedKeys(
+          limitation,
+          ["kind", "description"],
+          `${componentBase}.limitation`,
+          issues,
+        );
+        if (limitation.description !== undefined)
+          validateToken(
+            limitation.description,
+            `${componentBase}.limitation.description`,
+            "Unknown limitation description",
+            issues,
+          );
+      } else if (
+        limitation.kind === "layer" ||
+        limitation.kind === "pre-limited"
+      ) {
+        validateAllowedKeys(
+          limitation,
+          ["kind", "attachment", "limit", "application", "derivation"],
+          `${componentBase}.limitation`,
+          issues,
+        );
+        if (
+          !["claim", "occurrence", "policy", "source-defined"].includes(
+            limitation.application,
+          )
+        ) {
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${componentBase}.limitation.application`,
+            "Unknown limitation application",
+          );
+        }
+        if (
+          validateFinite(
+            limitation.attachment,
+            `${componentBase}.limitation.attachment`,
+            "Attachment",
+            issues,
+          ) &&
+          limitation.attachment < 0
+        ) {
+          pushIssue(
+            issues,
+            "invalid-number",
+            `${componentBase}.limitation.attachment`,
+            "Attachment must be nonnegative",
+          );
         }
         if (limitation.limit !== null) {
-          if (validateFinite(limitation.limit, `${componentBase}.limitation.limit`, "Layer width", issues) && limitation.limit <= 0) {
-            pushIssue(issues, "invalid-number", `${componentBase}.limitation.limit`, "Layer width must be positive");
+          if (
+            validateFinite(
+              limitation.limit,
+              `${componentBase}.limitation.limit`,
+              "Layer width",
+              issues,
+            ) &&
+            limitation.limit <= 0
+          ) {
+            pushIssue(
+              issues,
+              "invalid-number",
+              `${componentBase}.limitation.limit`,
+              "Layer width must be positive",
+            );
           }
-          if (Number.isFinite(limitation.attachment) && Number.isFinite(limitation.limit) && !Number.isFinite(limitation.attachment + limitation.limit)) {
-            pushIssue(issues, "invalid-number", `${componentBase}.limitation.limit`, "Attachment plus layer width must be finite");
+          if (
+            Number.isFinite(limitation.attachment) &&
+            Number.isFinite(limitation.limit) &&
+            !Number.isFinite(limitation.attachment + limitation.limit)
+          ) {
+            pushIssue(
+              issues,
+              "invalid-number",
+              `${componentBase}.limitation.limit`,
+              "Attachment plus layer width must be finite",
+            );
           }
         }
         if (limitation.derivation?.kind === "sdk") {
-          if (limitation.kind !== "layer" || limitation.application !== "claim") {
-            pushIssue(issues, "incompatible-semantics", `${componentBase}.limitation.derivation`, "SDK limitations require a claim layer");
+          if (isPlainRecord(limitation.derivation))
+            validateAllowedKeys(
+              limitation.derivation,
+              ["kind"],
+              `${componentBase}.limitation.derivation`,
+              issues,
+            );
+          if (
+            limitation.kind !== "layer" ||
+            limitation.application !== "claim"
+          ) {
+            pushIssue(
+              issues,
+              "incompatible-semantics",
+              `${componentBase}.limitation.derivation`,
+              "SDK limitations require a claim layer",
+            );
           }
         } else if (limitation.derivation?.kind === "external") {
-          validateToken(limitation.derivation.transformationRef, `${componentBase}.limitation.derivation.transformationRef`, "Transformation reference", issues);
+          if (isPlainRecord(limitation.derivation))
+            validateAllowedKeys(
+              limitation.derivation,
+              ["kind", "actor", "transformationRef"],
+              `${componentBase}.limitation.derivation`,
+              issues,
+            );
+          if (
+            limitation.derivation.actor !== "caller" &&
+            limitation.derivation.actor !== "source"
+          ) {
+            pushIssue(
+              issues,
+              "invalid-type",
+              `${componentBase}.limitation.derivation.actor`,
+              "External derivation actor must be caller or source",
+            );
+          }
+          validateToken(
+            limitation.derivation.transformationRef,
+            `${componentBase}.limitation.derivation.transformationRef`,
+            "Transformation reference",
+            issues,
+          );
         } else {
-          pushIssue(issues, "invalid-type", `${componentBase}.limitation.derivation`, "Limited basis requires a derivation record");
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${componentBase}.limitation.derivation`,
+            "Limited basis requires a derivation record",
+          );
         }
       } else if (limitation.kind !== "unlimited") {
-        pushIssue(issues, "invalid-type", `${componentBase}.limitation.kind`, "Unknown amount limitation kind");
-      }
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${componentBase}.limitation.kind`,
+          "Unknown amount limitation kind",
+        );
+      } else
+        validateAllowedKeys(
+          limitation,
+          ["kind"],
+          `${componentBase}.limitation`,
+          issues,
+        );
     });
   });
 
   measures.forEach((measure, index) => {
     const base = `$.measures[${index}]`;
-    validateToken(measure.displayName, `${base}.displayName`, "Measure display name", issues);
-    validateToken(measure.description, `${base}.description`, "Measure description", issues);
+    if (!isPlainRecord(measure)) {
+      pushIssue(issues, "invalid-type", base, "Measure must be an object");
+      return;
+    }
+    validateAllowedKeys(
+      measure,
+      [
+        "id",
+        "displayName",
+        "description",
+        "source",
+        "kind",
+        "unit",
+        "developmentSemantics",
+        "aggregation",
+        "missing",
+        "basisId",
+        "countPopulationId",
+        "exposureBasisId",
+        "exposureTiming",
+      ],
+      base,
+      issues,
+    );
+    validateToken(
+      measure.displayName,
+      `${base}.displayName`,
+      "Measure display name",
+      issues,
+    );
+    validateToken(
+      measure.description,
+      `${base}.description`,
+      "Measure description",
+      issues,
+    );
     validateToken(measure.unit, `${base}.unit`, "Measure unit", issues);
-    if (measure.aggregation !== "sum") pushIssue(issues, "incompatible-semantics", `${base}.aggregation`, "Only sum aggregation is supported");
-    if (measure.missing !== "unknown" && measure.missing !== "zero") pushIssue(issues, "invalid-type", `${base}.missing`, "Unknown missing-value policy");
-    if (!["cumulative", "incremental", "point-in-time", "unknown"].includes(measure.developmentSemantics)) {
-      pushIssue(issues, "invalid-type", `${base}.developmentSemantics`, "Unknown development semantics");
+    if (measure.aggregation !== "sum")
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.aggregation`,
+        "Only sum aggregation is supported",
+      );
+    if (measure.missing !== "unknown" && measure.missing !== "zero")
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.missing`,
+        "Unknown missing-value policy",
+      );
+    if (
+      !["cumulative", "incremental", "point-in-time", "unknown"].includes(
+        measure.developmentSemantics,
+      )
+    ) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.developmentSemantics`,
+        "Unknown development semantics",
+      );
     }
     if (measure.kind === "amount") {
-      const basis = measure.basisId ? amountBasisMap.get(measure.basisId) : undefined;
-      if (!basis) pushIssue(issues, "unknown-reference", `${base}.basisId`, "Amount measure requires an existing amount basis");
-      else if (measure.unit !== basis.currency) pushIssue(issues, "incompatible-semantics", `${base}.unit`, "Amount measure unit must equal basis currency");
-      if (measure.countPopulationId !== undefined || measure.exposureBasisId !== undefined || measure.exposureTiming !== undefined) {
-        pushIssue(issues, "incompatible-semantics", base, "Amount measure has inapplicable population or exposure semantics");
+      const basis = measure.basisId
+        ? amountBasisMap.get(measure.basisId)
+        : undefined;
+      if (!basis)
+        pushIssue(
+          issues,
+          "unknown-reference",
+          `${base}.basisId`,
+          "Amount measure requires an existing amount basis",
+        );
+      else if (measure.unit !== basis.currency)
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.unit`,
+          "Amount measure unit must equal basis currency",
+        );
+      if (
+        measure.countPopulationId !== undefined ||
+        measure.exposureBasisId !== undefined ||
+        measure.exposureTiming !== undefined
+      ) {
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          base,
+          "Amount measure has inapplicable population or exposure semantics",
+        );
       }
     } else if (measure.kind === "count") {
-      const population = measure.countPopulationId ? populationMap.get(measure.countPopulationId) : undefined;
-      if (!population) pushIssue(issues, "unknown-reference", `${base}.countPopulationId`, "Count measure requires an existing count population");
-      else if (measure.unit !== population.unit) pushIssue(issues, "incompatible-semantics", `${base}.unit`, "Count measure unit must equal population unit");
-      if (measure.basisId !== undefined || measure.exposureBasisId !== undefined || measure.exposureTiming !== undefined) {
-        pushIssue(issues, "incompatible-semantics", base, "Count measure has inapplicable amount or exposure semantics");
+      const population = measure.countPopulationId
+        ? populationMap.get(measure.countPopulationId)
+        : undefined;
+      if (!population)
+        pushIssue(
+          issues,
+          "unknown-reference",
+          `${base}.countPopulationId`,
+          "Count measure requires an existing count population",
+        );
+      else if (measure.unit !== population.unit)
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.unit`,
+          "Count measure unit must equal population unit",
+        );
+      if (
+        measure.basisId !== undefined ||
+        measure.exposureBasisId !== undefined ||
+        measure.exposureTiming !== undefined
+      ) {
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          base,
+          "Count measure has inapplicable amount or exposure semantics",
+        );
       }
     } else if (measure.kind === "exposure") {
-      const basis = measure.exposureBasisId ? exposureBasisMap.get(measure.exposureBasisId) : undefined;
-      if (!basis) pushIssue(issues, "unknown-reference", `${base}.exposureBasisId`, "Exposure measure requires an existing exposure basis");
-      else if (measure.unit !== basis.unit) pushIssue(issues, "incompatible-semantics", `${base}.unit`, "Exposure measure unit must equal exposure-basis unit");
-      if (measure.source !== "exposure") pushIssue(issues, "incompatible-semantics", `${base}.source`, "Exposure measure source must be exposure");
-      if (measure.exposureTiming !== "origin-static" && measure.exposureTiming !== "valuation-specific") {
-        pushIssue(issues, "missing-required", `${base}.exposureTiming`, "Exposure measure requires timing");
+      const basis = measure.exposureBasisId
+        ? exposureBasisMap.get(measure.exposureBasisId)
+        : undefined;
+      if (!basis)
+        pushIssue(
+          issues,
+          "unknown-reference",
+          `${base}.exposureBasisId`,
+          "Exposure measure requires an existing exposure basis",
+        );
+      else if (measure.unit !== basis.unit)
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.unit`,
+          "Exposure measure unit must equal exposure-basis unit",
+        );
+      if (measure.source !== "exposure")
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.source`,
+          "Exposure measure source must be exposure",
+        );
+      if (
+        measure.exposureTiming !== "origin-static" &&
+        measure.exposureTiming !== "valuation-specific"
+      ) {
+        pushIssue(
+          issues,
+          "missing-required",
+          `${base}.exposureTiming`,
+          "Exposure measure requires timing",
+        );
       }
-      if (measure.missing !== "unknown") pushIssue(issues, "incompatible-semantics", `${base}.missing`, "Exposure missingness must remain unknown");
-      if (measure.basisId !== undefined || measure.countPopulationId !== undefined) {
-        pushIssue(issues, "incompatible-semantics", base, "Exposure measure has inapplicable amount or population semantics");
+      if (measure.missing !== "unknown")
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.missing`,
+          "Exposure missingness must remain unknown",
+        );
+      if (
+        measure.basisId !== undefined ||
+        measure.countPopulationId !== undefined
+      ) {
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          base,
+          "Exposure measure has inapplicable amount or population semantics",
+        );
       }
     } else {
       pushIssue(issues, "invalid-type", `${base}.kind`, "Unknown measure kind");
     }
-    if (measure.kind !== "exposure" && measure.source !== "loss" && measure.source !== "derived") {
-      pushIssue(issues, "invalid-type", `${base}.source`, "Non-exposure measure source must be loss or derived");
+    if (
+      measure.kind !== "exposure" &&
+      measure.source !== "loss" &&
+      measure.source !== "derived"
+    ) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.source`,
+        "Non-exposure measure source must be loss or derived",
+      );
     }
     if (measure.kind !== "exposure" && measure.source === "exposure") {
-      pushIssue(issues, "incompatible-semantics", `${base}.source`, "Only exposure measures may use exposure source");
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.source`,
+        "Only exposure measures may use exposure source",
+      );
     }
     if (measure.kind === "amount" && measure.basisId) {
       const basis = amountBasisMap.get(measure.basisId);
-      const hasSdkLimitation = basis?.components.some((component) =>
-        (component.limitation.kind === "layer" || component.limitation.kind === "pre-limited") &&
-        component.limitation.derivation.kind === "sdk",
-      ) ?? false;
+      const hasSdkLimitation =
+        basis?.components.some(
+          (component) =>
+            (component.limitation.kind === "layer" ||
+              component.limitation.kind === "pre-limited") &&
+            component.limitation.derivation.kind === "sdk",
+        ) ?? false;
       if (hasSdkLimitation && measure.source !== "derived") {
-        pushIssue(issues, "incompatible-semantics", `${base}.source`, "SDK-limited amount measures must be derived");
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.source`,
+          "SDK-limited amount measures must be derived",
+        );
       }
     }
   });
@@ -921,89 +2161,308 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
   const formulaRoleUsage = new Map<string, readonly string[]>();
   formulas.forEach((formula, index) => {
     const base = `$.formulas[${index}]`;
-    validateToken(formula.version, `${base}.version`, "Formula version", issues);
+    if (!isPlainRecord(formula)) {
+      pushIssue(issues, "invalid-type", base, "Formula must be an object");
+      return;
+    }
+    validateAllowedKeys(
+      formula,
+      [
+        "id",
+        "version",
+        "roles",
+        "numerator",
+        "denominator",
+        "denominatorPolicy",
+      ],
+      base,
+      issues,
+    );
+    validateToken(
+      formula.version,
+      `${base}.version`,
+      "Formula version",
+      issues,
+    );
     if (formula.denominatorPolicy !== "positive-or-null") {
-      pushIssue(issues, "incompatible-semantics", `${base}.denominatorPolicy`, "Unknown denominator policy");
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.denominatorPolicy`,
+        "Unknown denominator policy",
+      );
     }
     if (!isPlainRecord(formula.roles)) {
-      pushIssue(issues, "invalid-type", `${base}.roles`, "Formula roles must be an object");
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.roles`,
+        "Formula roles must be an object",
+      );
       return;
     }
     for (const [roleName, role] of Object.entries(formula.roles)) {
-      validateToken(roleName, propertyPath(`${base}.roles`, roleName), "Formula role", issues);
-      if (!isPlainRecord(role) || !["count", "amount", "exposure"].includes(role.kind)) {
-        pushIssue(issues, "invalid-type", propertyPath(`${base}.roles`, roleName), "Formula role has an invalid kind");
+      validateToken(
+        roleName,
+        propertyPath(`${base}.roles`, roleName),
+        "Formula role",
+        issues,
+      );
+      if (
+        !isPlainRecord(role) ||
+        !["count", "amount", "exposure"].includes(role.kind)
+      ) {
+        pushIssue(
+          issues,
+          "invalid-type",
+          propertyPath(`${base}.roles`, roleName),
+          "Formula role has an invalid kind",
+        );
+      } else {
+        const rolePath = propertyPath(`${base}.roles`, roleName);
+        validateAllowedKeys(
+          role,
+          ["kind", "compatibilityGroup", "developmentSemantics"],
+          rolePath,
+          issues,
+        );
+        if (
+          role.developmentSemantics !== undefined &&
+          !["cumulative", "incremental", "point-in-time", "unknown"].includes(
+            role.developmentSemantics as string,
+          )
+        ) {
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${rolePath}.developmentSemantics`,
+            "Unknown formula-role development semantics",
+          );
+        }
       }
-      if (role.compatibilityGroup !== undefined) validateToken(role.compatibilityGroup, `${propertyPath(`${base}.roles`, roleName)}.compatibilityGroup`, "Compatibility group", issues);
+      if (role.compatibilityGroup !== undefined)
+        validateToken(
+          role.compatibilityGroup,
+          `${propertyPath(`${base}.roles`, roleName)}.compatibilityGroup`,
+          "Compatibility group",
+          issues,
+        );
     }
-    const numerator = walkDiagnosticExpression(formula.numerator, "role", `${base}.numerator`, issues);
-    const denominator = walkDiagnosticExpression(formula.denominator, "role", `${base}.denominator`, issues);
+    const numerator = walkDiagnosticExpression(
+      formula.numerator,
+      "role",
+      `${base}.numerator`,
+      issues,
+    );
+    const denominator = walkDiagnosticExpression(
+      formula.denominator,
+      "role",
+      `${base}.denominator`,
+      issues,
+    );
     definitionExpressionNodes += numerator.nodeCount + denominator.nodeCount;
-    const used = [...new Set([...numerator.dependencies, ...denominator.dependencies])].sort();
+    const used = [
+      ...new Set([...numerator.dependencies, ...denominator.dependencies]),
+    ].sort();
     formulaRoleUsage.set(formula.id, used);
     for (const role of used) {
-      if (!Object.prototype.hasOwnProperty.call(formula.roles, role)) {
-        pushIssue(issues, "unknown-reference", base, `Formula ${formula.id} references unknown role ${role}`);
+      if (!hasDiagnosticOwn(formula.roles, role)) {
+        pushIssue(
+          issues,
+          "unknown-reference",
+          base,
+          `Formula ${formula.id} references unknown role ${role}`,
+        );
       }
     }
     for (const role of Object.keys(formula.roles)) {
-      if (!used.includes(role)) pushIssue(issues, "incompatible-semantics", propertyPath(`${base}.roles`, role), `Formula role ${role} is unused`);
+      if (!used.includes(role))
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          propertyPath(`${base}.roles`, role),
+          `Formula role ${role} is unused`,
+        );
     }
-    for (const [side, walked] of [["numerator", numerator], ["denominator", denominator]] as const) {
-      const kinds = new Set(walked.dependencies.map((role) => formula.roles[role]?.kind).filter(Boolean));
-      if (kinds.size > 1) pushIssue(issues, "incompatible-semantics", `${base}.${side}`, "Formula arithmetic combines different role kinds");
+    for (const [side, walked] of [
+      ["numerator", numerator],
+      ["denominator", denominator],
+    ] as const) {
+      const kinds = new Set(
+        walked.dependencies
+          .map((role) => formula.roles[role]?.kind)
+          .filter(Boolean),
+      );
+      if (kinds.size > 1)
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.${side}`,
+          "Formula arithmetic combines different role kinds",
+        );
     }
   });
 
   const instanceRuleIds = new Set<string>();
   instances.forEach((instance, index) => {
     const base = `$.instances[${index}]`;
-    validateToken(instance.version, `${base}.version`, "Instance version", issues);
-    validateToken(instance.formulaId, `${base}.formulaId`, "Formula reference", issues);
+    if (!isPlainRecord(instance)) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        base,
+        "Metric instance must be an object",
+      );
+      return;
+    }
+    validateAllowedKeys(
+      instance,
+      ["id", "version", "formulaId", "bindings", "presentation", "rules"],
+      base,
+      issues,
+    );
+    validateToken(
+      instance.version,
+      `${base}.version`,
+      "Instance version",
+      issues,
+    );
+    validateToken(
+      instance.formulaId,
+      `${base}.formulaId`,
+      "Formula reference",
+      issues,
+    );
     const formula = formulaMap.get(instance.formulaId);
     if (!formula) {
-      pushIssue(issues, "unknown-reference", `${base}.formulaId`, `Unknown formula ${instance.formulaId}`);
+      pushIssue(
+        issues,
+        "unknown-reference",
+        `${base}.formulaId`,
+        `Unknown formula ${instance.formulaId}`,
+      );
       return;
     }
     if (!isPlainRecord(instance.bindings)) {
-      pushIssue(issues, "invalid-type", `${base}.bindings`, "Instance bindings must be an object");
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.bindings`,
+        "Instance bindings must be an object",
+      );
       return;
     }
     const usedRoles = formulaRoleUsage.get(formula.id) ?? [];
-    const bindingSemantics = new Map<string, ReturnType<typeof expressionSemantics>>();
+    const bindingSemantics = new Map<
+      string,
+      ReturnType<typeof expressionSemantics>
+    >();
     for (const roleName of usedRoles) {
-      if (!Object.prototype.hasOwnProperty.call(instance.bindings, roleName)) {
-        pushIssue(issues, "missing-required", propertyPath(`${base}.bindings`, roleName), `Missing binding for role ${roleName}`);
+      if (!hasDiagnosticOwn(instance.bindings, roleName)) {
+        pushIssue(
+          issues,
+          "missing-required",
+          propertyPath(`${base}.bindings`, roleName),
+          `Missing binding for role ${roleName}`,
+        );
         continue;
       }
       const expression = instance.bindings[roleName]!;
-      const semantics = expressionSemantics(expression, propertyPath(`${base}.bindings`, roleName), measureMap, issues);
+      const semantics = expressionSemantics(
+        expression,
+        propertyPath(`${base}.bindings`, roleName),
+        measureMap,
+        issues,
+      );
       bindingSemantics.set(roleName, semantics);
-      definitionExpressionNodes += walkDiagnosticExpression(expression, "measure", propertyPath(`${base}.bindings`, roleName), []).nodeCount;
+      definitionExpressionNodes += walkDiagnosticExpression(
+        expression,
+        "measure",
+        propertyPath(`${base}.bindings`, roleName),
+        [],
+      ).nodeCount;
       const role = formula.roles[roleName]!;
-      const boundMeasures = semantics.measureIds.map((id) => measureMap.get(id)).filter((item): item is DiagnosticMeasureDefinition => item !== undefined);
+      const boundMeasures = semantics.measureIds
+        .map((id) => measureMap.get(id))
+        .filter(
+          (item): item is DiagnosticMeasureDefinition => item !== undefined,
+        );
       if (boundMeasures.some((measure) => measure.kind !== role.kind)) {
-        pushIssue(issues, "incompatible-semantics", propertyPath(`${base}.bindings`, roleName), `Binding kind does not match role ${roleName}`);
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          propertyPath(`${base}.bindings`, roleName),
+          `Binding kind does not match role ${roleName}`,
+        );
       }
       if (role.developmentSemantics !== undefined) {
-        const leaves = transitiveMeasureIds(semantics.measureIds, derivationsByOutput)
+        const leaves = transitiveMeasureIds(
+          semantics.measureIds,
+          derivationsByOutput,
+        )
           .map((id) => measureMap.get(id))
-          .filter((measure): measure is DiagnosticMeasureDefinition => measure !== undefined);
-        if (leaves.some((measure) => measure.developmentSemantics !== role.developmentSemantics)) {
-          pushIssue(issues, "incompatible-semantics", propertyPath(`${base}.bindings`, roleName), `Transitive binding development semantics do not match role ${roleName}`);
+          .filter(
+            (measure): measure is DiagnosticMeasureDefinition =>
+              measure !== undefined,
+          );
+        if (
+          leaves.some(
+            (measure) =>
+              measure.developmentSemantics !== role.developmentSemantics,
+          )
+        ) {
+          pushIssue(
+            issues,
+            "incompatible-semantics",
+            propertyPath(`${base}.bindings`, roleName),
+            `Transitive binding development semantics do not match role ${roleName}`,
+          );
         }
       }
     }
-    for (const [side, roleExpression] of [["numerator", formula.numerator], ["denominator", formula.denominator]] as const) {
-      const roleIds = walkDiagnosticExpression(roleExpression, "role", `${base}.${side}`, []).dependencies;
-      const signatures = new Set(roleIds.map((roleId) => bindingSemantics.get(roleId)?.signature).filter((signature): signature is string => signature !== null && signature !== undefined));
+    const calculationSignatures = new Map<
+      "numerator" | "denominator",
+      string | null
+    >();
+    for (const [side, roleExpression] of [
+      ["numerator", formula.numerator],
+      ["denominator", formula.denominator],
+    ] as const) {
+      const roleIds = walkDiagnosticExpression(
+        roleExpression,
+        "role",
+        `${base}.${side}`,
+        [],
+      ).dependencies;
+      const signatures = new Set(
+        roleIds
+          .map((roleId) => bindingSemantics.get(roleId)?.signature)
+          .filter(
+            (signature): signature is string =>
+              signature !== null && signature !== undefined,
+          ),
+      );
+      calculationSignatures.set(
+        side,
+        signatures.size === 1 ? [...signatures][0]! : null,
+      );
       if (signatures.size > 1) {
-        pushIssue(issues, "incompatible-semantics", `${base}.bindings`, `Bound ${side} arithmetic combines incompatible semantics`);
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.bindings`,
+          `Bound ${side} arithmetic combines incompatible semantics`,
+        );
       }
     }
     for (const binding of Object.keys(instance.bindings)) {
       if (!usedRoles.includes(binding)) {
-        pushIssue(issues, "unknown-reference", propertyPath(`${base}.bindings`, binding), `Unexpected binding for role ${binding}`);
+        pushIssue(
+          issues,
+          "unknown-reference",
+          propertyPath(`${base}.bindings`, binding),
+          `Unexpected binding for role ${binding}`,
+        );
       }
     }
     const compatibility = new Map<string, string>();
@@ -1011,67 +2470,366 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
       const role = formula.roles[roleName]!;
       const binding = instance.bindings[roleName];
       if (!role.compatibilityGroup || !binding) continue;
-      const semantics = expressionSemantics(binding, propertyPath(`${base}.bindings`, roleName), measureMap, []);
+      const semantics = expressionSemantics(
+        binding,
+        propertyPath(`${base}.bindings`, roleName),
+        measureMap,
+        [],
+      );
       if (semantics.signature === null) continue;
       const previous = compatibility.get(role.compatibilityGroup);
       if (previous !== undefined && previous !== semantics.signature) {
-        pushIssue(issues, "incompatible-semantics", propertyPath(`${base}.bindings`, roleName), `Compatibility group ${role.compatibilityGroup} binds different semantics`);
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          propertyPath(`${base}.bindings`, roleName),
+          `Compatibility group ${role.compatibilityGroup} binds different semantics`,
+        );
       } else compatibility.set(role.compatibilityGroup, semantics.signature);
     }
+    if (!isPlainRecord(instance.presentation)) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.presentation`,
+        "Metric presentation must be an object",
+      );
+    } else
+      validateAllowedKeys(
+        instance.presentation,
+        [
+          "displayName",
+          "description",
+          "displayUnit",
+          "scale",
+          "numeratorLabel",
+          "denominatorLabel",
+        ],
+        `${base}.presentation`,
+        issues,
+      );
     for (const [key, text] of [
       ["displayName", instance.presentation?.displayName],
       ["description", instance.presentation?.description],
       ["displayUnit", instance.presentation?.displayUnit],
       ["numeratorLabel", instance.presentation?.numeratorLabel],
       ["denominatorLabel", instance.presentation?.denominatorLabel],
-    ] as const) validateToken(text, `${base}.presentation.${key}`, `Presentation ${key}`, issues);
-    if (!validateFinite(instance.presentation?.scale, `${base}.presentation.scale`, "Presentation scale", issues) || instance.presentation.scale <= 0) {
-      pushIssue(issues, "invalid-number", `${base}.presentation.scale`, "Presentation scale must be positive");
+    ] as const)
+      validateToken(
+        text,
+        `${base}.presentation.${key}`,
+        `Presentation ${key}`,
+        issues,
+      );
+    if (
+      !validateFinite(
+        instance.presentation?.scale,
+        `${base}.presentation.scale`,
+        "Presentation scale",
+        issues,
+      ) ||
+      instance.presentation.scale <= 0
+    ) {
+      pushIssue(
+        issues,
+        "invalid-number",
+        `${base}.presentation.scale`,
+        "Presentation scale must be positive",
+      );
     }
-    requireArray(instance.rules, `${base}.rules`, issues).forEach((rawRule, ruleIndex) => {
-      const rule = rawRule as DiagnosticComparisonRule;
-      const ruleBase = `${base}.rules[${ruleIndex}]`;
-      if (validateToken(rule.id, `${ruleBase}.id`, "Metric rule ID", issues)) {
-        if (rule.id.startsWith("diagnostic/structural/")) pushIssue(issues, "incompatible-semantics", `${ruleBase}.id`, "Metric rule ID uses the reserved structural prefix");
-        if (instanceRuleIds.has(rule.id) || reviewRuleMap.has(rule.id)) pushIssue(issues, "duplicate-id", `${ruleBase}.id`, `Duplicate rule ID ${rule.id}`);
-        instanceRuleIds.add(rule.id);
-      }
-      validateToken(rule.code, `${ruleBase}.code`, "Metric rule code", issues);
-      validateToken(rule.message, `${ruleBase}.message`, "Metric rule message", issues);
-      validateTolerance(rule.when?.tolerance, `${ruleBase}.when.tolerance`, issues);
-      for (const [side, operand] of [["left", rule.when?.left], ["right", rule.when?.right]] as const) {
-        const operandPath = `${ruleBase}.when.${side}`;
-        if (operand?.source === "measure") {
-          const semantic = expressionSemantics(operand.expression, `${operandPath}.expression`, measureMap, issues);
-          definitionExpressionNodes += 1 + walkDiagnosticExpression(operand.expression, "measure", `${operandPath}.expression`, []).nodeCount;
-          void semantic;
-        } else {
-          definitionExpressionNodes += 1;
-          if (operand?.source === "constant") validateFinite(operand.value, `${operandPath}.value`, "Rule constant", issues);
+    requireArray(instance.rules, `${base}.rules`, issues).forEach(
+      (rawRule, ruleIndex) => {
+        const ruleBase = `${base}.rules[${ruleIndex}]`;
+        if (!isPlainRecord(rawRule)) {
+          pushIssue(
+            issues,
+            "invalid-type",
+            ruleBase,
+            "Metric rule must be an object",
+          );
+          return;
         }
-      }
-    });
+        const rule = rawRule as unknown as DiagnosticComparisonRule;
+        validateAllowedKeys(
+          rawRule,
+          ["id", "code", "message", "severity", "when"],
+          ruleBase,
+          issues,
+        );
+        if (
+          validateToken(rule.id, `${ruleBase}.id`, "Metric rule ID", issues)
+        ) {
+          if (rule.id.startsWith("diagnostic/structural/"))
+            pushIssue(
+              issues,
+              "incompatible-semantics",
+              `${ruleBase}.id`,
+              "Metric rule ID uses the reserved structural prefix",
+            );
+          if (instanceRuleIds.has(rule.id) || reviewRuleMap.has(rule.id))
+            pushIssue(
+              issues,
+              "duplicate-id",
+              `${ruleBase}.id`,
+              `Duplicate rule ID ${rule.id}`,
+            );
+          instanceRuleIds.add(rule.id);
+        }
+        validateToken(
+          rule.code,
+          `${ruleBase}.code`,
+          "Metric rule code",
+          issues,
+        );
+        validateToken(
+          rule.message,
+          `${ruleBase}.message`,
+          "Metric rule message",
+          issues,
+        );
+        if (rule.severity !== "warning" && rule.severity !== "fail")
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${ruleBase}.severity`,
+            "Metric rule severity must be warning or fail",
+          );
+        if (!isPlainRecord(rule.when)) {
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${ruleBase}.when`,
+            "Metric rule predicate must be an object",
+          );
+          return;
+        }
+        validateAllowedKeys(
+          rule.when,
+          ["left", "operator", "right", "tolerance"],
+          `${ruleBase}.when`,
+          issues,
+        );
+        if (rule.when.tolerance !== undefined) {
+          if (!isPlainRecord(rule.when.tolerance))
+            pushIssue(
+              issues,
+              "invalid-type",
+              `${ruleBase}.when.tolerance`,
+              "Tolerance must be an object",
+            );
+          else
+            validateAllowedKeys(
+              rule.when.tolerance,
+              ["absolute", "relative"],
+              `${ruleBase}.when.tolerance`,
+              issues,
+            );
+        }
+        if (
+          !["lt", "lte", "eq", "neq", "gte", "gt"].includes(rule.when.operator)
+        )
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${ruleBase}.when.operator`,
+            "Unknown metric comparison operator",
+          );
+        validateTolerance(
+          rule.when?.tolerance,
+          `${ruleBase}.when.tolerance`,
+          issues,
+        );
+        const operandSignatures = new Map<
+          "left" | "right",
+          string | null | undefined
+        >();
+        for (const [side, operand] of [
+          ["left", rule.when?.left],
+          ["right", rule.when?.right],
+        ] as const) {
+          const operandPath = `${ruleBase}.when.${side}`;
+          if (isPlainRecord(operand)) {
+            const allowed =
+              operand.source === "measure"
+                ? ["source", "expression"]
+                : operand.source === "calculation"
+                  ? ["source", "field"]
+                  : operand.source === "constant"
+                    ? ["source", "value"]
+                    : ["source"];
+            validateAllowedKeys(operand, allowed, operandPath, issues);
+          }
+          if (operand?.source === "measure") {
+            const semantic = expressionSemantics(
+              operand.expression,
+              `${operandPath}.expression`,
+              measureMap,
+              issues,
+              2,
+            );
+            const operandNodes =
+              1 +
+              walkDiagnosticExpression(
+                operand.expression,
+                "measure",
+                `${operandPath}.expression`,
+                [],
+              ).nodeCount;
+            definitionExpressionNodes += operandNodes;
+            if (operandNodes > MAX_DIAGNOSTIC_EXPRESSION_NODES) {
+              pushIssue(
+                issues,
+                "expression-limit",
+                operandPath,
+                `Metric rule operand node count exceeds ${MAX_DIAGNOSTIC_EXPRESSION_NODES}`,
+              );
+            }
+            operandSignatures.set(side, semantic.signature);
+          } else if (operand?.source === "calculation") {
+            definitionExpressionNodes += 1;
+            if (
+              operand.field !== "numerator" &&
+              operand.field !== "denominator"
+            )
+              pushIssue(
+                issues,
+                "invalid-type",
+                `${operandPath}.field`,
+                "Unknown calculation field",
+              );
+            else
+              operandSignatures.set(
+                side,
+                calculationSignatures.get(operand.field),
+              );
+          } else if (operand?.source === "constant") {
+            definitionExpressionNodes += 1;
+            operandSignatures.set(side, undefined);
+            validateFinite(
+              operand.value,
+              `${operandPath}.value`,
+              "Rule constant",
+              issues,
+            );
+          } else
+            pushIssue(
+              issues,
+              "invalid-type",
+              operandPath,
+              "Unknown metric rule operand",
+            );
+        }
+        const leftSignature = operandSignatures.get("left");
+        const rightSignature = operandSignatures.get("right");
+        if (
+          leftSignature !== undefined &&
+          rightSignature !== undefined &&
+          leftSignature !== null &&
+          rightSignature !== null &&
+          leftSignature !== rightSignature
+        ) {
+          pushIssue(
+            issues,
+            "incompatible-semantics",
+            `${ruleBase}.when`,
+            "Metric comparison operands must have identical quantity semantics",
+          );
+        }
+      },
+    );
   });
 
   const derivedOutputs = new Map<string, DiagnosticDerivedMeasureDefinition>();
   derivations.forEach((derivation, index) => {
     const base = `$.derivedMeasures[${index}]`;
-    validateToken(derivation.outputMeasureId, `${base}.outputMeasureId`, "Derived output measure", issues);
+    if (!isPlainRecord(derivation)) {
+      pushIssue(
+        issues,
+        "invalid-type",
+        base,
+        "Derived measure must be an object",
+      );
+      return;
+    }
+    validateAllowedKeys(
+      derivation,
+      ["id", "outputMeasureId", "expression"],
+      base,
+      issues,
+    );
+    validateToken(
+      derivation.outputMeasureId,
+      `${base}.outputMeasureId`,
+      "Derived output measure",
+      issues,
+    );
     const output = measureMap.get(derivation.outputMeasureId);
-    if (!output) pushIssue(issues, "unknown-reference", `${base}.outputMeasureId`, `Unknown derived output ${derivation.outputMeasureId}`);
-    else if (output.source !== "derived") pushIssue(issues, "incompatible-semantics", `${base}.outputMeasureId`, "Derivation output must declare source derived");
-    if (derivedOutputs.has(derivation.outputMeasureId)) pushIssue(issues, "duplicate-id", `${base}.outputMeasureId`, `Duplicate derived output ${derivation.outputMeasureId}`);
+    if (!output)
+      pushIssue(
+        issues,
+        "unknown-reference",
+        `${base}.outputMeasureId`,
+        `Unknown derived output ${derivation.outputMeasureId}`,
+      );
+    else if (output.source !== "derived")
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.outputMeasureId`,
+        "Derivation output must declare source derived",
+      );
+    if (derivedOutputs.has(derivation.outputMeasureId))
+      pushIssue(
+        issues,
+        "duplicate-id",
+        `${base}.outputMeasureId`,
+        `Duplicate derived output ${derivation.outputMeasureId}`,
+      );
     derivedOutputs.set(derivation.outputMeasureId, derivation);
-    const walked = walkDiagnosticExpression(derivation.expression, "claim", `${base}.expression`, issues);
+    const walked = walkDiagnosticExpression(
+      derivation.expression,
+      "claim",
+      `${base}.expression`,
+      issues,
+    );
     definitionExpressionNodes += walked.nodeCount;
-    for (const id of walked.dependencies) if (!measureMap.has(id)) pushIssue(issues, "unknown-reference", `${base}.expression`, `Unknown derivation measure ${id}`);
-    const transitiveIds = transitiveMeasureIds(walked.dependencies, derivationsByOutput);
-    const transitiveInputs = transitiveIds.map((id) => measureMap.get(id)).filter((item): item is DiagnosticMeasureDefinition => item !== undefined);
-    if (output && transitiveInputs.some((input) => input.developmentSemantics !== output.developmentSemantics)) {
-      pushIssue(issues, "incompatible-semantics", `${base}.expression`, "Derived output and inputs must share development semantics");
+    for (const id of walked.dependencies)
+      if (!measureMap.has(id))
+        pushIssue(
+          issues,
+          "unknown-reference",
+          `${base}.expression`,
+          `Unknown derivation measure ${id}`,
+        );
+    const transitiveIds = transitiveMeasureIds(
+      walked.dependencies,
+      derivationsByOutput,
+    );
+    const transitiveInputs = transitiveIds
+      .map((id) => measureMap.get(id))
+      .filter(
+        (item): item is DiagnosticMeasureDefinition => item !== undefined,
+      );
+    if (
+      output &&
+      transitiveInputs.some(
+        (input) => input.developmentSemantics !== output.developmentSemantics,
+      )
+    ) {
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.expression`,
+        "Derived output and inputs must share development semantics",
+      );
     }
     if (definition.lossRowGrain !== "claim") {
-      pushIssue(issues, "incompatible-semantics", base, "Derived measures require claim-grain input");
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        base,
+        "Derived measures require claim-grain input",
+      );
     }
     const expressionStack: unknown[] = [derivation.expression];
     while (expressionStack.length > 0) {
@@ -1080,33 +2838,84 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
       if (current.op === "claim-layer") {
         const attachment = current.attachment;
         const limit = current.limit;
-        const attachmentOk = validateFinite(attachment, `${base}.expression.attachment`, "Claim-layer attachment", issues);
-        if (attachmentOk && attachment < 0) pushIssue(issues, "invalid-number", `${base}.expression.attachment`, "Claim-layer attachment must be nonnegative");
+        const attachmentOk = validateFinite(
+          attachment,
+          `${base}.expression.attachment`,
+          "Claim-layer attachment",
+          issues,
+        );
+        if (attachmentOk && attachment < 0)
+          pushIssue(
+            issues,
+            "invalid-number",
+            `${base}.expression.attachment`,
+            "Claim-layer attachment must be nonnegative",
+          );
         if (limit !== null) {
-          const limitOk = validateFinite(limit, `${base}.expression.limit`, "Claim-layer width", issues);
-          if (limitOk && limit <= 0) pushIssue(issues, "invalid-number", `${base}.expression.limit`, "Claim-layer width must be positive");
+          const limitOk = validateFinite(
+            limit,
+            `${base}.expression.limit`,
+            "Claim-layer width",
+            issues,
+          );
+          if (limitOk && limit <= 0)
+            pushIssue(
+              issues,
+              "invalid-number",
+              `${base}.expression.limit`,
+              "Claim-layer width must be positive",
+            );
           if (attachmentOk && limitOk && !Number.isFinite(attachment + limit)) {
-            pushIssue(issues, "invalid-number", `${base}.expression.limit`, "Attachment plus claim-layer width must be finite");
+            pushIssue(
+              issues,
+              "invalid-number",
+              `${base}.expression.limit`,
+              "Attachment plus claim-layer width must be finite",
+            );
           }
         }
-      } else if (current.op === "add" && Array.isArray(current.terms)) expressionStack.push(...current.terms);
-      else if (current.op === "subtract") expressionStack.push(current.left, current.right);
+      } else if (current.op === "add" && Array.isArray(current.terms))
+        expressionStack.push(...current.terms);
+      else if (current.op === "subtract")
+        expressionStack.push(current.left, current.right);
     }
-    const projection = projectClaimExpression(derivation.expression, `${base}.expression`, measureMap, amountBasisMap, issues);
+    const projection = projectClaimExpression(
+      derivation.expression,
+      `${base}.expression`,
+      measureMap,
+      amountBasisMap,
+      issues,
+    );
     if (output && projection) {
-      const expected = output.kind === "amount" && output.basisId
-        ? amountBasisMap.get(output.basisId)
-        : undefined;
-      const matches = output.kind === projection.kind && output.unit === projection.unit &&
+      const expected =
+        output.kind === "amount" && output.basisId
+          ? amountBasisMap.get(output.basisId)
+          : undefined;
+      const matches =
+        output.kind === projection.kind &&
+        output.unit === projection.unit &&
         (output.kind === "amount"
-          ? expected !== undefined && projectedBasisKey(projectedAmountBasis(expected)) === projectedBasisKey(projection.amountBasis!)
+          ? expected !== undefined &&
+            projectedBasisKey(projectedAmountBasis(expected)) ===
+              projectedBasisKey(projection.amountBasis!)
           : semanticReference(output) === projection.reference);
-      if (!matches) pushIssue(issues, "incompatible-semantics", `${base}.expression`, "Derived expression does not project the output measure semantics");
+      if (!matches)
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          `${base}.expression`,
+          "Derived expression does not project the output measure semantics",
+        );
     }
   });
   for (const [measureId, measure] of measureMap) {
     if (measure.source === "derived" && !derivedOutputs.has(measureId)) {
-      pushIssue(issues, "missing-required", "$.derivedMeasures", `Derived measure ${measureId} requires exactly one derivation`);
+      pushIssue(
+        issues,
+        "missing-required",
+        "$.derivedMeasures",
+        `Derived measure ${measureId} requires exactly one derivation`,
+      );
     }
   }
   const visiting = new Set<string>();
@@ -1114,14 +2923,25 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
   const visit = (id: string): void => {
     if (visited.has(id)) return;
     if (visiting.has(id)) {
-      pushIssue(issues, "cycle", "$.derivedMeasures", `Derived measure graph contains a cycle at ${id}`);
+      pushIssue(
+        issues,
+        "cycle",
+        "$.derivedMeasures",
+        `Derived measure graph contains a cycle at ${id}`,
+      );
       return;
     }
     visiting.add(id);
     const derivation = derivedOutputs.get(id);
     if (derivation) {
-      const deps = walkDiagnosticExpression(derivation.expression, "claim", "$.derivedMeasures", []).dependencies;
-      for (const dependency of deps) if (derivedOutputs.has(dependency)) visit(dependency);
+      const deps = walkDiagnosticExpression(
+        derivation.expression,
+        "claim",
+        "$.derivedMeasures",
+        [],
+      ).dependencies;
+      for (const dependency of deps)
+        if (derivedOutputs.has(dependency)) visit(dependency);
     }
     visiting.delete(id);
     visited.add(id);
@@ -1130,29 +2950,360 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
 
   reviewRules.forEach((rule, index) => {
     const base = `$.reviewRules[${index}]`;
+    if (!isPlainRecord(rule)) {
+      pushIssue(issues, "invalid-type", base, "Review rule must be an object");
+      return;
+    }
+    const commonKeys = [
+      "kind",
+      "id",
+      "code",
+      "description",
+      "severity",
+      "tolerance",
+      "missingInput",
+    ];
+    const branchKeys =
+      rule.kind === "compare"
+        ? ["when"]
+        : rule.kind === "reconcile"
+          ? ["actual", "expected"]
+          : rule.kind === "monotonic"
+            ? ["expression", "direction"]
+            : rule.kind === "layer-order"
+              ? ["narrower", "broader", "comparability"]
+              : rule.kind === "control-total"
+                ? ["expression", "expected", "filter", "projection"]
+                : [];
+    validateAllowedKeys(rule, [...commonKeys, ...branchKeys], base, issues);
+    if (rule.tolerance !== undefined) {
+      if (!isPlainRecord(rule.tolerance))
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${base}.tolerance`,
+          "Tolerance must be an object",
+        );
+      else
+        validateAllowedKeys(
+          rule.tolerance,
+          ["absolute", "relative"],
+          `${base}.tolerance`,
+          issues,
+        );
+    }
     validateToken(rule.code, `${base}.code`, "Review rule code", issues);
-    validateToken(rule.description, `${base}.description`, "Review rule description", issues);
-    if (rule.id.startsWith("diagnostic/structural/")) pushIssue(issues, "incompatible-semantics", `${base}.id`, "Review rule ID uses the reserved structural prefix");
+    validateToken(
+      rule.description,
+      `${base}.description`,
+      "Review rule description",
+      issues,
+    );
+    if (
+      typeof rule.id === "string" &&
+      rule.id.startsWith("diagnostic/structural/")
+    )
+      pushIssue(
+        issues,
+        "incompatible-semantics",
+        `${base}.id`,
+        "Review rule ID uses the reserved structural prefix",
+      );
+    if (rule.severity !== "warning" && rule.severity !== "fail")
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.severity`,
+        "Review severity must be warning or fail",
+      );
+    if (
+      rule.missingInput !== "not-evaluated" &&
+      rule.missingInput !== "finding"
+    )
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.missingInput`,
+        "Review missing-input policy must be not-evaluated or finding",
+      );
     validateTolerance(rule.tolerance, `${base}.tolerance`, issues);
-    const roots: DiagnosticMeasureExpression[] = [];
+    const roots: {
+      readonly expression: DiagnosticMeasureExpression;
+      readonly path: string;
+    }[] = [];
+    const operand = (value: unknown, path: string): void => {
+      if (isPlainRecord(value) && value.op === "constant") {
+        validateAllowedKeys(value, ["op", "value"], path, issues);
+        validateFinite(value.value, `${path}.value`, "Review constant", issues);
+        definitionExpressionNodes++;
+      } else
+        roots.push({ expression: value as DiagnosticMeasureExpression, path });
+    };
     if (rule.kind === "compare") {
-      if (rule.when.left.op !== "constant") roots.push(rule.when.left);
-      else definitionExpressionNodes++;
-      if (rule.when.right.op !== "constant") roots.push(rule.when.right);
-      else definitionExpressionNodes++;
+      if (!isPlainRecord(rule.when))
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${base}.when`,
+          "Compare rule predicate must be an object",
+        );
+      else {
+        validateAllowedKeys(
+          rule.when,
+          ["left", "operator", "right"],
+          `${base}.when`,
+          issues,
+        );
+        operand(rule.when.left, `${base}.when.left`);
+        operand(rule.when.right, `${base}.when.right`);
+        if (
+          !["lt", "lte", "eq", "neq", "gte", "gt"].includes(rule.when.operator)
+        )
+          pushIssue(
+            issues,
+            "invalid-type",
+            `${base}.when.operator`,
+            "Unknown review comparison operator",
+          );
+      }
     } else if (rule.kind === "reconcile") {
-      roots.push(rule.actual);
-      if (rule.expected.op !== "constant") roots.push(rule.expected);
-      else definitionExpressionNodes++;
-    } else if (rule.kind === "monotonic") roots.push(rule.expression);
-    else if (rule.kind === "layer-order") roots.push(rule.narrower, rule.broader);
-    else if (rule.kind === "control-total") {
-      roots.push(rule.expression);
-      validateFinite(rule.expected, `${base}.expected`, "Control total", issues);
-    } else pushIssue(issues, "invalid-type", `${base}.kind`, "Unknown review-rule kind");
-    roots.forEach((root, rootIndex) => {
-      expressionSemantics(root, `${base}.expression[${rootIndex}]`, measureMap, issues);
-      definitionExpressionNodes += walkDiagnosticExpression(root, "measure", `${base}.expression[${rootIndex}]`, []).nodeCount;
+      roots.push({ expression: rule.actual, path: `${base}.actual` });
+      operand(rule.expected, `${base}.expected`);
+    } else if (rule.kind === "monotonic") {
+      roots.push({ expression: rule.expression, path: `${base}.expression` });
+      if (
+        rule.direction !== "nondecreasing" &&
+        rule.direction !== "nonincreasing"
+      )
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${base}.direction`,
+          "Unknown monotonic direction",
+        );
+    } else if (rule.kind === "layer-order") {
+      roots.push(
+        { expression: rule.narrower, path: `${base}.narrower` },
+        { expression: rule.broader, path: `${base}.broader` },
+      );
+      if (
+        !isPlainRecord(rule.comparability) ||
+        (rule.comparability.kind !== "compiler-proven" &&
+          rule.comparability.kind !== "caller-asserted")
+      ) {
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${base}.comparability`,
+          "Unknown layer comparability evidence",
+        );
+      } else if (rule.comparability.kind === "caller-asserted") {
+        validateAllowedKeys(
+          rule.comparability,
+          ["kind", "rationaleArtifactId"],
+          `${base}.comparability`,
+          issues,
+        );
+        validateToken(
+          rule.comparability.rationaleArtifactId,
+          `${base}.comparability.rationaleArtifactId`,
+          "Rationale artifact ID",
+          issues,
+        );
+      }
+      if (
+        isPlainRecord(rule.comparability) &&
+        rule.comparability.kind === "compiler-proven"
+      )
+        validateAllowedKeys(
+          rule.comparability,
+          ["kind"],
+          `${base}.comparability`,
+          issues,
+        );
+      if (
+        isPlainRecord(rule.comparability) &&
+        (rule.comparability.kind === "compiler-proven" ||
+          rule.comparability.kind === "caller-asserted")
+      ) {
+        validateLayerComparability(
+          rule,
+          `${base}.comparability`,
+          measureMap,
+          amountBasisMap,
+          derivationsByOutput,
+          issues,
+        );
+      }
+    } else if (rule.kind === "control-total") {
+      roots.push({ expression: rule.expression, path: `${base}.expression` });
+      validateFinite(
+        rule.expected,
+        `${base}.expected`,
+        "Control total",
+        issues,
+      );
+      if (rule.filter !== undefined)
+        validateReviewFilter(
+          rule.filter,
+          `${base}.filter`,
+          definition.periodAxis,
+          issues,
+        );
+      if (
+        !isPlainRecord(rule.projection) ||
+        !["valuation", "latest-valuation-per-origin", "all-cells"].includes(
+          rule.projection.kind,
+        )
+      ) {
+        pushIssue(
+          issues,
+          "invalid-type",
+          `${base}.projection`,
+          "Unknown control-total projection",
+        );
+      } else if (rule.projection.kind === "valuation") {
+        validateAllowedKeys(
+          rule.projection,
+          ["kind", "valuation"],
+          `${base}.projection`,
+          issues,
+        );
+        if (
+          validateToken(
+            rule.projection.valuation,
+            `${base}.projection.valuation`,
+            "Control-total valuation",
+            issues,
+          ) &&
+          !normalizeDiagnosticPeriodWithAxis(
+            definition.periodAxis,
+            "valuation",
+            rule.projection.valuation,
+          )
+        ) {
+          pushIssue(
+            issues,
+            "invalid-period",
+            `${base}.projection.valuation`,
+            `Unknown valuation period ${JSON.stringify(rule.projection.valuation)}`,
+          );
+        }
+      } else
+        validateAllowedKeys(
+          rule.projection,
+          ["kind"],
+          `${base}.projection`,
+          issues,
+        );
+    } else
+      pushIssue(
+        issues,
+        "invalid-type",
+        `${base}.kind`,
+        "Unknown review-rule kind",
+      );
+    const compatibleOperands = (
+      left: DiagnosticReviewOperand,
+      right: DiagnosticReviewOperand,
+      path: string,
+    ): void => {
+      if (!isPlainRecord(left) || !isPlainRecord(right)) return;
+      if (left.op === "constant" || right.op === "constant") return;
+      const leftSignature = expressionSemantics(
+        left,
+        `${path}.left`,
+        measureMap,
+        [],
+      ).signature;
+      const rightSignature = expressionSemantics(
+        right,
+        `${path}.right`,
+        measureMap,
+        [],
+      ).signature;
+      if (
+        leftSignature !== null &&
+        rightSignature !== null &&
+        leftSignature !== rightSignature
+      ) {
+        pushIssue(
+          issues,
+          "incompatible-semantics",
+          path,
+          "Review comparison operands must have identical quantity semantics",
+        );
+      }
+    };
+    if (rule.kind === "compare" && isPlainRecord(rule.when)) {
+      compatibleOperands(rule.when.left, rule.when.right, `${base}.when`);
+    } else if (rule.kind === "reconcile") {
+      compatibleOperands(rule.actual, rule.expected, base);
+    }
+    roots.forEach(({ expression, path }) => {
+      const semantics = expressionSemantics(
+        expression,
+        path,
+        measureMap,
+        issues,
+      );
+      definitionExpressionNodes += walkDiagnosticExpression(
+        expression,
+        "measure",
+        path,
+        [],
+      ).nodeCount;
+      if (rule.kind === "monotonic") {
+        const leaves = transitiveMeasureIds(
+          semantics.measureIds,
+          derivationsByOutput,
+        )
+          .map((id) => measureMap.get(id))
+          .filter(
+            (item): item is DiagnosticMeasureDefinition => item !== undefined,
+          );
+        if (
+          leaves.some(
+            (measure) =>
+              measure.developmentSemantics !== "cumulative" &&
+              measure.developmentSemantics !== "point-in-time",
+          )
+        ) {
+          pushIssue(
+            issues,
+            "incompatible-semantics",
+            path,
+            "Monotonic review requires cumulative or point-in-time leaves",
+          );
+        }
+      }
+      if (
+        rule.kind === "control-total" &&
+        rule.projection?.kind === "all-cells"
+      ) {
+        const leaves = transitiveMeasureIds(
+          semantics.measureIds,
+          derivationsByOutput,
+        )
+          .map((id) => measureMap.get(id))
+          .filter(
+            (item): item is DiagnosticMeasureDefinition => item !== undefined,
+          );
+        if (
+          leaves.some(
+            (measure) =>
+              measure.developmentSemantics === "cumulative" ||
+              measure.exposureTiming === "origin-static",
+          )
+        ) {
+          pushIssue(
+            issues,
+            "incompatible-semantics",
+            `${base}.projection`,
+            "All-cells control totals cannot repeat cumulative or origin-static measures",
+          );
+        }
+      }
     });
   });
 
@@ -1169,10 +3320,33 @@ function validateDefinition(value: unknown): DiagnosticDefinition {
   return definition;
 }
 
+/** Internal boundary reuse: direct helpers use the compiler's exact axis contract. */
+export function validateDiagnosticPeriodAxisInput(
+  value: unknown,
+): readonly DiagnosticValidationIssue[] {
+  const preflight = diagnosticJsonPreflight(value, "configuration").map((issue) => ({
+    ...issue,
+    path: `$.periodAxis${issue.path.slice(1)}`,
+  }));
+  if (preflight.length > 0) return preflight;
+  const issues: DiagnosticValidationIssue[] = [];
+  validatePeriodAxis(value as DiagnosticPeriodAxis, issues);
+  return issues.map((issue) => ({ ...issue, domain: "configuration" as const }));
+}
+
 function optionalFromNullable<T>(value: T | null | undefined): T | undefined {
   return value === null || value === undefined ? undefined : value;
 }
 
+function omitProperties<T extends object>(
+  value: T,
+  keys: readonly string[],
+): Record<string, unknown> {
+  const result = { ...value } as Record<string, unknown>;
+  for (const key of keys) delete result[key];
+  return result;
+}
+
 /**
  * The normalized wire projection materializes optional semantic fields as
  * null. Convert only those documented defaults back to the authored view so
@@ -1185,27 +3359,47 @@ function authoredView(
   const reviewRules = definition.reviewRules.map((rule) => {
     const tolerance = { ...rule.tolerance };
     if (rule.kind !== "control-total") return { ...rule, tolerance };
-    const filter = rule.filter === null
-      ? undefined
-      : {
-          sourceGroups: optionalFromNullable(rule.filter.sourceGroups),
-          origins: optionalFromNullable(rule.filter.origins),
-          originFrom: optionalFromNullable(rule.filter.originFrom),
-          originThrough: optionalFromNullable(rule.filter.originThrough),
-          valuations: optionalFromNullable(rule.filter.valuations),
-          valuationFrom: optionalFromNullable(rule.filter.valuationFrom),
-          valuationThrough: optionalFromNullable(rule.filter.valuationThrough),
-          minDevelopmentAge: optionalFromNullable(rule.filter.minDevelopmentAge),
-          maxDevelopmentAge: optionalFromNullable(rule.filter.maxDevelopmentAge),
-        };
-    return { ...rule, tolerance, ...(filter === undefined ? {} : { filter }) };
+    const filter =
+      rule.filter === null || rule.filter === undefined
+        ? undefined
+        : (Object.fromEntries(
+            Object.entries({
+              sourceGroups: optionalFromNullable(rule.filter.sourceGroups),
+              origins: optionalFromNullable(rule.filter.origins),
+              originFrom: optionalFromNullable(rule.filter.originFrom),
+              originThrough: optionalFromNullable(rule.filter.originThrough),
+              valuations: optionalFromNullable(rule.filter.valuations),
+              valuationFrom: optionalFromNullable(rule.filter.valuationFrom),
+              valuationThrough: optionalFromNullable(
+                rule.filter.valuationThrough,
+              ),
+              minDevelopmentAge: optionalFromNullable(
+                rule.filter.minDevelopmentAge,
+              ),
+              maxDevelopmentAge: optionalFromNullable(
+                rule.filter.maxDevelopmentAge,
+              ),
+            }).filter(([, item]) => item !== undefined),
+          ) as DiagnosticReviewFilter);
+    return {
+      ...omitProperties(rule, ["filter"]),
+      tolerance,
+      ...(filter === undefined ? {} : { filter }),
+    } as DiagnosticReviewRule;
   }) as readonly DiagnosticReviewRule[];
   return {
+    ...definition,
     diagnosticDefinitionVersion: definition.diagnosticDefinitionVersion,
     id: definition.id,
     version: definition.version,
     lossRowGrain: definition.lossRowGrain,
     measures: definition.measures.map((measure) => ({
+      ...omitProperties(measure, [
+        "basisId",
+        "countPopulationId",
+        "exposureBasisId",
+        "exposureTiming",
+      ]),
       id: measure.id,
       displayName: measure.displayName,
       description: measure.description,
@@ -1215,69 +3409,103 @@ function authoredView(
       developmentSemantics: measure.developmentSemantics,
       aggregation: measure.aggregation,
       missing: measure.missing,
-      ...(measure.basisId === null || measure.basisId === undefined ? {} : { basisId: measure.basisId }),
-      ...(measure.countPopulationId === null || measure.countPopulationId === undefined
+      ...(measure.basisId === null || measure.basisId === undefined
+        ? {}
+        : { basisId: measure.basisId }),
+      ...(measure.countPopulationId === null ||
+      measure.countPopulationId === undefined
         ? {}
         : { countPopulationId: measure.countPopulationId }),
-      ...(measure.exposureBasisId === null || measure.exposureBasisId === undefined
+      ...(measure.exposureBasisId === null ||
+      measure.exposureBasisId === undefined
         ? {}
         : { exposureBasisId: measure.exposureBasisId }),
-      ...(measure.exposureTiming === null || measure.exposureTiming === undefined
+      ...(measure.exposureTiming === null ||
+      measure.exposureTiming === undefined
         ? {}
         : { exposureTiming: measure.exposureTiming }),
     })),
-    countPopulations: definition.countPopulations.map((population) => ({ ...population })),
+    countPopulations: definition.countPopulations.map((population) => ({
+      ...population,
+    })),
     exposureBases: definition.exposureBases.map((basis) => ({
+      ...omitProperties(basis, ["sourceDescription"]),
       id: basis.id,
       displayName: basis.displayName,
       basis: basis.basis,
       unit: basis.unit,
       description: basis.description,
-      ...(basis.sourceDescription === null || basis.sourceDescription === undefined
+      ...(basis.sourceDescription === null ||
+      basis.sourceDescription === undefined
         ? {}
         : { sourceDescription: basis.sourceDescription }),
-      ...(basis.attributes === undefined ? {} : { attributes: basis.attributes }),
+      ...(basis.attributes === undefined
+        ? {}
+        : { attributes: basis.attributes }),
     })),
     amountBases: definition.amountBases.map((basis) => ({
+      ...omitProperties(basis, ["sourceDescription"]),
       id: basis.id,
       displayName: basis.displayName,
       currency: basis.currency,
       perspective: basis.perspective,
       components: basis.components.map((component) => ({
+        ...component,
         id: component.id,
         treatment: component.treatment,
-        limitation: component.limitation.kind === "unknown"
-          ? {
-              kind: "unknown" as const,
-              ...(component.limitation.description === null || component.limitation.description === undefined
-                ? {}
-                : { description: component.limitation.description }),
-            }
-          : component.limitation,
+        limitation:
+          component.limitation.kind === "unknown"
+            ? {
+                ...omitProperties(component.limitation, ["description"]),
+                kind: "unknown" as const,
+                ...(component.limitation.description === null ||
+                component.limitation.description === undefined
+                  ? {}
+                  : { description: component.limitation.description }),
+              }
+            : component.limitation,
       })),
-      ...(basis.sourceDescription === null || basis.sourceDescription === undefined
+      ...(basis.sourceDescription === null ||
+      basis.sourceDescription === undefined
         ? {}
         : { sourceDescription: basis.sourceDescription }),
-      ...(basis.attributes === undefined ? {} : { attributes: basis.attributes }),
+      ...(basis.attributes === undefined
+        ? {}
+        : { attributes: basis.attributes }),
+    })),
+    derivedMeasures: definition.derivedMeasures.map((derivation) => ({
+      ...derivation,
     })),
-    derivedMeasures: definition.derivedMeasures.map((derivation) => ({ ...derivation })),
     formulas: definition.formulas.map((formula) => ({
+      ...formula,
       id: formula.id,
       version: formula.version,
-      roles: Object.fromEntries(Object.entries(formula.roles).map(([name, role]) => [name, {
-        kind: role.kind,
-        ...(role.compatibilityGroup === null || role.compatibilityGroup === undefined
-          ? {}
-          : { compatibilityGroup: role.compatibilityGroup }),
-        ...(role.developmentSemantics === null || role.developmentSemantics === undefined
-          ? {}
-          : { developmentSemantics: role.developmentSemantics }),
-      }])),
+      roles: Object.fromEntries(
+        Object.entries(formula.roles).map(([name, role]) => [
+          name,
+          {
+            ...omitProperties(role, [
+              "compatibilityGroup",
+              "developmentSemantics",
+            ]),
+            kind: role.kind,
+            ...(role.compatibilityGroup === null ||
+            role.compatibilityGroup === undefined
+              ? {}
+              : { compatibilityGroup: role.compatibilityGroup }),
+            ...(role.developmentSemantics === null ||
+            role.developmentSemantics === undefined
+              ? {}
+              : { developmentSemantics: role.developmentSemantics }),
+          },
+        ]),
+      ),
       numerator: formula.numerator,
       denominator: formula.denominator,
       denominatorPolicy: formula.denominatorPolicy,
     })),
     instances: definition.instances.map((instance) => ({
+      ...instance,
       id: instance.id,
       version: instance.version,
       formulaId: instance.formulaId,
@@ -1299,29 +3527,35 @@ export function compileDiagnosticDefinition(
 ): CompiledDiagnosticDefinition {
   const boundaryIssues: DiagnosticValidationIssue[] = [];
   validateJsonValue(value, boundaryIssues);
-  if (boundaryIssues.length > 0) throw new DiagnosticValidationError(boundaryIssues);
+  if (boundaryIssues.length > 0)
+    throw new DiagnosticValidationError(boundaryIssues);
   let authored: DiagnosticDefinition;
   try {
     authored = authoredView(value);
   } catch {
-    throw new DiagnosticValidationError([{
-      domain: "definition",
-      code: "invalid-type",
-      path: "$",
-      message: "Diagnostic definition does not have the required object and array structure",
-    }]);
+    throw new DiagnosticValidationError([
+      {
+        domain: "definition",
+        code: "invalid-type",
+        path: "$",
+        message:
+          "Diagnostic definition does not have the required object and array structure",
+      },
+    ]);
   }
   let definition: DiagnosticDefinition;
   try {
     definition = validateDefinition(authored);
   } catch (error) {
     if (error instanceof DiagnosticValidationError) throw error;
-    throw new DiagnosticValidationError([{
-      domain: "definition",
-      code: "invalid-type",
-      path: "$",
-      message: "Diagnostic definition contains a malformed nested value",
-    }]);
+    throw new DiagnosticValidationError([
+      {
+        domain: "definition",
+        code: "invalid-type",
+        path: "$",
+        message: "Diagnostic definition contains a malformed nested value",
+      },
+    ]);
   }
   const normalized = normalizeDiagnosticDefinition(definition);
   const identities = buildDiagnosticIdentities(normalized);
@@ -1341,13 +3575,22 @@ export function compileDiagnosticDefinition(
   Object.freeze(compiled);
   authenticCompiledDefinitions.add(compiled);
   compiledInternals.set(compiled, {
-    formulasById: new Map(normalized.formulas.map((formula) => [formula.id, formula])),
-    measuresById: new Map(definition.measures.map((measure) => [measure.id, measure])),
+    formulasById: new Map(
+      normalized.formulas.map((formula) => [formula.id, formula]),
+    ),
+    measuresById: new Map(
+      definition.measures.map((measure) => [measure.id, measure]),
+    ),
     calculationScopesByInstanceId: identities.calculationScopesByInstanceId,
-    calculationDependenciesByInstanceId: identities.calculationDependenciesByInstanceId,
-    evaluationDependenciesByInstanceId: identities.evaluationDependenciesByInstanceId,
+    calculationDependenciesByInstanceId:
+      identities.calculationDependenciesByInstanceId,
+    evaluationDependenciesByInstanceId:
+      identities.evaluationDependenciesByInstanceId,
     derivationsByOutputMeasureId: new Map(
-      normalized.derivedMeasures.map((derivation) => [derivation.outputMeasureId, derivation as DiagnosticDerivedMeasureDefinition]),
+      normalized.derivedMeasures.map((derivation) => [
+        derivation.outputMeasureId,
+        derivation as DiagnosticDerivedMeasureDefinition,
+      ]),
     ),
   });
   return compiled;
@@ -1356,13 +3599,19 @@ export function compileDiagnosticDefinition(
 export function assertCompiledDiagnosticDefinition(
   value: unknown,
 ): asserts value is CompiledDiagnosticDefinition {
-  if ((typeof value !== "object" && typeof value !== "function") || value === null || !authenticCompiledDefinitions.has(value)) {
-    throw new DiagnosticValidationError([{
-      domain: "definition",
-      code: "invalid-input-relationship",
-      path: "$",
-      message: "Value is not an authentic compiled diagnostic definition",
-    }]);
+  if (
+    (typeof value !== "object" && typeof value !== "function") ||
+    value === null ||
+    !authenticCompiledDefinitions.has(value)
+  ) {
+    throw new DiagnosticValidationError([
+      {
+        domain: "definition",
+        code: "invalid-input-relationship",
+        path: "$",
+        message: "Value is not an authentic compiled diagnostic definition",
+      },
+    ]);
   }
 }