@actuarial-ts/core 0.5.0 → 0.6.1

package/dist/diagnosticIdentity.js

@@ -0,0 +1,721 @@
+import { canonicalJson, fnv1a64 } from "./canonical.js";
+import { normalizeDiagnosticPeriodWithAxis } from "./diagnosticPeriodAxis.js";
+import { diagnosticJsonPreflight, isDiagnosticPlainRecord, isDiagnosticToken, normalizeDiagnosticNumber, } from "./diagnosticRuntime.js";
+import { DiagnosticValidationError, } from "./types.js";
+/** Validates selector shapes without interpreting periods against a definition. */
+function validateFilterIdentityInput(filter) {
+    const issues = [
+        ...diagnosticJsonPreflight(filter, "configuration"),
+    ];
+    if (issues.length)
+        throw new DiagnosticValidationError(issues);
+    if (!isDiagnosticPlainRecord(filter))
+        throw new DiagnosticValidationError([
+            {
+                domain: "configuration",
+                code: "invalid-type",
+                path: "$",
+                message: "Filter must be a plain object or null",
+            },
+        ]);
+    const lists = [
+        "sourceGroups", "outputGroups", "origins", "valuations", "instanceIds",
+    ];
+    const labels = [
+        "originFrom", "originThrough", "valuationFrom", "valuationThrough",
+    ];
+    const bounds = ["minDevelopmentAge", "maxDevelopmentAge"];
+    const checkToken = (value, path) => {
+        if (!isDiagnosticToken(value))
+            issues.push({
+                domain: "configuration",
+                code: "invalid-string",
+                path,
+                message: "Filter selectors must use nonempty token strings",
+            });
+    };
+    for (const key of Object.keys(filter).sort()) {
+        const value = filter[key];
+        const path = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+            ? `$.${key}`
+            : `$[${JSON.stringify(key)}]`;
+        if (lists.includes(key)) {
+            if (!Array.isArray(value))
+                issues.push({
+                    domain: "configuration",
+                    code: "invalid-type",
+                    path,
+                    message: "Filter selector must be an array",
+                });
+            else
+                value.forEach((item, index) => checkToken(item, `${path}[${index}]`));
+        }
+        else if (labels.includes(key))
+            checkToken(value, path);
+        else if (bounds.includes(key)) {
+            if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+                issues.push({
+                    domain: "configuration",
+                    code: "invalid-number",
+                    path,
+                    message: "Development-age bounds must be nonnegative safe integers",
+                });
+        }
+        else
+            issues.push({
+                domain: "configuration",
+                code: "unknown-key",
+                path,
+                message: `Unknown filter key ${key}`,
+            });
+    }
+    if (typeof filter.minDevelopmentAge === "number" &&
+        typeof filter.maxDevelopmentAge === "number" &&
+        filter.minDevelopmentAge > filter.maxDevelopmentAge)
+        issues.push({
+            domain: "configuration",
+            code: "invalid-configuration",
+            path: "$",
+            message: "Minimum development age exceeds maximum",
+        });
+    if (issues.length)
+        throw new DiagnosticValidationError(issues);
+}
+/** Materializes optional selectors; period aliases must already be canonical. */
+export function normalizeDiagnosticsFilterIdentity(filter) {
+    if (filter === null)
+        return null;
+    validateFilterIdentityInput(filter);
+    return deepFreeze({
+        sourceGroups: filter.sourceGroups === undefined
+            ? null
+            : sortedUnique(filter.sourceGroups),
+        outputGroups: filter.outputGroups === undefined
+            ? null
+            : sortedUnique(filter.outputGroups),
+        origins: filter.origins === undefined ? null : sortedUnique(filter.origins),
+        originFrom: filter.originFrom ?? null,
+        originThrough: filter.originThrough ?? null,
+        valuations: filter.valuations === undefined ? null : sortedUnique(filter.valuations),
+        valuationFrom: filter.valuationFrom ?? null,
+        valuationThrough: filter.valuationThrough ?? null,
+        minDevelopmentAge: filter.minDevelopmentAge === undefined
+            ? null
+            : normalizeDiagnosticNumber(filter.minDevelopmentAge),
+        maxDevelopmentAge: filter.maxDevelopmentAge === undefined
+            ? null
+            : normalizeDiagnosticNumber(filter.maxDevelopmentAge),
+        instanceIds: filter.instanceIds === undefined ? null : sortedUnique(filter.instanceIds),
+    });
+}
+/**
+ * Owned identity copy. Source slots are schema-defined; free JSON dimensions
+ * must not be interpreted as source evidence just because a key looks similar.
+ */
+export function projectDiagnosticIdentity(value) {
+    const issues = diagnosticJsonPreflight(value, "input", {
+        maxNodes: Number.MAX_SAFE_INTEGER,
+    });
+    if (issues.length)
+        throw new DiagnosticValidationError(issues);
+    const clone = (item, sourceSlot = false, freeJson = false, path = "$") => {
+        if (item === null || typeof item !== "object")
+            return typeof item === "number" && Object.is(item, -0) ? 0 : item;
+        if (Array.isArray(item))
+            return Object.freeze(item.map((child, index) => clone(child, sourceSlot, freeJson, `${path}[${index}]`)));
+        const record = item;
+        if (sourceSlot && typeof record.artifactId === "string") {
+            const sourceIssues = [];
+            for (const key of Object.keys(record)) {
+                const fieldPath = `${path}.${key}`;
+                if (![
+                    "artifactId",
+                    "sourceFile",
+                    "sourceSheet",
+                    "sourceRow",
+                    "sourceCell",
+                ].includes(key))
+                    sourceIssues.push({
+                        domain: "input",
+                        code: "unknown-key",
+                        path: fieldPath,
+                        message: `Unknown source-location key ${key}`,
+                    });
+                else if (key === "sourceRow") {
+                    if (record[key] !== null &&
+                        !(typeof record[key] === "number" &&
+                            Number.isSafeInteger(record[key]) &&
+                            record[key] >= 0))
+                        sourceIssues.push({
+                            domain: "input",
+                            code: "invalid-number",
+                            path: fieldPath,
+                            message: "Source row must be a nonnegative safe integer or null",
+                        });
+                }
+                else if (!(key !== "artifactId" && record[key] === null) &&
+                    !isDiagnosticToken(record[key]))
+                    sourceIssues.push({
+                        domain: "input",
+                        code: "invalid-string",
+                        path: fieldPath,
+                        message: "Source location must use nonempty token strings",
+                    });
+            }
+            if (sourceIssues.length)
+                throw new DiagnosticValidationError(sourceIssues);
+            return normalizeDiagnosticSourceLocation(record);
+        }
+        const result = Object.create(null);
+        for (const key of Object.keys(record).sort()) {
+            const opaque = freeJson || key === "groupDimensions" || key === "dimensions";
+            result[key] = clone(record[key], !opaque && (key === "source" || key === "sources"), opaque, `${path}.${key}`);
+        }
+        return Object.freeze(result);
+    };
+    return clone(value);
+}
+function compareCodeUnits(left, right) {
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort(compareCodeUnits);
+}
+function sortedRecord(entries) {
+    const result = Object.create(null);
+    for (const [key, value] of [...entries].sort(([left], [right]) => compareCodeUnits(left, right))) {
+        result[key] = value;
+    }
+    return result;
+}
+function normalizeJsonValue(value) {
+    if (typeof value === "number" && Object.is(value, -0))
+        return 0;
+    if (Array.isArray(value))
+        return value.map((item) => normalizeJsonValue(item));
+    if (value !== null && typeof value === "object") {
+        return sortedRecord(Object.entries(value).map(([key, item]) => [key, normalizeJsonValue(item)]));
+    }
+    return value;
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        deepFreeze(child, seen);
+    return Object.freeze(value);
+}
+function attributes(value) {
+    return sortedRecord(Object.entries(value ?? {}).map(([key, item]) => [key, normalizeJsonValue(item)]));
+}
+function normalizeLimitation(limitation) {
+    if (limitation.kind === "unlimited")
+        return { kind: "unlimited" };
+    if (limitation.kind === "unknown") {
+        return { kind: "unknown", description: limitation.description ?? null };
+    }
+    return {
+        kind: limitation.kind,
+        attachment: Object.is(limitation.attachment, -0)
+            ? 0
+            : limitation.attachment,
+        limit: limitation.limit !== null && Object.is(limitation.limit, -0)
+            ? 0
+            : limitation.limit,
+        application: limitation.application,
+        derivation: limitation.derivation.kind === "sdk"
+            ? { kind: "sdk" }
+            : {
+                kind: "external",
+                actor: limitation.derivation.actor,
+                transformationRef: limitation.derivation.transformationRef,
+            },
+    };
+}
+function normalizeMeasureExpression(expression) {
+    if (expression.op === "measure")
+        return {
+            op: "measure",
+            measureId: expression.measureId,
+        };
+    if (expression.op === "claim-layer") {
+        return {
+            op: "claim-layer",
+            measureId: expression.measureId,
+            attachment: Object.is(expression.attachment, -0)
+                ? 0
+                : expression.attachment,
+            limit: expression.limit !== null && Object.is(expression.limit, -0)
+                ? 0
+                : expression.limit,
+        };
+    }
+    if (expression.op === "subtract") {
+        return {
+            op: "subtract",
+            left: normalizeMeasureExpression(expression.left),
+            right: normalizeMeasureExpression(expression.right),
+        };
+    }
+    return {
+        op: "add",
+        terms: expression.terms.map((term) => normalizeMeasureExpression(term)),
+    };
+}
+function normalizeRoleExpression(expression) {
+    if (expression.op === "role")
+        return { op: "role", role: expression.role };
+    if (expression.op === "subtract") {
+        return {
+            op: "subtract",
+            left: normalizeRoleExpression(expression.left),
+            right: normalizeRoleExpression(expression.right),
+        };
+    }
+    return { op: "add", terms: expression.terms.map(normalizeRoleExpression) };
+}
+function normalizeTolerance(tolerance) {
+    return {
+        absolute: Object.is(tolerance?.absolute ?? 0, -0)
+            ? 0
+            : (tolerance?.absolute ?? 0),
+        relative: Object.is(tolerance?.relative ?? 0, -0)
+            ? 0
+            : (tolerance?.relative ?? 0),
+    };
+}
+function normalizeRuleOperand(operand) {
+    if (operand.source === "measure") {
+        return {
+            source: "measure",
+            expression: normalizeMeasureExpression(operand.expression),
+        };
+    }
+    if (operand.source === "calculation")
+        return { source: "calculation", field: operand.field };
+    return {
+        source: "constant",
+        value: Object.is(operand.value, -0) ? 0 : operand.value,
+    };
+}
+function normalizeReviewOperand(operand) {
+    if (operand.op === "constant")
+        return {
+            op: "constant",
+            value: Object.is(operand.value, -0) ? 0 : operand.value,
+        };
+    return normalizeMeasureExpression(operand);
+}
+function normalizeReviewFilter(filter, axis) {
+    const normalizeMany = (side, values) => values === undefined
+        ? null
+        : sortedUnique(values.map((value) => normalizeDiagnosticPeriodWithAxis(axis, side, value).label));
+    const normalizeOne = (side, value) => value === undefined
+        ? null
+        : normalizeDiagnosticPeriodWithAxis(axis, side, value).label;
+    return {
+        sourceGroups: filter.sourceGroups === undefined
+            ? null
+            : sortedUnique(filter.sourceGroups),
+        origins: normalizeMany("origin", filter.origins),
+        originFrom: normalizeOne("origin", filter.originFrom),
+        originThrough: normalizeOne("origin", filter.originThrough),
+        valuations: normalizeMany("valuation", filter.valuations),
+        valuationFrom: normalizeOne("valuation", filter.valuationFrom),
+        valuationThrough: normalizeOne("valuation", filter.valuationThrough),
+        minDevelopmentAge: filter.minDevelopmentAge === undefined
+            ? null
+            : Object.is(filter.minDevelopmentAge, -0)
+                ? 0
+                : filter.minDevelopmentAge,
+        maxDevelopmentAge: filter.maxDevelopmentAge === undefined
+            ? null
+            : Object.is(filter.maxDevelopmentAge, -0)
+                ? 0
+                : filter.maxDevelopmentAge,
+    };
+}
+function normalizePeriodAxis(axis) {
+    if (axis.kind === "calendar") {
+        return {
+            kind: "calendar",
+            originCadence: axis.originCadence,
+            valuationCadence: axis.valuationCadence,
+            originAnchor: axis.originAnchor,
+            valuationAnchor: axis.valuationAnchor,
+            ageUnit: "month",
+            ageOffset: Object.is(axis.ageOffset, -0) ? 0 : axis.ageOffset,
+        };
+    }
+    const coordinates = (values) => values
+        .map((coordinate) => ({
+        label: coordinate.label,
+        aliases: sortedUnique(coordinate.aliases ?? []),
+        coordinate: Object.is(coordinate.coordinate, -0)
+            ? 0
+            : coordinate.coordinate,
+    }))
+        .sort((left, right) => left.coordinate - right.coordinate ||
+        compareCodeUnits(left.label, right.label));
+    return {
+        kind: "ordered",
+        id: axis.id,
+        version: axis.version,
+        ageUnit: axis.ageUnit,
+        ageOffset: Object.is(axis.ageOffset, -0) ? 0 : axis.ageOffset,
+        origins: coordinates(axis.origins),
+        valuations: coordinates(axis.valuations),
+    };
+}
+function topologicalDerivations(derivations) {
+    const byOutput = new Map(derivations.map((derivation) => [derivation.outputMeasureId, derivation]));
+    const remaining = new Map(derivations.map((derivation) => [derivation.id, derivation]));
+    const emittedOutputs = new Set();
+    const ordered = [];
+    while (remaining.size > 0) {
+        const ready = [...remaining.values()]
+            .filter((derivation) => expressionDependencies(derivation.expression)
+            .filter((id) => byOutput.has(id))
+            .every((id) => emittedOutputs.has(id)))
+            .sort((left, right) => compareCodeUnits(left.id, right.id));
+        if (ready.length === 0)
+            return [...derivations].sort((left, right) => compareCodeUnits(left.id, right.id));
+        for (const derivation of ready) {
+            ordered.push(derivation);
+            emittedOutputs.add(derivation.outputMeasureId);
+            remaining.delete(derivation.id);
+        }
+    }
+    return ordered;
+}
+function normalizeReviewRule(rule, axis) {
+    const base = {
+        id: rule.id,
+        code: rule.code,
+        description: rule.description,
+        severity: rule.severity,
+        missingInput: rule.missingInput,
+        tolerance: normalizeTolerance(rule.tolerance),
+    };
+    if (rule.kind === "compare") {
+        return {
+            ...base,
+            kind: "compare",
+            when: {
+                left: normalizeReviewOperand(rule.when.left),
+                operator: rule.when.operator,
+                right: normalizeReviewOperand(rule.when.right),
+            },
+        };
+    }
+    if (rule.kind === "reconcile") {
+        return {
+            ...base,
+            kind: "reconcile",
+            actual: normalizeMeasureExpression(rule.actual),
+            expected: normalizeReviewOperand(rule.expected),
+        };
+    }
+    if (rule.kind === "monotonic") {
+        return {
+            ...base,
+            kind: "monotonic",
+            expression: normalizeMeasureExpression(rule.expression),
+            direction: rule.direction,
+        };
+    }
+    if (rule.kind === "layer-order") {
+        return {
+            ...base,
+            kind: "layer-order",
+            narrower: normalizeMeasureExpression(rule.narrower),
+            broader: normalizeMeasureExpression(rule.broader),
+            comparability: normalizeJsonValue(rule.comparability),
+        };
+    }
+    return {
+        ...base,
+        kind: "control-total",
+        expression: normalizeMeasureExpression(rule.expression),
+        expected: Object.is(rule.expected, -0) ? 0 : rule.expected,
+        filter: rule.filter === undefined
+            ? null
+            : normalizeReviewFilter(rule.filter, axis),
+        projection: rule.projection.kind === "valuation"
+            ? {
+                kind: "valuation",
+                valuation: normalizeDiagnosticPeriodWithAxis(axis, "valuation", rule.projection.valuation).label,
+            }
+            : normalizeJsonValue(rule.projection),
+    };
+}
+export function normalizeDiagnosticDefinition(definition) {
+    const normalized = {
+        diagnosticDefinitionVersion: "1.0.0",
+        id: definition.id,
+        version: definition.version,
+        lossRowGrain: definition.lossRowGrain,
+        measures: definition.measures
+            .map((measure) => ({
+            id: measure.id,
+            displayName: measure.displayName,
+            description: measure.description,
+            source: measure.source,
+            kind: measure.kind,
+            unit: measure.unit,
+            developmentSemantics: measure.developmentSemantics,
+            aggregation: "sum",
+            missing: measure.missing,
+            basisId: measure.basisId ?? null,
+            countPopulationId: measure.countPopulationId ?? null,
+            exposureBasisId: measure.exposureBasisId ?? null,
+            exposureTiming: measure.exposureTiming ?? null,
+        }))
+            .sort((left, right) => compareCodeUnits(left.id, right.id)),
+        countPopulations: definition.countPopulations
+            .map((population) => ({
+            id: population.id,
+            displayName: population.displayName,
+            subject: population.subject,
+            unit: population.unit,
+            description: population.description,
+            attributes: attributes(population.attributes),
+        }))
+            .sort((left, right) => compareCodeUnits(left.id, right.id)),
+        exposureBases: definition.exposureBases
+            .map((basis) => ({
+            id: basis.id,
+            displayName: basis.displayName,
+            basis: basis.basis,
+            unit: basis.unit,
+            description: basis.description,
+            sourceDescription: basis.sourceDescription ?? null,
+            attributes: attributes(basis.attributes),
+        }))
+            .sort((left, right) => compareCodeUnits(left.id, right.id)),
+        amountBases: definition.amountBases
+            .map((basis) => ({
+            id: basis.id,
+            displayName: basis.displayName,
+            currency: basis.currency,
+            perspective: basis.perspective,
+            components: basis.components
+                .map((component) => ({
+                id: component.id,
+                treatment: component.treatment,
+                limitation: normalizeLimitation(component.limitation),
+            }))
+                .sort((left, right) => compareCodeUnits(left.id, right.id)),
+            sourceDescription: basis.sourceDescription ?? null,
+            attributes: attributes(basis.attributes),
+        }))
+            .sort((left, right) => compareCodeUnits(left.id, right.id)),
+        derivedMeasures: topologicalDerivations(definition.derivedMeasures).map((derivation) => ({
+            id: derivation.id,
+            outputMeasureId: derivation.outputMeasureId,
+            expression: normalizeMeasureExpression(derivation.expression),
+        })),
+        formulas: definition.formulas
+            .map((formula) => ({
+            id: formula.id,
+            version: formula.version,
+            roles: sortedRecord(Object.entries(formula.roles).map(([name, role]) => [
+                name,
+                {
+                    kind: role.kind,
+                    compatibilityGroup: role.compatibilityGroup ?? null,
+                    developmentSemantics: role.developmentSemantics ?? null,
+                },
+            ])),
+            numerator: normalizeRoleExpression(formula.numerator),
+            denominator: normalizeRoleExpression(formula.denominator),
+            denominatorPolicy: "positive-or-null",
+        }))
+            .sort((left, right) => compareCodeUnits(left.id, right.id)),
+        instances: definition.instances.map((instance) => ({
+            id: instance.id,
+            version: instance.version,
+            formulaId: instance.formulaId,
+            bindings: sortedRecord(Object.entries(instance.bindings).map(([role, expression]) => [role, normalizeMeasureExpression(expression)])),
+            presentation: {
+                displayName: instance.presentation.displayName,
+                description: instance.presentation.description,
+                displayUnit: instance.presentation.displayUnit,
+                scale: Object.is(instance.presentation.scale, -0)
+                    ? 0
+                    : instance.presentation.scale,
+                numeratorLabel: instance.presentation.numeratorLabel,
+                denominatorLabel: instance.presentation.denominatorLabel,
+            },
+            rules: instance.rules.map((rule) => ({
+                id: rule.id,
+                code: rule.code,
+                message: rule.message,
+                severity: rule.severity,
+                when: {
+                    left: normalizeRuleOperand(rule.when.left),
+                    operator: rule.when.operator,
+                    right: normalizeRuleOperand(rule.when.right),
+                    tolerance: normalizeTolerance(rule.when.tolerance),
+                },
+            })),
+        })),
+        reviewRules: definition.reviewRules.map((rule) => normalizeReviewRule(rule, definition.periodAxis)),
+        periodAxis: normalizePeriodAxis(definition.periodAxis),
+    };
+    return deepFreeze(normalized);
+}
+export function normalizeDiagnosticSourceLocation(source) {
+    return deepFreeze({
+        artifactId: source.artifactId,
+        sourceFile: source.sourceFile ?? null,
+        sourceSheet: source.sourceSheet ?? null,
+        sourceRow: source.sourceRow === undefined
+            ? null
+            : Object.is(source.sourceRow, -0)
+                ? 0
+                : source.sourceRow,
+        sourceCell: source.sourceCell ?? null,
+    });
+}
+function expressionDependencies(expression) {
+    if (expression.op === "measure" || expression.op === "claim-layer")
+        return [expression.measureId];
+    if (expression.op === "subtract")
+        return sortedUnique([
+            ...expressionDependencies(expression.left),
+            ...expressionDependencies(expression.right),
+        ]);
+    return sortedUnique(expression.terms.flatMap(expressionDependencies));
+}
+function ruleMeasureDependencies(operand) {
+    return operand.source === "measure"
+        ? expressionDependencies(operand.expression)
+        : [];
+}
+function tag(kind, property, value) {
+    return `fnv1a64-jcs-v1:${fnv1a64(canonicalJson({
+        identityVersion: 1,
+        kind,
+        [property]: value,
+    }))}`;
+}
+export function buildDiagnosticIdentities(definition) {
+    const formulas = new Map(definition.formulas.map((formula) => [formula.id, formula]));
+    const measures = new Map(definition.measures.map((measure) => [measure.id, measure]));
+    const derivations = new Map(definition.derivedMeasures.map((derivation) => [
+        derivation.outputMeasureId,
+        derivation,
+    ]));
+    const populations = new Map(definition.countPopulations.map((population) => [
+        population.id,
+        population,
+    ]));
+    const exposureBases = new Map(definition.exposureBases.map((basis) => [basis.id, basis]));
+    const amountBases = new Map(definition.amountBases.map((basis) => [basis.id, basis]));
+    const formulaFingerprints = sortedRecord(definition.formulas.map((formula) => [formula.id, tag("diagnostic-formula", "formula", formula)]));
+    const calculationFingerprints = Object.create(null);
+    const calculationScopesByInstanceId = new Map();
+    const calculationDependenciesByInstanceId = new Map();
+    const evaluationDependenciesByInstanceId = new Map();
+    const transitiveDependencies = (roots) => {
+        const found = new Set();
+        const stack = [...roots];
+        while (stack.length > 0) {
+            const id = stack.pop();
+            if (found.has(id))
+                continue;
+            found.add(id);
+            const derivation = derivations.get(id);
+            if (derivation)
+                stack.push(...expressionDependencies(derivation.expression));
+        }
+        return [...found].sort(compareCodeUnits);
+    };
+    for (const instance of definition.instances) {
+        const calculationDependencies = transitiveDependencies(Object.values(instance.bindings).flatMap(expressionDependencies));
+        const evaluationDependencies = transitiveDependencies([
+            ...calculationDependencies,
+            ...instance.rules.flatMap((rule) => [
+                ...ruleMeasureDependencies(rule.when.left),
+                ...ruleMeasureDependencies(rule.when.right),
+            ]),
+        ]);
+        calculationDependenciesByInstanceId.set(instance.id, calculationDependencies);
+        evaluationDependenciesByInstanceId.set(instance.id, evaluationDependencies);
+        const selectedMeasures = calculationDependencies
+            .map((id) => measures.get(id))
+            .filter(Boolean);
+        const selectedDerivations = definition.derivedMeasures.filter((derivation) => calculationDependencies.includes(derivation.outputMeasureId));
+        const countPopulationIds = sortedUnique(selectedMeasures.flatMap((measure) => measure.countPopulationId === null ? [] : [measure.countPopulationId]));
+        const exposureBasisIds = sortedUnique(selectedMeasures.flatMap((measure) => measure.exposureBasisId === null ? [] : [measure.exposureBasisId]));
+        const amountBasisIds = sortedUnique(selectedMeasures.flatMap((measure) => measure.basisId === null ? [] : [measure.basisId]));
+        const scope = {
+            formulaFingerprint: formulaFingerprints[instance.formulaId],
+            instance: {
+                id: instance.id,
+                version: instance.version,
+                formulaId: instance.formulaId,
+                bindings: instance.bindings,
+            },
+            lossRowGrain: definition.lossRowGrain,
+            measures: selectedMeasures.map((measure) => ({
+                id: measure.id,
+                source: measure.source,
+                kind: measure.kind,
+                unit: measure.unit,
+                developmentSemantics: measure.developmentSemantics,
+                aggregation: "sum",
+                missing: measure.missing,
+                basisId: measure.basisId,
+                countPopulationId: measure.countPopulationId,
+                exposureBasisId: measure.exposureBasisId,
+                exposureTiming: measure.exposureTiming,
+            })),
+            countPopulations: countPopulationIds.map((id) => {
+                const population = populations.get(id);
+                return {
+                    id,
+                    subject: population.subject,
+                    unit: population.unit,
+                    attributes: population.attributes,
+                };
+            }),
+            exposureBases: exposureBasisIds.map((id) => {
+                const basis = exposureBases.get(id);
+                return {
+                    id,
+                    basis: basis.basis,
+                    unit: basis.unit,
+                    attributes: basis.attributes,
+                };
+            }),
+            amountBases: amountBasisIds.map((id) => {
+                const basis = amountBases.get(id);
+                return {
+                    id,
+                    currency: basis.currency,
+                    perspective: basis.perspective,
+                    components: basis.components,
+                    attributes: basis.attributes,
+                };
+            }),
+            derivedMeasures: selectedDerivations,
+        };
+        const frozenScope = deepFreeze(scope);
+        calculationScopesByInstanceId.set(instance.id, frozenScope);
+        calculationFingerprints[instance.id] = tag("diagnostic-calculation", "calculation", frozenScope);
+    }
+    return {
+        formulaFingerprints: deepFreeze(formulaFingerprints),
+        calculationFingerprints: deepFreeze(sortedRecord(Object.entries(calculationFingerprints))),
+        definitionIntegrity: tag("diagnostic-definition", "definition", definition),
+        calculationScopesByInstanceId,
+        calculationDependenciesByInstanceId,
+        evaluationDependenciesByInstanceId,
+    };
+}
+//# sourceMappingURL=diagnosticIdentity.js.map