@actuarial-ts/core 0.6.0 → 0.7.0

package/dist/diagnosticDefinitions.js

@@ -1,15 +1,14 @@
-import { MAX_DIAGNOSTIC_DEFINITION_EXPRESSION_NODES, walkDiagnosticExpression, } from "./diagnosticExpressions.js";
+import { MAX_DIAGNOSTIC_DEFINITION_EXPRESSION_NODES, MAX_DIAGNOSTIC_EXPRESSION_NODES, walkDiagnosticExpression, } from "./diagnosticExpressions.js";
 import { buildDiagnosticIdentities, normalizeDiagnosticDefinition, } from "./diagnosticIdentity.js";
 import { DiagnosticValidationError, } from "./types.js";
 import { canonicalJson } from "./canonical.js";
+import { normalizeDiagnosticPeriodWithAxis } from "./diagnosticPeriodAxis.js";
+import { diagnosticJsonPreflight, hasDiagnosticOwn, isDiagnosticPlainRecord, isDiagnosticToken, isWellFormedDiagnosticString, } from "./diagnosticRuntime.js";
 const compiledDiagnosticDefinitionBrand = Symbol("compiled-diagnostic-definition");
 const authenticCompiledDefinitions = new WeakSet();
 const compiledInternals = new WeakMap();
 function isPlainRecord(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
+    return isDiagnosticPlainRecord(value);
 }
 function propertyPath(parent, key) {
     return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
@@ -19,32 +18,50 @@ function propertyPath(parent, key) {
 function pushIssue(issues, code, path, message) {
     issues.push({ domain: "definition", code, path, message });
 }
-function hasWellFormedUtf16(value) {
-    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, allowed, path, issues) {
+    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, path, issues) {
+    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(value, path, label, issues) {
     if (typeof value !== "string") {
         pushIssue(issues, "invalid-type", path, `${label} must be a string`);
         return false;
     }
-    if (!hasWellFormedUtf16(value)) {
+    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)) {
+    if (!isDiagnosticToken(value)) {
         pushIssue(issues, "invalid-string", path, `${label} must be nonempty without surrounding ASCII whitespace`);
         return false;
     }
@@ -58,62 +75,7 @@ function validateFinite(value, path, label, issues) {
     return true;
 }
 function validateJsonValue(value, issues) {
-    const active = new WeakSet();
-    const stack = [{ 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;
-        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 });
-            }
-        }
-    }
+    issues.push(...diagnosticJsonPreflight(value, "definition"));
 }
 function requireArray(value, path, issues) {
     if (!Array.isArray(value)) {
@@ -153,7 +115,8 @@ function transitiveMeasureIds(roots, derivations) {
         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();
@@ -174,11 +137,22 @@ function projectClaimExpression(expression, path, measures, amountBases, issues)
         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") {
@@ -189,7 +163,10 @@ function projectClaimExpression(expression, path, measures, amountBases, issues)
         }
         const basis = amountBases.get(measure.basisId);
         const component = basis?.components[0];
-        if (!basis || basis.components.length !== 1 || component?.treatment !== "included" || component.limitation.kind !== "unlimited") {
+        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;
         }
@@ -200,7 +177,8 @@ function projectClaimExpression(expression, path, measures, amountBases, issues)
             amountBasis: {
                 currency: basis.currency,
                 perspective: basis.perspective,
-                components: [{
+                components: [
+                    {
                         id: component.id,
                         treatment: "included",
                         limitation: {
@@ -210,20 +188,27 @@ function projectClaimExpression(expression, path, measures, amountBases, issues)
                             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;
     if (expression.op === "subtract") {
         const [left, right] = present;
-        if (left.kind !== right.kind || left.unit !== right.unit ||
+        if (left.kind !== right.kind ||
+            left.unit !== right.unit ||
             (left.kind === "amount"
-                ? projectedBasisKey(left.amountBasis) !== projectedBasisKey(right.amountBasis)
+                ? projectedBasisKey(left.amountBasis) !==
+                    projectedBasisKey(right.amountBasis)
                 : left.reference !== right.reference)) {
             pushIssue(issues, "incompatible-semantics", path, "Claim subtraction requires one exact semantic basis");
             return null;
@@ -243,7 +228,8 @@ function projectClaimExpression(expression, path, measures, amountBases, issues)
         return first;
     }
     const bases = present.map((item) => item.amountBasis);
-    if (bases.some((basis) => basis.currency !== bases[0].currency || basis.perspective !== bases[0].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;
     }
@@ -264,10 +250,15 @@ function projectClaimExpression(expression, path, measures, amountBases, issues)
         perspective: bases[0].perspective,
         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(expression, path, measures, issues) {
-    const walked = walkDiagnosticExpression(expression, "measure", path, issues);
+function expressionSemantics(expression, path, measures, issues, initialDepth = 1) {
+    const walked = walkDiagnosticExpression(expression, "measure", path, issues, initialDepth);
     const found = walked.dependencies
         .map((id) => measures.get(id))
         .filter((value) => value !== undefined);
@@ -276,7 +267,7 @@ function expressionSemantics(expression, path, measures, issues) {
             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");
     }
@@ -297,6 +288,224 @@ function validateTolerance(value, path, issues) {
         }
     }
 }
+function validateReviewFilter(value, path, axis, issues) {
+    if (!isPlainRecord(value)) {
+        pushIssue(issues, "invalid-type", path, "Review filter must be an object");
+        return;
+    }
+    const periodCoordinates = new Map();
+    const validatePeriods = (key, side) => {
+        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, side) => {
+        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"]) {
+        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 measureExpressionBasis(expression, measures, amountBases) {
+    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;
+}
+function traceLayerComponents(measureId, measures, amountBases, derivations, seen = new Set()) {
+    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) => {
+        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();
+        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) {
+    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, path, measures, amountBases, derivations, issues) {
+    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, broaderMeasureId) => {
+        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, broader) => {
+        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, issues) {
     if (!isPlainRecord(axis)) {
         pushIssue(issues, "invalid-type", "$.periodAxis", "Period axis must be an object");
@@ -307,17 +516,33 @@ function validatePeriodAxis(axis, issues) {
         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");
         }
         if (!["month", "quarter", "year"].includes(axis.valuationCadence)) {
             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");
         }
         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");
         return;
@@ -331,6 +556,11 @@ function validatePeriodAxis(axis, issues) {
         const coordinateValues = new Set();
         coordinates.forEach((coordinate, index) => {
             const base = `$.periodAxis.${side}[${index}]`;
+            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}`);
@@ -345,7 +575,10 @@ function validatePeriodAxis(axis, issues) {
             }
             else
                 coordinateValues.add(coordinate.coordinate);
-            for (const [aliasIndex, alias] of (coordinate?.aliases ?? []).entries()) {
+            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))
@@ -363,12 +596,28 @@ function validateDefinition(value) {
         throw new DiagnosticValidationError(issues);
     }
     const definition = value;
+    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");
     }
     validateToken(definition.id, "$.id", "Definition ID", issues);
     validateToken(definition.version, "$.version", "Definition version", issues);
-    if (definition.lossRowGrain !== "claim" && definition.lossRowGrain !== "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);
@@ -386,7 +635,8 @@ function validateDefinition(value) {
     collectCatalog(derivations, "$.derivedMeasures", issues);
     const derivationsByOutput = new Map();
     for (const derivation of derivations) {
-        if (isPlainRecord(derivation) && typeof derivation.outputMeasureId === "string" &&
+        if (isPlainRecord(derivation) &&
+            typeof derivation.outputMeasureId === "string" &&
             !derivationsByOutput.has(derivation.outputMeasureId)) {
             derivationsByOutput.set(derivation.outputMeasureId, derivation);
         }
@@ -396,15 +646,41 @@ function validateDefinition(value) {
     const reviewRuleMap = collectCatalog(reviewRules, "$.reviewRules", issues);
     populations.forEach((population, index) => {
         const base = `$.countPopulations[${index}]`;
+        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)) {
+        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}]`;
+        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);
@@ -413,9 +689,23 @@ function validateDefinition(value) {
         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}]`;
+        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)
@@ -423,11 +713,13 @@ function validateDefinition(value) {
         if (!["gross", "net", "ceded", "other", "unknown"].includes(basis.perspective)) {
             pushIssue(issues, "invalid-type", `${base}.perspective`, "Unknown amount perspective");
         }
+        validateScalarAttributes(basis.attributes, `${base}.attributes`, issues);
         const components = requireArray(basis.components, `${base}.components`, issues);
         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")) {
+        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) => {
@@ -436,6 +728,7 @@ function validateDefinition(value) {
                 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");
             }
@@ -445,27 +738,46 @@ function validateDefinition(value) {
                 return;
             }
             if (limitation.kind === "unknown") {
+                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") {
-                if (validateFinite(limitation.attachment, `${componentBase}.limitation.attachment`, "Attachment", issues) && limitation.attachment < 0) {
+            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) {
+                    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)) {
+                    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") {
+                    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") {
+                    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 {
@@ -475,10 +787,31 @@ function validateDefinition(value) {
             else if (limitation.kind !== "unlimited") {
                 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}]`;
+        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);
@@ -490,46 +823,60 @@ function validateDefinition(value) {
             pushIssue(issues, "invalid-type", `${base}.developmentSemantics`, "Unknown development semantics");
         }
         if (measure.kind === "amount") {
-            const basis = measure.basisId ? amountBasisMap.get(measure.basisId) : undefined;
+            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) {
+            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;
+            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) {
+            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;
+            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") {
+            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) {
+            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") {
+        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") {
@@ -537,7 +884,8 @@ function validateDefinition(value) {
         }
         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") &&
+            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");
@@ -548,6 +896,18 @@ function validateDefinition(value) {
     const formulaRoleUsage = new Map();
     formulas.forEach((formula, index) => {
         const base = `$.formulas[${index}]`;
+        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");
@@ -558,19 +918,30 @@ function validateDefinition(value) {
         }
         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)) {
+            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)) {
+                    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);
         }
         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)) {
+            if (!hasDiagnosticOwn(formula.roles, role)) {
                 pushIssue(issues, "unknown-reference", base, `Formula ${formula.id} references unknown role ${role}`);
             }
         }
@@ -578,8 +949,13 @@ function validateDefinition(value) {
             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]]) {
-            const kinds = new Set(walked.dependencies.map((role) => formula.roles[role]?.kind).filter(Boolean));
+        for (const [side, walked] of [
+            ["numerator", numerator],
+            ["denominator", denominator],
+        ]) {
+            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");
         }
@@ -587,6 +963,11 @@ function validateDefinition(value) {
     const instanceRuleIds = new Set();
     instances.forEach((instance, index) => {
         const base = `$.instances[${index}]`;
+        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);
@@ -601,7 +982,7 @@ function validateDefinition(value) {
         const usedRoles = formulaRoleUsage.get(formula.id) ?? [];
         const bindingSemantics = new Map();
         for (const roleName of usedRoles) {
-            if (!Object.prototype.hasOwnProperty.call(instance.bindings, roleName)) {
+            if (!hasDiagnosticOwn(instance.bindings, roleName)) {
                 pushIssue(issues, "missing-required", propertyPath(`${base}.bindings`, roleName), `Missing binding for role ${roleName}`);
                 continue;
             }
@@ -610,7 +991,9 @@ function validateDefinition(value) {
             bindingSemantics.set(roleName, semantics);
             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 !== undefined);
+            const boundMeasures = semantics.measureIds
+                .map((id) => measureMap.get(id))
+                .filter((item) => 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}`);
             }
@@ -623,9 +1006,16 @@ function validateDefinition(value) {
                 }
             }
         }
-        for (const [side, roleExpression] of [["numerator", formula.numerator], ["denominator", formula.denominator]]) {
+        const calculationSignatures = new Map();
+        for (const [side, roleExpression] of [
+            ["numerator", formula.numerator],
+            ["denominator", formula.denominator],
+        ]) {
             const roleIds = walkDiagnosticExpression(roleExpression, "role", `${base}.${side}`, []).dependencies;
-            const signatures = new Set(roleIds.map((roleId) => bindingSemantics.get(roleId)?.signature).filter((signature) => signature !== null && signature !== undefined));
+            const signatures = new Set(roleIds
+                .map((roleId) => bindingSemantics.get(roleId)?.signature)
+                .filter((signature) => 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`);
             }
@@ -651,6 +1041,18 @@ function validateDefinition(value) {
             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],
@@ -659,12 +1061,18 @@ function validateDefinition(value) {
             ["denominatorLabel", instance.presentation?.denominatorLabel],
         ])
             validateToken(text, `${base}.presentation.${key}`, `Presentation ${key}`, issues);
-        if (!validateFinite(instance.presentation?.scale, `${base}.presentation.scale`, "Presentation scale", issues) || instance.presentation.scale <= 0) {
+        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;
             const ruleBase = `${base}.rules[${ruleIndex}]`;
+            if (!isPlainRecord(rawRule)) {
+                pushIssue(issues, "invalid-type", ruleBase, "Metric rule must be an object");
+                return;
+            }
+            const rule = rawRule;
+            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");
@@ -674,25 +1082,83 @@ function validateDefinition(value) {
             }
             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);
-            for (const [side, operand] of [["left", rule.when?.left], ["right", rule.when?.right]]) {
+            const operandSignatures = new Map();
+            for (const [side, operand] of [
+                ["left", rule.when?.left],
+                ["right", rule.when?.right],
+            ]) {
                 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);
-                    definitionExpressionNodes += 1 + walkDiagnosticExpression(operand.expression, "measure", `${operandPath}.expression`, []).nodeCount;
-                    void semantic;
+                    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 {
+                else if (operand?.source === "calculation") {
                     definitionExpressionNodes += 1;
-                    if (operand?.source === "constant")
-                        validateFinite(operand.value, `${operandPath}.value`, "Rule constant", issues);
+                    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();
     derivations.forEach((derivation, index) => {
         const base = `$.derivedMeasures[${index}]`;
+        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)
@@ -708,8 +1174,11 @@ function validateDefinition(value) {
             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 !== undefined);
-        if (output && transitiveInputs.some((input) => input.developmentSemantics !== output.developmentSemantics)) {
+        const transitiveInputs = transitiveIds
+            .map((id) => measureMap.get(id))
+            .filter((item) => 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") {
@@ -745,9 +1214,12 @@ function validateDefinition(value) {
             const expected = output.kind === "amount" && output.basisId
                 ? amountBasisMap.get(output.basisId)
                 : undefined;
-            const matches = output.kind === projection.kind && output.unit === projection.unit &&
+            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");
@@ -782,42 +1254,161 @@ function validateDefinition(value) {
         visit(id);
     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/"))
+        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 = [];
-        if (rule.kind === "compare") {
-            if (rule.when.left.op !== "constant")
-                roots.push(rule.when.left);
-            else
+        const operand = (value, path) => {
+            if (isPlainRecord(value) && value.op === "constant") {
+                validateAllowedKeys(value, ["op", "value"], path, issues);
+                validateFinite(value.value, `${path}.value`, "Review constant", issues);
                 definitionExpressionNodes++;
-            if (rule.when.right.op !== "constant")
-                roots.push(rule.when.right);
+            }
             else
-                definitionExpressionNodes++;
+                roots.push({ expression: value, path });
+        };
+        if (rule.kind === "compare") {
+            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++;
+            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 === "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);
+            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");
-        roots.forEach((root, rootIndex) => {
-            expressionSemantics(root, `${base}.expression[${rootIndex}]`, measureMap, issues);
-            definitionExpressionNodes += walkDiagnosticExpression(root, "measure", `${base}.expression[${rootIndex}]`, []).nodeCount;
+        const compatibleOperands = (left, right, path) => {
+            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 !== 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 !== 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");
+                }
+            }
         });
     });
     if (definitionExpressionNodes > MAX_DIAGNOSTIC_DEFINITION_EXPRESSION_NODES) {
@@ -828,9 +1419,27 @@ function validateDefinition(value) {
         throw new DiagnosticValidationError(issues);
     return definition;
 }
+/** Internal boundary reuse: direct helpers use the compiler's exact axis contract. */
+export function validateDiagnosticPeriodAxisInput(value) {
+    const preflight = diagnosticJsonPreflight(value, "configuration").map((issue) => ({
+        ...issue,
+        path: `$.periodAxis${issue.path.slice(1)}`,
+    }));
+    if (preflight.length > 0)
+        return preflight;
+    const issues = [];
+    validatePeriodAxis(value, issues);
+    return issues.map((issue) => ({ ...issue, domain: "configuration" }));
+}
 function optionalFromNullable(value) {
     return value === null || value === undefined ? undefined : value;
 }
+function omitProperties(value, keys) {
+    const result = { ...value };
+    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
@@ -842,9 +1451,9 @@ function authoredView(value) {
         const tolerance = { ...rule.tolerance };
         if (rule.kind !== "control-total")
             return { ...rule, tolerance };
-        const filter = rule.filter === null
+        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),
@@ -854,15 +1463,26 @@ function authoredView(value) {
                 valuationThrough: optionalFromNullable(rule.filter.valuationThrough),
                 minDevelopmentAge: optionalFromNullable(rule.filter.minDevelopmentAge),
                 maxDevelopmentAge: optionalFromNullable(rule.filter.maxDevelopmentAge),
-            };
-        return { ...rule, tolerance, ...(filter === undefined ? {} : { filter }) };
+            }).filter(([, item]) => item !== undefined));
+        return {
+            ...omitProperties(rule, ["filter"]),
+            tolerance,
+            ...(filter === undefined ? {} : { filter }),
+        };
     });
     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,
@@ -872,69 +1492,100 @@ function authoredView(value) {
             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"
                     ? {
+                        ...omitProperties(component.limitation, ["description"]),
                         kind: "unknown",
-                        ...(component.limitation.description === null || component.limitation.description === undefined
+                        ...(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, {
+            roles: Object.fromEntries(Object.entries(formula.roles).map(([name, role]) => [
+                name,
+                {
+                    ...omitProperties(role, [
+                        "compatibilityGroup",
+                        "developmentSemantics",
+                    ]),
                     kind: role.kind,
-                    ...(role.compatibilityGroup === null || role.compatibilityGroup === undefined
+                    ...(role.compatibilityGroup === null ||
+                        role.compatibilityGroup === undefined
                         ? {}
                         : { compatibilityGroup: role.compatibilityGroup }),
-                    ...(role.developmentSemantics === null || role.developmentSemantics === undefined
+                    ...(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,
@@ -960,12 +1611,14 @@ export function compileDiagnosticDefinition(value) {
         authored = authoredView(value);
     }
     catch {
-        throw new DiagnosticValidationError([{
+        throw new DiagnosticValidationError([
+            {
                 domain: "definition",
                 code: "invalid-type",
                 path: "$",
                 message: "Diagnostic definition does not have the required object and array structure",
-            }]);
+            },
+        ]);
     }
     let definition;
     try {
@@ -974,12 +1627,14 @@ export function compileDiagnosticDefinition(value) {
     catch (error) {
         if (error instanceof DiagnosticValidationError)
             throw error;
-        throw new DiagnosticValidationError([{
+        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);
@@ -1004,18 +1659,25 @@ export function compileDiagnosticDefinition(value) {
         calculationScopesByInstanceId: identities.calculationScopesByInstanceId,
         calculationDependenciesByInstanceId: identities.calculationDependenciesByInstanceId,
         evaluationDependenciesByInstanceId: identities.evaluationDependenciesByInstanceId,
-        derivationsByOutputMeasureId: new Map(normalized.derivedMeasures.map((derivation) => [derivation.outputMeasureId, derivation])),
+        derivationsByOutputMeasureId: new Map(normalized.derivedMeasures.map((derivation) => [
+            derivation.outputMeasureId,
+            derivation,
+        ])),
     });
     return compiled;
 }
 export function assertCompiledDiagnosticDefinition(value) {
-    if ((typeof value !== "object" && typeof value !== "function") || value === null || !authenticCompiledDefinitions.has(value)) {
-        throw new DiagnosticValidationError([{
+    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",
-            }]);
+            },
+        ]);
     }
 }
 /** @internal Shared only by core diagnostic runtime modules; not re-exported. */