@spottoai/types-package 1.0.2-dev1138.1 → 1.0.2-dev1138.12

package/dist/esm/azure/financialAuthorityProjectionKernel.js

@@ -0,0 +1,263 @@
+import { FINANCIAL_AUTHORITY_RESOURCE_PROJECTION_CONTRACT_VERSION_V1, } from './financialAuthorityView.js';
+import { FINANCIAL_SAVINGS_RESOURCE_PROJECTION_CONTRACT_VERSION_V1, } from './financialSavingsAuthority.js';
+import { AZURE_BILLED_ALL_CHARGES_POLICY_V1, resolveFinancialChargeInclusionPolicyV1, } from './financialChargeComposition.js';
+import { classifyFinancialSavingsAllocationForPolicyV1 } from './financialSavingsChargePolicyKernel.js';
+const normalize = (value) => value.trim().toLowerCase().replace(/\/+$/, '');
+/** Derives one compact, non-additive resource view from a validated canonical authority. */
+export const projectFinancialAuthorityResourceV1 = (authority, resourceType, scopeId) => {
+    const normalizedType = normalize(resourceType);
+    const normalizedScopeId = normalize(scopeId);
+    const coverage = authority.scopeCoverage.find(entry => normalize(entry.resourceType) === normalizedType && entry.scopeIds.some(candidate => normalize(candidate) === normalizedScopeId));
+    if (!coverage)
+        return undefined;
+    const coordinates = authority.coordinates.map(coordinate => {
+        const owners = coordinate.ownerBaselines.filter(baseline => normalize(baseline.scopeId) === normalizedScopeId);
+        const ownerBaseline = owners[0];
+        if (owners.length !== 1 || !ownerBaseline)
+            throw new TypeError('Financial authority resource owner is missing or ambiguous.');
+        const chargeComposition = ownerBaseline.status === 'available' && ownerBaseline.baselineKind === 'owner'
+            ? coordinate.chargeCompositions.find(composition => composition.baselineId === ownerBaseline.baselineId)
+            : undefined;
+        if (ownerBaseline.status === 'available' && ownerBaseline.baselineKind === 'owner' && !chargeComposition) {
+            throw new TypeError('Financial authority resource charge composition is missing.');
+        }
+        const displayRollups = (coordinate.displayRollups ?? []).filter(rollup => normalize(rollup.displayScopeId) === normalizedScopeId);
+        const displayMemberBaselineIds = new Set(displayRollups.flatMap(rollup => rollup.members.map(member => member.baselineId)).filter(baselineId => baselineId !== ownerBaseline.baselineId));
+        const displayMemberBaselines = coordinate.ownerBaselines.filter(baseline => baseline.status === 'available' &&
+            baseline.baselineKind === 'owner' &&
+            displayMemberBaselineIds.has(baseline.baselineId));
+        if (displayMemberBaselines.length !== displayMemberBaselineIds.size) {
+            throw new TypeError('Financial authority resource display member baseline is missing.');
+        }
+        const displayMemberChargeCompositions = (coordinate.chargeCompositions ?? []).filter(composition => displayMemberBaselineIds.has(composition.baselineId));
+        if (displayMemberBaselines.some(baseline => baseline.status === 'available' &&
+            baseline.baselineKind === 'owner' &&
+            !displayMemberChargeCompositions.some(composition => composition.baselineId === baseline.baselineId))) {
+            throw new TypeError('Financial authority resource display member charge composition is missing.');
+        }
+        const displayMemberships = new Set(displayRollups.flatMap(rollup => rollup.members.map(member => `${member.baselineId}\u0000${member.componentId}`)));
+        return {
+            coordinateId: coordinate.coordinateId,
+            periodRole: coordinate.periodRole,
+            period: coordinate.period,
+            costBasis: coordinate.costBasis,
+            estimateLens: coordinate.estimateLens,
+            ...(coordinate.requestedCurrencyCode === undefined ? {} : { requestedCurrencyCode: coordinate.requestedCurrencyCode }),
+            ownerBaseline,
+            ...(displayMemberBaselines.length === 0 ? {} : { displayMemberBaselines }),
+            ...(chargeComposition === undefined ? {} : { chargeComposition }),
+            ...(displayMemberChargeCompositions.length === 0 ? {} : { displayMemberChargeCompositions }),
+            componentDescriptors: (coordinate.componentDescriptors ?? []).filter(descriptor => displayMemberships.has(`${descriptor.baselineId}\u0000${descriptor.componentId}`)),
+            displayRollups,
+            projections: coordinate.projections.filter(projection => normalize(projection.scopeId) === normalizedScopeId),
+        };
+    });
+    const firstCoordinate = coordinates[0];
+    if (!firstCoordinate)
+        throw new TypeError('Financial authority resource projection has no coordinates.');
+    const assessmentIds = new Set();
+    const bundleIds = new Set();
+    coordinates.forEach(coordinate => {
+        assessmentIds.add(coordinate.ownerBaseline.assessmentId);
+        if (coordinate.ownerBaseline.status === 'available' && coordinate.ownerBaseline.baselineKind === 'owner') {
+            bundleIds.add(coordinate.ownerBaseline.evidenceBundleId);
+        }
+        for (const baseline of coordinate.displayMemberBaselines ?? []) {
+            assessmentIds.add(baseline.assessmentId);
+            if (baseline.status === 'available' && baseline.baselineKind === 'owner')
+                bundleIds.add(baseline.evidenceBundleId);
+        }
+        coordinate.projections.forEach(projection => {
+            if (projection.targetAssessmentId)
+                assessmentIds.add(projection.targetAssessmentId);
+            if (projection.targetEvidenceBundleId)
+                bundleIds.add(projection.targetEvidenceBundleId);
+        });
+    });
+    const evidenceAssessments = authority.evidenceAssessments.filter(assessment => assessmentIds.has(assessment.assessmentId));
+    evidenceAssessments.forEach(assessment => {
+        if (assessment.evidenceBundleId)
+            bundleIds.add(assessment.evidenceBundleId);
+    });
+    return {
+        contractVersion: FINANCIAL_AUTHORITY_RESOURCE_PROJECTION_CONTRACT_VERSION_V1,
+        authorityId: authority.authorityId,
+        provider: authority.provider,
+        providerAccountRefs: authority.providerAccountRefs,
+        artifactGeneration: authority.artifactGeneration,
+        billingGenerationId: authority.billingGenerationId,
+        resourceType: coverage.resourceType,
+        financialRole: coverage.financialRole,
+        scopeId: normalizedScopeId,
+        evidenceBundles: authority.evidenceBundles.filter(bundle => bundleIds.has(bundle.bundleId)),
+        evidenceAssessments,
+        coordinates: [firstCoordinate, ...coordinates.slice(1)],
+    };
+};
+/** Derives the matching compact savings view for one canonical resource owner. */
+export const projectFinancialSavingsResourceV1 = (savingsAuthority, financialProjection, financialAuthority, chargeInclusionPolicyRef = AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef) => {
+    if (savingsAuthority.financialAuthorityId !== financialProjection.authorityId ||
+        savingsAuthority.artifactGeneration.runId !== financialProjection.artifactGeneration.runId ||
+        savingsAuthority.artifactGeneration.generatedAt !== financialProjection.artifactGeneration.generatedAt) {
+        throw new TypeError('Financial savings authority is not bound to the resource Financial Authority projection.');
+    }
+    if (!resolveFinancialChargeInclusionPolicyV1(chargeInclusionPolicyRef)) {
+        throw new TypeError('Financial savings resource charge-inclusion policy is not registered.');
+    }
+    if (financialAuthority !== undefined &&
+        (financialAuthority.authorityId !== financialProjection.authorityId ||
+            financialAuthority.artifactGeneration.runId !== financialProjection.artifactGeneration.runId ||
+            financialAuthority.artifactGeneration.generatedAt !== financialProjection.artifactGeneration.generatedAt)) {
+        throw new TypeError('Full Financial Authority is not bound to the resource projection.');
+    }
+    const normalizedScopeId = normalize(financialProjection.scopeId);
+    const financialCoordinateIds = new Set(financialProjection.coordinates.map(coordinate => coordinate.coordinateId));
+    const savingsByCoordinateId = new Map(savingsAuthority.coordinates.map(coordinate => [coordinate.coordinateId, coordinate]));
+    if (financialCoordinateIds.size !== financialProjection.coordinates.length ||
+        savingsAuthority.coordinates.length !== financialProjection.coordinates.length ||
+        savingsAuthority.coordinates.some(coordinate => !financialCoordinateIds.has(coordinate.coordinateId))) {
+        throw new TypeError('Financial savings coordinates do not match the resource Financial Authority projection.');
+    }
+    const coordinates = financialProjection.coordinates.map(financialCoordinate => {
+        const coordinate = savingsByCoordinateId.get(financialCoordinate.coordinateId);
+        if (!coordinate)
+            throw new TypeError('Financial savings coordinate is missing.');
+        if (coordinate.status === 'unavailable')
+            return { ...coordinate, chargeInclusionPolicyRef };
+        const displayOwnerScopeIds = new Set((financialCoordinate.displayMemberBaselines ?? []).map(baseline => normalize(baseline.scopeId)));
+        displayOwnerScopeIds.delete(normalizedScopeId);
+        const selectedOwnerScopeIds = new Set([normalizedScopeId, ...displayOwnerScopeIds]);
+        const resourceAllocations = coordinate.allocations.filter(allocation => selectedOwnerScopeIds.has(normalize(allocation.ownerScopeId)));
+        const sourceResourceContributions = coordinate.resourceContributions.filter(contribution => selectedOwnerScopeIds.has(normalize(contribution.ownerScopeId)));
+        const sourceResourceContributionByOwner = new Map();
+        for (const contribution of sourceResourceContributions) {
+            const ownerScopeId = normalize(contribution.ownerScopeId);
+            if (sourceResourceContributionByOwner.has(ownerScopeId)) {
+                throw new TypeError('Financial savings resource contribution is ambiguous.');
+            }
+            sourceResourceContributionByOwner.set(ownerScopeId, contribution);
+        }
+        for (const ownerScopeId of selectedOwnerScopeIds) {
+            const sourceRecommendationSavings = coordinate.recommendationContributions
+                .filter(contribution => normalize(contribution.ownerScopeId) === ownerScopeId)
+                .reduce((total, contribution) => {
+                const next = total + contribution.savingsMinorUnits;
+                if (!Number.isSafeInteger(next)) {
+                    throw new TypeError('Financial savings recommendation contribution overflows safe minor units.');
+                }
+                return next;
+            }, 0);
+            if ((sourceResourceContributionByOwner.get(ownerScopeId)?.savingsMinorUnits ?? 0) !== sourceRecommendationSavings) {
+                throw new TypeError('Financial savings recommendation contributions do not reconcile to the resource contribution.');
+            }
+        }
+        const policyUnavailableScenarioIds = new Set();
+        const chargeCompositionByBaselineId = new Map([
+            ...(financialCoordinate.chargeComposition ? [financialCoordinate.chargeComposition] : []),
+            ...(financialCoordinate.displayMemberChargeCompositions ?? []),
+        ].map(composition => [composition.baselineId, composition]));
+        const selectedAllocations = resourceAllocations.filter(allocation => {
+            if (chargeInclusionPolicyRef.policyId === AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef.policyId &&
+                chargeInclusionPolicyRef.policyDigest === AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef.policyDigest)
+                return true;
+            const disposition = classifyFinancialSavingsAllocationForPolicyV1(chargeCompositionByBaselineId, allocation, chargeInclusionPolicyRef);
+            if (disposition === 'unavailable')
+                policyUnavailableScenarioIds.add(allocation.scenarioId);
+            return disposition === 'included';
+        });
+        const allocationsByRecommendation = new Map();
+        for (const allocation of selectedAllocations) {
+            const key = `${normalize(allocation.ownerScopeId)}\u0000${allocation.recommendationId}`;
+            const current = allocationsByRecommendation.get(key) ?? [];
+            current.push(allocation);
+            allocationsByRecommendation.set(key, current);
+        }
+        const allRecommendationContributions = [...allocationsByRecommendation.entries()]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([, allocations]) => {
+            const firstAllocation = allocations[0];
+            if (!firstAllocation)
+                throw new TypeError('Financial savings recommendation contribution has no allocation.');
+            const savingsMinorUnits = allocations.reduce((total, allocation) => {
+                const next = total + allocation.savingsMinorUnits;
+                if (!Number.isSafeInteger(next)) {
+                    throw new TypeError('Financial savings recommendation contribution overflows safe minor units.');
+                }
+                return next;
+            }, 0);
+            return {
+                ownerScopeId: normalize(firstAllocation.ownerScopeId),
+                recommendationId: firstAllocation.recommendationId,
+                allocationIds: allocations.map(allocation => allocation.allocationId),
+                savingsMinorUnits,
+            };
+        });
+        const recommendationContributions = allRecommendationContributions.filter(contribution => normalize(contribution.ownerScopeId) === normalizedScopeId);
+        const displayMemberRecommendationContributions = allRecommendationContributions.filter(contribution => displayOwnerScopeIds.has(normalize(contribution.ownerScopeId)));
+        const buildResourceContribution = (ownerScopeId) => {
+            const allocations = selectedAllocations.filter(allocation => normalize(allocation.ownerScopeId) === ownerScopeId);
+            if (allocations.length === 0)
+                return undefined;
+            const savingsMinorUnits = allocations.reduce((total, allocation) => {
+                const next = total + allocation.savingsMinorUnits;
+                if (!Number.isSafeInteger(next))
+                    throw new TypeError('Financial savings resource contribution overflows safe minor units.');
+                return next;
+            }, 0);
+            return {
+                ownerScopeId,
+                allocationIds: allocations.map(allocation => allocation.allocationId),
+                savingsMinorUnits,
+            };
+        };
+        const resourceContribution = buildResourceContribution(normalizedScopeId);
+        const displayMemberResourceContributions = [...displayOwnerScopeIds]
+            .sort()
+            .map(buildResourceContribution)
+            .filter((contribution) => contribution !== undefined);
+        const unavailableActivationIds = new Set(coordinate.status === 'partial'
+            ? coordinate.activations.filter(activation => activation.result === 'unavailable').map(activation => activation.scenarioId)
+            : []);
+        const authorityCoordinate = financialAuthority?.coordinates.find(candidate => candidate.coordinateId === financialCoordinate.coordinateId);
+        if (financialAuthority !== undefined && !authorityCoordinate) {
+            throw new TypeError('Full Financial Authority coordinate is missing for the resource projection.');
+        }
+        const unavailableScenarioIds = [...new Set([...unavailableActivationIds, ...policyUnavailableScenarioIds])]
+            .filter(scenarioId => {
+            if (!authorityCoordinate) {
+                // Without the full authority there is no proof that an absent target
+                // projection belongs elsewhere. Preserve the gap on this resource.
+                return true;
+            }
+            const scenarioProjections = authorityCoordinate.projections.filter(projection => projection.scenarioId === scenarioId);
+            return scenarioProjections.length === 0 || scenarioProjections.some(projection => selectedOwnerScopeIds.has(normalize(projection.scopeId)));
+        })
+            .sort();
+        const composed = {
+            coordinateId: coordinate.coordinateId,
+            chargeInclusionPolicyRef,
+            currentAggregateBaselineId: coordinate.currentAggregateBaselineId,
+            accountingCurrencyCode: coordinate.accountingCurrencyCode,
+            minorUnitScale: coordinate.minorUnitScale,
+            roundingMode: coordinate.roundingMode,
+            ...(resourceContribution === undefined ? {} : { resourceContribution }),
+            recommendationContributions,
+            ...(displayMemberResourceContributions.length === 0 ? {} : { displayMemberResourceContributions }),
+            ...(displayMemberRecommendationContributions.length === 0 ? {} : { displayMemberRecommendationContributions }),
+        };
+        return unavailableScenarioIds.length > 0
+            ? { ...composed, status: 'partial', unavailableScenarioIds: unavailableScenarioIds }
+            : { ...composed, status: 'available' };
+    });
+    const firstCoordinate = coordinates[0];
+    if (!firstCoordinate)
+        throw new TypeError('Financial savings resource projection has no coordinates.');
+    return {
+        contractVersion: FINANCIAL_SAVINGS_RESOURCE_PROJECTION_CONTRACT_VERSION_V1,
+        savingsAuthorityId: savingsAuthority.savingsAuthorityId,
+        financialAuthorityId: savingsAuthority.financialAuthorityId,
+        artifactGeneration: savingsAuthority.artifactGeneration,
+        scopeId: normalizedScopeId,
+        coordinates: [firstCoordinate, ...coordinates.slice(1)],
+    };
+};

package/dist/esm/azure/financialAuthorityViewValidation.js

@@ -5,6 +5,8 @@ import { isFinancialEvidenceAssessmentV1 } from './financialEvidenceAssessmentVa
 import { formatExactDecimalValue, multiplyExactDecimalValues, parseCanonicalDecimal, sumCanonicalDecimals } from '../common/exactDecimal.js';
 import { isFinancialBaselinePeriodV2, isFinancialEvidenceBundleV1, isFinancialScopeBaselineEnvelopeV2 } from './financialScopeBaselineValidation.js';
 import { isFinancialAuthorityComponentDescriptorV1, isFinancialDisplayRollupV1 } from './financialDisplayRollupValidation.js';
+import { AZURE_BILLED_ALL_CHARGES_POLICY_V1 } from './financialChargeComposition.js';
+import { isFinancialChargeCompositionV1 } from './financialChargeCompositionValidation.js';
 const SHA256_ID = /^sha256:[0-9a-f]{64}$/;
 const CURRENCY = /^[A-Z]{3}$/;
 const AZURE_RESOURCE_TYPE = /^[a-z0-9.-]+\/[a-z0-9._/-]+$/;
@@ -55,6 +57,7 @@ const canonicalCoordinatePreimage = (value) => ({
     ownerBaselines: [...value.ownerBaselines].sort((left, right) => left.scopeId.localeCompare(right.scopeId)),
     residualBaseline: value.residualBaseline,
     aggregateBaseline: value.aggregateBaseline,
+    chargeCompositions: [...value.chargeCompositions].sort((left, right) => left.baselineId.localeCompare(right.baselineId)),
     componentDescriptors: [...value.componentDescriptors].sort((left, right) => `${left.baselineId}\u0000${left.componentId}`.localeCompare(`${right.baselineId}\u0000${right.componentId}`)),
     displayRollups: [...value.displayRollups].sort((left, right) => left.displayRollupId.localeCompare(right.displayRollupId)),
     projections: [...value.projections].sort((left, right) => left.scenarioId.localeCompare(right.scenarioId)),
@@ -95,6 +98,7 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
             'ownerBaselines',
             'residualBaseline',
             'aggregateBaseline',
+            'chargeCompositions',
             'componentDescriptors',
             'displayRollups',
             'projections',
@@ -113,6 +117,9 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
         !value.ownerBaselines.every(isFinancialScopeBaselineEnvelopeV2) ||
         !isFinancialScopeBaselineEnvelopeV2(value.residualBaseline) ||
         !isFinancialScopeBaselineEnvelopeV2(value.aggregateBaseline) ||
+        !Array.isArray(value.chargeCompositions) ||
+        value.chargeCompositions.length > 20001 ||
+        !value.chargeCompositions.every(isFinancialChargeCompositionV1) ||
         !Array.isArray(value.componentDescriptors) ||
         value.componentDescriptors.length > 20000 ||
         !value.componentDescriptors.every(isFinancialAuthorityComponentDescriptorV1) ||
@@ -173,6 +180,38 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
     }
     if (coordinate.residualBaseline.status === 'available' && !bundleIds.has(coordinate.residualBaseline.evidenceBundleId))
         return false;
+    const composableBaselines = [...coordinate.ownerBaselines, coordinate.residualBaseline].filter((baseline) => baseline.status === 'available' && baseline.baselineKind === 'owner');
+    const chargeCompositionByBaselineId = new Map(coordinate.chargeCompositions.map(composition => [composition.baselineId, composition]));
+    if (chargeCompositionByBaselineId.size !== coordinate.chargeCompositions.length ||
+        coordinate.chargeCompositions.length !== composableBaselines.length)
+        return false;
+    for (const baseline of composableBaselines) {
+        const composition = chargeCompositionByBaselineId.get(baseline.baselineId);
+        if (composition === undefined ||
+            canonicalText(baseline.chargeInclusionPolicyRef) !== canonicalText(AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef) ||
+            composition.ownerScopeId !== baseline.scopeId ||
+            periodText(composition.period) !== periodText(baseline.period) ||
+            composition.costBasis !== baseline.costBasis ||
+            composition.estimateLens !== baseline.estimateLens ||
+            composition.accountingCurrencyCode !== baseline.total.currencyCode ||
+            composition.reconciliation.sourceTotal !== baseline.total.amount)
+            return false;
+        const baselineComponentById = new Map(baseline.components.map(component => [component.componentId, component]));
+        const partitionedComponentIds = composition.buckets.flatMap(bucket => bucket.componentIds);
+        if (partitionedComponentIds.length !== baseline.components.length ||
+            new Set(partitionedComponentIds).size !== partitionedComponentIds.length ||
+            partitionedComponentIds.some(componentId => !baselineComponentById.has(componentId)))
+            return false;
+        for (const bucket of composition.buckets) {
+            try {
+                if (formatExactDecimalValue(sumCanonicalDecimals(bucket.componentIds.map(componentId => baselineComponentById.get(componentId).amount))) !== bucket.amount)
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
     const financialOwnerBaselines = coordinate.ownerBaselines.filter(baseline => financialRoleByScope.get(baseline.scopeId) === 'owner');
     const availableMembers = [...financialOwnerBaselines, coordinate.residualBaseline]
         .filter(baseline => baseline.status === 'available')
@@ -256,7 +295,7 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
             (projection.targetEvidenceBundleId !== undefined && !bundleIds.has(projection.targetEvidenceBundleId)) ||
             (targetAssessment !== undefined &&
                 (targetAssessment.request.scopeId !== projection.scopeId ||
-                    targetAssessment.result !== 'available' ||
+                    (projection.status === 'available' && targetAssessment.result !== 'available') ||
                     targetAssessment.evidenceBundleId !== projection.targetEvidenceBundleId)) ||
             (projection.baselineId !== undefined && (owner.status !== 'available' || projection.baselineId !== owner.baselineId)) ||
             (projection.status === 'available' && owner.status !== 'available'))
@@ -328,6 +367,15 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
                             return false;
                         continue;
                     }
+                    if (projection.operationKind === 'replace-quantity-and-rate') {
+                        if (!('targetQuantity' in applied) || !('targetRate' in applied))
+                            return false;
+                        if (applied.targetQuantity.unit !== applied.targetRate.quantityUnit ||
+                            applied.targetRate.currencyCode !== projection.accountingCurrencyCode ||
+                            formatExactDecimalValue(multiplyExactDecimalValues(parseCanonicalDecimal(applied.targetQuantity.amount), parseCanonicalDecimal(applied.targetRate.amount))) !== applied.targetAmount)
+                            return false;
+                        continue;
+                    }
                     if (!('sourceRate' in applied) || !('targetQuantity' in applied) || component.effectiveRate === undefined)
                         return false;
                     if (applied.sourceRate.amount !== component.effectiveRate.amount ||
@@ -495,3 +543,225 @@ export const isFinancialAuthorityViewV1 = (value) => {
 export const isFinancialAuthorityViewBoundToArtifactGenerationV1 = (value, expected) => isFinancialAuthorityViewV1(value) &&
     value.artifactGeneration.runId === expected.runId &&
     value.artifactGeneration.generatedAt === expected.generatedAt;
+const isSameProviderAccountSet = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    const sortedLeft = [...left].sort();
+    const sortedRight = [...right].sort();
+    return sortedLeft.every((value, index) => value === sortedRight[index]);
+};
+const isResourceProjectionCoordinate = (value, projection, assessmentById, bundleIds) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, [
+            'coordinateId',
+            'periodRole',
+            'period',
+            'costBasis',
+            'estimateLens',
+            'ownerBaseline',
+            'componentDescriptors',
+            'displayRollups',
+            'projections',
+        ], [
+            'requestedCurrencyCode',
+            'displayMemberBaselines',
+            'chargeComposition',
+            'displayMemberChargeCompositions',
+        ]) ||
+        !isHash(value.coordinateId) ||
+        (value.periodRole !== 'current' && value.periodRole !== 'previous') ||
+        !isFinancialBaselinePeriodV2(value.period) ||
+        typeof value.costBasis !== 'string' ||
+        !COST_BASES.has(value.costBasis) ||
+        typeof value.estimateLens !== 'string' ||
+        !ESTIMATE_LENSES.has(value.estimateLens) ||
+        (value.requestedCurrencyCode !== undefined && (typeof value.requestedCurrencyCode !== 'string' || !CURRENCY.test(value.requestedCurrencyCode))) ||
+        !isFinancialScopeBaselineEnvelopeV2(value.ownerBaseline) ||
+        (value.displayMemberBaselines !== undefined &&
+            (!Array.isArray(value.displayMemberBaselines) ||
+                value.displayMemberBaselines.length > 20000 ||
+                !value.displayMemberBaselines.every(isFinancialScopeBaselineEnvelopeV2))) ||
+        (value.chargeComposition !== undefined && !isFinancialChargeCompositionV1(value.chargeComposition)) ||
+        (value.displayMemberChargeCompositions !== undefined &&
+            (!Array.isArray(value.displayMemberChargeCompositions) ||
+                value.displayMemberChargeCompositions.length > 20000 ||
+                !value.displayMemberChargeCompositions.every(isFinancialChargeCompositionV1))) ||
+        !Array.isArray(value.componentDescriptors) ||
+        value.componentDescriptors.length > 20000 ||
+        !value.componentDescriptors.every(isFinancialAuthorityComponentDescriptorV1) ||
+        !Array.isArray(value.displayRollups) ||
+        value.displayRollups.length > 20000 ||
+        !value.displayRollups.every(isFinancialDisplayRollupV1) ||
+        !Array.isArray(value.projections) ||
+        value.projections.length > 20000 ||
+        !value.projections.every(isFinancialProjectionEnvelopeV1))
+        return false;
+    const coordinate = value;
+    const baseline = coordinate.ownerBaseline;
+    const displayMemberBaselines = coordinate.displayMemberBaselines ?? [];
+    const displayMemberChargeCompositions = coordinate.displayMemberChargeCompositions ?? [];
+    const assessment = assessmentById.get(baseline.assessmentId);
+    if (normalizeScopeId(baseline.scopeId) !== projection.scopeId ||
+        baseline.costBasis !== coordinate.costBasis ||
+        baseline.estimateLens !== coordinate.estimateLens ||
+        periodText(baseline.period) !== periodText(coordinate.period) ||
+        baseline.requestedCurrencyCode !== coordinate.requestedCurrencyCode ||
+        !isSameProviderAccountSet(baseline.providerAccountRefs, projection.providerAccountRefs) ||
+        !assessment ||
+        assessment.request.scopeId !== baseline.scopeId ||
+        assessment.request.scopeKind !== baseline.scopeKind ||
+        assessment.result !== baseline.status)
+        return false;
+    if (projection.financialRole === 'display-only' && (baseline.status !== 'unavailable' || baseline.unavailableReason !== 'unsupported-scope')) {
+        return false;
+    }
+    if (projection.financialRole === 'unclassified' && (baseline.status !== 'unavailable' || baseline.unavailableReason !== 'ownership-unresolved')) {
+        return false;
+    }
+    if (baseline.status !== 'available' || baseline.baselineKind !== 'owner') {
+        return (displayMemberBaselines.length === 0 &&
+            coordinate.chargeComposition === undefined &&
+            displayMemberChargeCompositions.length === 0 &&
+            coordinate.componentDescriptors.length === 0 &&
+            coordinate.displayRollups.length === 0 &&
+            coordinate.projections.every(projectionValue => normalizeScopeId(projectionValue.scopeId) === projection.scopeId) &&
+            new Set(coordinate.projections.map(projectionValue => projectionValue.scenarioId)).size === coordinate.projections.length);
+    }
+    if (baseline.scopeKind !== 'canonical-resource-owner' && baseline.scopeKind !== 'composite-resource')
+        return false;
+    if (!bundleIds.has(baseline.evidenceBundleId) || assessment.evidenceBundleId !== baseline.evidenceBundleId)
+        return false;
+    const availableDisplayMemberBaselines = displayMemberBaselines.filter((candidate) => candidate.status === 'available' && candidate.baselineKind === 'owner');
+    if (availableDisplayMemberBaselines.length !== displayMemberBaselines.length)
+        return false;
+    const projectedBaselines = [baseline, ...availableDisplayMemberBaselines];
+    if (new Set(projectedBaselines.map(candidate => candidate.baselineId)).size !== projectedBaselines.length ||
+        displayMemberBaselines.some(candidate => {
+            if (candidate.status !== 'available' ||
+                candidate.baselineKind !== 'owner' ||
+                (candidate.scopeKind !== 'canonical-resource-owner' && candidate.scopeKind !== 'composite-resource') ||
+                candidate.costBasis !== coordinate.costBasis ||
+                candidate.estimateLens !== coordinate.estimateLens ||
+                periodText(candidate.period) !== periodText(coordinate.period) ||
+                candidate.requestedCurrencyCode !== coordinate.requestedCurrencyCode ||
+                candidate.total.currencyCode !== baseline.total.currencyCode ||
+                !isSameProviderAccountSet(candidate.providerAccountRefs, projection.providerAccountRefs) ||
+                !bundleIds.has(candidate.evidenceBundleId))
+                return true;
+            const candidateAssessment = assessmentById.get(candidate.assessmentId);
+            return (!candidateAssessment ||
+                candidateAssessment.request.scopeId !== candidate.scopeId ||
+                candidateAssessment.request.scopeKind !== candidate.scopeKind ||
+                candidateAssessment.result !== candidate.status ||
+                candidateAssessment.evidenceBundleId !== candidate.evidenceBundleId);
+        }))
+        return false;
+    const compositions = [coordinate.chargeComposition, ...displayMemberChargeCompositions];
+    if (compositions.some(candidate => candidate === undefined))
+        return false;
+    const compositionByBaselineId = new Map(compositions.map(candidate => [candidate.baselineId, candidate]));
+    if (compositions.length !== projectedBaselines.length || compositionByBaselineId.size !== projectedBaselines.length)
+        return false;
+    for (const projectedBaseline of projectedBaselines) {
+        const composition = compositionByBaselineId.get(projectedBaseline.baselineId);
+        if (!composition ||
+            composition.baselineId !== projectedBaseline.baselineId ||
+            normalizeScopeId(composition.ownerScopeId) !== normalizeScopeId(projectedBaseline.scopeId) ||
+            periodText(composition.period) !== periodText(projectedBaseline.period) ||
+            composition.costBasis !== projectedBaseline.costBasis ||
+            composition.estimateLens !== projectedBaseline.estimateLens ||
+            composition.accountingCurrencyCode !== projectedBaseline.total.currencyCode ||
+            composition.reconciliation.sourceTotal !== projectedBaseline.total.amount)
+            return false;
+    }
+    const composition = coordinate.chargeComposition;
+    if (!composition ||
+        composition.baselineId !== baseline.baselineId ||
+        normalizeScopeId(composition.ownerScopeId) !== projection.scopeId ||
+        periodText(composition.period) !== periodText(baseline.period) ||
+        composition.costBasis !== baseline.costBasis ||
+        composition.estimateLens !== baseline.estimateLens ||
+        composition.accountingCurrencyCode !== baseline.total.currencyCode ||
+        composition.reconciliation.sourceTotal !== baseline.total.amount)
+        return false;
+    const componentKeys = new Set(projectedBaselines.flatMap(projectedBaseline => projectedBaseline.components.map(component => `${projectedBaseline.baselineId}\u0000${component.componentId}`)));
+    const ownerComponentKeys = new Set(baseline.components.map(component => `${baseline.baselineId}\u0000${component.componentId}`));
+    const descriptorKeys = coordinate.componentDescriptors.map(descriptor => `${descriptor.baselineId}\u0000${descriptor.componentId}`);
+    if (descriptorKeys.length !== componentKeys.size ||
+        new Set(descriptorKeys).size !== descriptorKeys.length ||
+        descriptorKeys.some(key => !componentKeys.has(key)) ||
+        coordinate.displayRollups.some(rollup => normalizeScopeId(rollup.displayScopeId) !== projection.scopeId ||
+            rollup.members.some(member => !componentKeys.has(`${member.baselineId}\u0000${member.componentId}`))) ||
+        coordinate.projections.some(projectionValue => normalizeScopeId(projectionValue.scopeId) !== projection.scopeId))
+        return false;
+    const rolledUpKeys = coordinate.displayRollups.flatMap(rollup => rollup.members.map(member => `${member.baselineId}\u0000${member.componentId}`));
+    return (ownerComponentKeys.size > 0 &&
+        new Set(rolledUpKeys).size === rolledUpKeys.length &&
+        rolledUpKeys.every(key => componentKeys.has(key)) &&
+        [...ownerComponentKeys].every(key => rolledUpKeys.includes(key)) &&
+        [...componentKeys].every(key => rolledUpKeys.includes(key)) &&
+        new Set(coordinate.projections.map(projectionValue => projectionValue.scenarioId)).size === coordinate.projections.length);
+};
+/** Strictly validates one bounded, non-additive resource projection without requiring the full authority ledger. */
+export const isFinancialAuthorityResourceProjectionV1 = (value) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, [
+            'contractVersion',
+            'authorityId',
+            'provider',
+            'providerAccountRefs',
+            'artifactGeneration',
+            'billingGenerationId',
+            'resourceType',
+            'financialRole',
+            'scopeId',
+            'evidenceBundles',
+            'evidenceAssessments',
+            'coordinates',
+        ]) ||
+        value.contractVersion !== 'financial-authority-resource-projection/v1' ||
+        !isHash(value.authorityId) ||
+        value.provider !== 'azure' ||
+        !Array.isArray(value.providerAccountRefs) ||
+        value.providerAccountRefs.length === 0 ||
+        value.providerAccountRefs.length > 64 ||
+        !value.providerAccountRefs.every(isIdentity) ||
+        new Set(value.providerAccountRefs).size !== value.providerAccountRefs.length ||
+        !isRecord(value.artifactGeneration) ||
+        !hasExactFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
+        !isIdentity(value.artifactGeneration.runId) ||
+        !isIsoInstant(value.artifactGeneration.generatedAt) ||
+        !isIdentity(value.billingGenerationId) ||
+        typeof value.resourceType !== 'string' ||
+        !AZURE_RESOURCE_TYPE.test(value.resourceType) ||
+        value.resourceType !== normalizeScopeId(value.resourceType) ||
+        (value.financialRole !== 'owner' && value.financialRole !== 'display-only' && value.financialRole !== 'unclassified') ||
+        !isIdentity(value.scopeId) ||
+        value.scopeId !== normalizeScopeId(value.scopeId) ||
+        !Array.isArray(value.evidenceBundles) ||
+        value.evidenceBundles.length > 20000 ||
+        !value.evidenceBundles.every(isFinancialEvidenceBundleV1) ||
+        !Array.isArray(value.evidenceAssessments) ||
+        value.evidenceAssessments.length > 20000 ||
+        !value.evidenceAssessments.every(isFinancialEvidenceAssessmentV1) ||
+        !Array.isArray(value.coordinates) ||
+        value.coordinates.length === 0 ||
+        value.coordinates.length > 128)
+        return false;
+    const projection = value;
+    const bundleIds = new Set(projection.evidenceBundles.map(bundle => bundle.bundleId));
+    const assessmentById = new Map(projection.evidenceAssessments.map(assessment => [assessment.assessmentId, assessment]));
+    const projectedScopeIds = new Set([
+        projection.scopeId,
+        ...projection.coordinates.flatMap(coordinate => (coordinate.displayMemberBaselines ?? []).map(baseline => normalizeScopeId(baseline.scopeId))),
+    ]);
+    if (bundleIds.size !== projection.evidenceBundles.length || assessmentById.size !== projection.evidenceAssessments.length)
+        return false;
+    if (projection.evidenceAssessments.some(assessment => (assessment.evidenceBundleId !== undefined && !bundleIds.has(assessment.evidenceBundleId)) ||
+        !isSameProviderAccountSet(assessment.request.providerAccountRefs, projection.providerAccountRefs) ||
+        !projectedScopeIds.has(normalizeScopeId(assessment.request.scopeId))) ||
+        !projection.coordinates.every(coordinate => isResourceProjectionCoordinate(coordinate, projection, assessmentById, bundleIds)) ||
+        new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size !== projection.coordinates.length)
+        return false;
+    return true;
+};

package/dist/esm/azure/financialChargeComposition.js

@@ -0,0 +1,36 @@
+import { sha256Utf8 } from '../common/sha256.js';
+export const FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1 = 1;
+export const FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1 = 'financial-charge-composition/v1';
+export const FINANCIAL_CHARGE_INCLUSION_POLICY_CONTRACT_VERSION_V1 = 'financial-charge-inclusion-policy/v1';
+const createRegisteredPolicy = (definition) => {
+    const { policyId, ...policy } = definition;
+    const registered = {
+        ...policy,
+        includeSources: Object.freeze([...policy.includeSources]),
+        excludeSources: Object.freeze([...policy.excludeSources]),
+        withholdSources: Object.freeze([...policy.withholdSources]),
+        policyRef: Object.freeze({ policyId, policyDigest: `sha256:${sha256Utf8(JSON.stringify(definition))}` }),
+    };
+    return Object.freeze(registered);
+};
+export const AZURE_BILLED_ALL_CHARGES_POLICY_V1 = createRegisteredPolicy({
+    schemaVersion: 1,
+    contractVersion: FINANCIAL_CHARGE_INCLUSION_POLICY_CONTRACT_VERSION_V1,
+    policyId: 'azure-billed-all-charges/v1',
+    includeSources: ['azure-native', 'marketplace', 'unknown'],
+    excludeSources: [],
+    withholdSources: [],
+});
+export const AZURE_CLOUD_SERVICES_EXCLUDING_MARKETPLACE_POLICY_V1 = createRegisteredPolicy({
+    schemaVersion: 1,
+    contractVersion: FINANCIAL_CHARGE_INCLUSION_POLICY_CONTRACT_VERSION_V1,
+    policyId: 'azure-cloud-services-excluding-marketplace/v1',
+    includeSources: ['azure-native'],
+    excludeSources: ['marketplace'],
+    withholdSources: ['unknown'],
+});
+export const FINANCIAL_CHARGE_INCLUSION_POLICIES_V1 = Object.freeze([
+    AZURE_BILLED_ALL_CHARGES_POLICY_V1,
+    AZURE_CLOUD_SERVICES_EXCLUDING_MARKETPLACE_POLICY_V1,
+]);
+export const resolveFinancialChargeInclusionPolicyV1 = (policyRef) => policyRef !== null && typeof policyRef === 'object' && FINANCIAL_CHARGE_INCLUSION_POLICIES_V1.find(policy => policy.policyRef.policyId === policyRef.policyId && policy.policyRef.policyDigest === policyRef.policyDigest) || undefined;