@spottoai/types-package 1.0.2-dev1138.13 → 1.0.2-dev1138.14

package/dist/esm/azure/financialAnalyticsValidation.js

@@ -6,6 +6,7 @@ import { FINANCIAL_DATAFLOW_LIMITS_V1, canonicalizeFinancialDataflowJsonV1, hasF
 import { isCurrentSpendCompositionV1 } from './financialDataflowValidation.js';
 const MAX_POINTS = 3660;
 const MAX_GAPS = 3660;
+const MAX_REFERENCE_COMPOSITIONS = 2;
 const isReasonCodes = (value) => Array.isArray(value) &&
     value.length > 0 &&
     value.length <= FINANCIAL_DATAFLOW_LIMITS_V1.maximumReasonCodes &&
@@ -29,6 +30,7 @@ const comparableCoordinate = (value) => ({
     estimateLens: value.estimateLens,
     requestedCurrencyCode: value.requestedCurrencyCode,
     accountingCurrency: value.accountingCurrency,
+    chargeInclusionPolicyRef: value.chargeInclusionPolicyRef,
 });
 const hasSameFinancialDimensions = (left, right) => canonicalizeFinancialDataflowJsonV1(comparableCoordinate(left)) === canonicalizeFinancialDataflowJsonV1(comparableCoordinate(right));
 const hasComparableTrendPeriods = (current, comparison) => {
@@ -42,6 +44,10 @@ const hasComparableTrendPeriods = (current, comparison) => {
     return (intervalDayCount(current.period.requested.startDate, current.period.requested.endDateExclusive) ===
         intervalDayCount(comparison.period.requested.startDate, comparison.period.requested.endDateExclusive));
 };
+const periodContains = (container, target) => container.period.requested.dateBasis === target.period.requested.dateBasis &&
+    container.period.requested.timeZone === target.period.requested.timeZone &&
+    container.period.requested.startDate <= target.period.requested.startDate &&
+    container.period.requested.endDateExclusive >= target.period.requested.endDateExclusive;
 const isInputIdentity = (value) => {
     if (!isFinancialDataflowRecordV1(value) ||
         !hasFinancialDataflowExactFieldsV1(value, [
@@ -50,6 +56,7 @@ const isInputIdentity = (value) => {
             'coordinate',
             'granularity',
             'producerGenerationId',
+            'referenceCompositions',
             'points',
             'gaps',
             'coverage',
@@ -59,9 +66,12 @@ const isInputIdentity = (value) => {
         value.contractVersion !== FINANCIAL_ANALYTICS_INPUT_CONTRACT_VERSION_V1 ||
         !isFinancialDataflowCoordinateV1(value.coordinate) ||
         value.coordinate.periodRole !== 'analytics-input' ||
+        value.coordinate.period.windowKind !== 'analytics-history' ||
         value.coordinate.accountingCurrency.status !== 'resolved' ||
         value.granularity !== 'daily' ||
         !isFinancialDataflowIdentityV1(value.producerGenerationId) ||
+        !Array.isArray(value.referenceCompositions) ||
+        value.referenceCompositions.length > MAX_REFERENCE_COMPOSITIONS ||
         !Array.isArray(value.points) ||
         value.points.length > MAX_POINTS ||
         !Array.isArray(value.gaps) ||
@@ -71,6 +81,16 @@ const isInputIdentity = (value) => {
         !isFinancialDataflowIdentityV1(value.algorithmVersion)) {
         return false;
     }
+    const coordinate = value.coordinate;
+    const referenceCompositions = value.referenceCompositions;
+    if (!referenceCompositions.every(isCurrentSpendCompositionV1))
+        return false;
+    const referenceRoles = referenceCompositions.map(composition => composition.coordinate.periodRole);
+    if (new Set(referenceCompositions.map(composition => composition.compositionId)).size !== referenceCompositions.length ||
+        new Set(referenceRoles).size !== referenceRoles.length ||
+        referenceCompositions.some(composition => !hasSameFinancialDimensions(coordinate, composition.coordinate))) {
+        return false;
+    }
     const gaps = value.gaps;
     const requested = value.coordinate.period.requested;
     const dates = new Set();
@@ -86,16 +106,47 @@ const isInputIdentity = (value) => {
             return false;
         }
         dates.add(point.date);
+        const pointForecastFields = [
+            point.forecastEligibleAmount,
+            point.oneTimeAmount,
+            point.unknownRecurrenceAmount,
+        ];
+        if (!pointForecastFields.every(amount => isCanonicalExactMoney({ amount, currencyCode: coordinate.accountingCurrency.currencyCode })) ||
+            (point.forecastStatus !== 'available' && point.forecastStatus !== 'partial') ||
+            (point.forecastStatus === 'available'
+                ? point.forecastReasonCodes !== undefined || point.unknownRecurrenceAmount !== '0'
+                : !isReasonCodes(point.forecastReasonCodes))) {
+            return false;
+        }
         if (point.status === 'available') {
-            if (!hasFinancialDataflowExactFieldsV1(point, ['date', 'compositionId', 'status', 'amount']) ||
-                !isCanonicalExactMoney({ amount: point.amount, currencyCode: 'AUD' }))
+            if (!hasFinancialDataflowExactFieldsV1(point, [
+                'date',
+                'compositionId',
+                'status',
+                'amount',
+                'forecastEligibleAmount',
+                'oneTimeAmount',
+                'unknownRecurrenceAmount',
+                'forecastStatus',
+            ], ['forecastReasonCodes']) ||
+                !isCanonicalExactMoney({ amount: point.amount, currencyCode: coordinate.accountingCurrency.currencyCode }))
                 return false;
             availableDayCount += 1;
         }
         else {
             if (point.status !== 'partial' ||
-                !hasFinancialDataflowExactFieldsV1(point, ['date', 'compositionId', 'status', 'knownAmount', 'reasonCodes']) ||
-                !isCanonicalExactMoney({ amount: point.knownAmount, currencyCode: 'AUD' }) ||
+                !hasFinancialDataflowExactFieldsV1(point, [
+                    'date',
+                    'compositionId',
+                    'status',
+                    'knownAmount',
+                    'reasonCodes',
+                    'forecastEligibleAmount',
+                    'oneTimeAmount',
+                    'unknownRecurrenceAmount',
+                    'forecastStatus',
+                ], ['forecastReasonCodes']) ||
+                !isCanonicalExactMoney({ amount: point.knownAmount, currencyCode: coordinate.accountingCurrency.currencyCode }) ||
                 !isReasonCodes(point.reasonCodes))
                 return false;
             partialDayCount += 1;
@@ -143,9 +194,7 @@ const isInputIdentity = (value) => {
         value.coverage.partialDayCount === partialDayCount &&
         value.coverage.unavailableDayCount === unavailableDayCount &&
         availableDayCount + partialDayCount + unavailableDayCount === expectedDays &&
-        cursor === requested.endDateExclusive &&
-        value.coordinate.period.gaps.length === gaps.length &&
-        value.coordinate.period.gaps.every(periodGap => gaps.some(gap => gap.startDate === periodGap.startDate && gap.endDateExclusive === periodGap.endDateExclusive)));
+        cursor === requested.endDateExclusive);
 };
 export const canonicalizeFinancialAnalyticsInputIdentityV1 = (value) => {
     if (!isFinancialDataflowValueWithinLimitsV1(value) || !isInputIdentity(value)) {
@@ -154,9 +203,16 @@ export const canonicalizeFinancialAnalyticsInputIdentityV1 = (value) => {
     return canonicalizeFinancialDataflowJsonV1({
         ...value,
         coordinate: { ...value.coordinate, providerAccountRefs: [...value.coordinate.providerAccountRefs].sort() },
+        referenceCompositions: [...value.referenceCompositions].sort((left, right) => left.compositionId.localeCompare(right.compositionId)),
         points: [...value.points]
             .sort((left, right) => left.date.localeCompare(right.date))
-            .map(point => (point.status === 'partial' ? { ...point, reasonCodes: [...point.reasonCodes].sort() } : point)),
+            .map(point => ({
+            ...point,
+            ...(point.status === 'partial' ? { reasonCodes: [...point.reasonCodes].sort() } : {}),
+            ...(point.forecastReasonCodes === undefined
+                ? {}
+                : { forecastReasonCodes: [...point.forecastReasonCodes].sort() }),
+        })),
         gaps: [...value.gaps]
             .sort((left, right) => `${left.startDate}\u0000${left.endDateExclusive}`.localeCompare(`${right.startDate}\u0000${right.endDateExclusive}`))
             .map(gap => ({ ...gap, reasonCodes: [...gap.reasonCodes].sort() })),
@@ -173,6 +229,18 @@ export const isFinancialAnalyticsInputSeriesV1 = (value) => {
 };
 const nextCalendarDate = (value) => new Date(Date.parse(`${value}T00:00:00.000Z`) + 86400000).toISOString().slice(0, 10);
 const hasSameReasonCodes = (left, right) => left.length === right.length && left.every(reasonCode => right.includes(reasonCode));
+const hasSameForecastSlice = (point, composition) => {
+    const selection = composition.chargeSelection;
+    return selection !== undefined &&
+        point.forecastEligibleAmount === selection.forecastEligibleAmount &&
+        point.oneTimeAmount === selection.oneTimeAmount &&
+        point.unknownRecurrenceAmount === selection.unknownRecurrenceAmount &&
+        point.forecastStatus === selection.forecastStatus &&
+        (point.forecastReasonCodes === undefined
+            ? selection.forecastReasonCodes === undefined
+            : selection.forecastReasonCodes !== undefined &&
+                hasSameReasonCodes(point.forecastReasonCodes, selection.forecastReasonCodes));
+};
 /** Proves that every analytics point is an exact projection of its referenced daily composition. */
 export const isFinancialAnalyticsInputSeriesCompatibleV1 = (input, dailyCompositions) => {
     if (!isFinancialAnalyticsInputSeriesV1(input) ||
@@ -188,6 +256,7 @@ export const isFinancialAnalyticsInputSeriesCompatibleV1 = (input, dailyComposit
     return input.points.every(point => {
         const composition = compositionById.get(point.compositionId);
         if (composition === undefined ||
+            composition.amount.status === 'unavailable' ||
             composition.coordinate.periodRole !== 'current-spend' ||
             composition.coordinate.period.windowKind !== 'daily' ||
             composition.coordinate.period.requested.startDate !== point.date ||
@@ -196,11 +265,14 @@ export const isFinancialAnalyticsInputSeriesCompatibleV1 = (input, dailyComposit
             return false;
         }
         if (point.status === 'available') {
-            return composition.amount.status === 'available' && point.amount === composition.amount.amount;
+            return (composition.amount.status === 'available' &&
+                point.amount === composition.amount.amount &&
+                hasSameForecastSlice(point, composition));
         }
         return (composition.amount.status === 'partial' &&
             point.knownAmount === composition.amount.knownAmount &&
-            hasSameReasonCodes(point.reasonCodes, composition.amount.reasonCodes));
+            hasSameReasonCodes(point.reasonCodes, composition.amount.reasonCodes) &&
+            hasSameForecastSlice(point, composition));
     });
 };
 const isResult = (value, currency) => {
@@ -234,7 +306,6 @@ const isResult = (value, currency) => {
     return (value.kind === 'anomaly' &&
         hasFinancialDataflowExactFieldsV1(value, ['kind', 'events']) &&
         Array.isArray(value.events) &&
-        value.events.length > 0 &&
         value.events.length <= MAX_POINTS &&
         value.events.every(event => {
             if (!isFinancialDataflowRecordV1(event) ||
@@ -283,9 +354,9 @@ const isProjectionIdentity = (value) => {
         return false;
     const currency = coordinateCurrency(value.coordinate);
     return (isFinancialDataflowHashV1(value.analyticsInputId) &&
+        isFinancialDataflowHashV1(value.currentSpendCompositionId) &&
         currency !== undefined &&
-        isResult(value.result, currency) &&
-        (value.result.kind === 'anomaly' || isFinancialDataflowHashV1(value.currentSpendCompositionId)));
+        isResult(value.result, currency));
 };
 export const canonicalizeFinancialAnalyticsProjectionIdentityV1 = (value) => {
     if (!isFinancialDataflowValueWithinLimitsV1(value) || !isProjectionIdentity(value)) {
@@ -334,17 +405,24 @@ export const isFinancialAnalyticsProjectionCompatibleV1 = (projection, input, cu
                 hasSameFinancialDimensions(projection.coordinate, currentSpendComposition.coordinate)));
     }
     if (projection.result.kind === 'anomaly') {
-        if (projection.currentSpendCompositionId !== undefined &&
-            (!isCurrentSpendCompositionV1(currentSpendComposition) ||
-                projection.currentSpendCompositionId !== currentSpendComposition.compositionId ||
-                !hasSameFinancialDimensions(projection.coordinate, currentSpendComposition.coordinate))) {
+        if (!isCurrentSpendCompositionV1(currentSpendComposition) ||
+            projection.currentSpendCompositionId !== currentSpendComposition.compositionId ||
+            !hasSameFinancialDimensions(projection.coordinate, currentSpendComposition.coordinate) ||
+            canonicalizeFinancialDataflowCoordinateV1({ ...projection.coordinate, periodRole: 'current-spend' }) !==
+                canonicalizeFinancialDataflowCoordinateV1(currentSpendComposition.coordinate) ||
+            !periodContains(input.coordinate, projection.coordinate)) {
             return false;
         }
         const pointsByDate = new Map(input.points.map(point => [point.date, point]));
         const eventDates = new Set();
+        const targetPeriod = projection.coordinate.period.requested;
         return projection.result.events.every(event => {
             const point = pointsByDate.get(event.date);
-            if (point === undefined || eventDates.has(event.date) || (projection.status === 'available' && point.status !== 'available'))
+            if (event.date < targetPeriod.startDate ||
+                event.date >= targetPeriod.endDateExclusive ||
+                point === undefined ||
+                eventDates.has(event.date) ||
+                (projection.status === 'available' && point.status !== 'available'))
                 return false;
             eventDates.add(event.date);
             const observedAmount = point.status === 'available' ? point.amount : point.knownAmount;
@@ -394,7 +472,11 @@ export const isFinancialAnalyticsProjectionCompatibleV1 = (projection, input, cu
             canonicalizeFinancialDataflowCoordinateV1(currentSpendComposition.coordinate)) {
         return false;
     }
-    if (projection.status === 'available' && currentSpendComposition.amount.status !== 'available')
+    if (projection.status === 'available' &&
+        currentSpendComposition.amount.status !== 'available' &&
+        !(currentSpendComposition.amount.status === 'partial' &&
+            currentSpendComposition.amount.reasonCodes.length === 1 &&
+            currentSpendComposition.amount.reasonCodes[0] === 'coverage-incomplete'))
         return false;
     if (currentSpendComposition.amount.status === 'unavailable')
         return false;

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)],
+    };
+};