@spottoai/types-package 1.0.2-dev1138.2 → 1.0.2-dev1138.3

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')

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;

package/dist/esm/azure/financialChargeCompositionKernel.js

@@ -0,0 +1,44 @@
+import { formatExactDecimalValue, sumCanonicalDecimals } from '../common/exactDecimal.js';
+import { FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1, FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1, } from './financialChargeComposition.js';
+import { createFinancialChargeCompositionIdV1 } from './financialChargeCompositionValidation.js';
+const bucketKey = (component) => `${component.chargeSource}\u0000${component.chargeRecurrence}\u0000${component.chargeClassification}`;
+export const createFinancialChargeCompositionV1 = (request) => {
+    if (!Array.isArray(request.components) || request.components.length === 0 || request.components.length > 20000) {
+        throw new TypeError('Financial charge composition requires a bounded non-empty component collection.');
+    }
+    if (new Set(request.components.map(component => component.componentId)).size !== request.components.length) {
+        throw new TypeError('Financial charge composition cannot classify one component more than once.');
+    }
+    const groups = new Map();
+    for (const component of request.components) {
+        const key = bucketKey(component);
+        groups.set(key, [...(groups.get(key) ?? []), component]);
+    }
+    const buckets = [...groups.values()]
+        .map(group => ({
+        chargeSource: group[0].chargeSource,
+        chargeRecurrence: group[0].chargeRecurrence,
+        chargeClassification: group[0].chargeClassification,
+        amount: formatExactDecimalValue(sumCanonicalDecimals(group.map(component => component.amount))),
+        componentIds: [...new Set(group.map(component => component.componentId))].sort(),
+        evidenceRefIds: [...new Set(group.flatMap(component => component.evidenceRefIds))].sort(),
+    }))
+        .sort((left, right) => `${left.chargeSource}\u0000${left.chargeRecurrence}\u0000${left.chargeClassification}`.localeCompare(`${right.chargeSource}\u0000${right.chargeRecurrence}\u0000${right.chargeClassification}`));
+    const bucketTotal = formatExactDecimalValue(sumCanonicalDecimals(buckets.map(bucket => bucket.amount)));
+    if (bucketTotal !== request.sourceTotal)
+        throw new TypeError('Financial charge composition does not reconcile to its source total.');
+    const identity = {
+        schemaVersion: FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1,
+        contractVersion: FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1,
+        baselineId: request.baselineId,
+        ownerScopeId: request.ownerScopeId,
+        period: request.period,
+        costBasis: request.costBasis,
+        estimateLens: request.estimateLens,
+        accountingCurrencyCode: request.accountingCurrencyCode,
+        buckets,
+        reconciliation: { status: 'reconciled', bucketTotal, sourceTotal: request.sourceTotal, difference: '0' },
+        algorithmVersion: request.algorithmVersion,
+    };
+    return { ...identity, chargeCompositionId: createFinancialChargeCompositionIdV1(identity) };
+};

package/dist/esm/azure/financialChargeCompositionValidation.js

@@ -0,0 +1,155 @@
+import { formatExactDecimalValue, sumCanonicalDecimals } from '../common/exactDecimal.js';
+import { sha256Utf8 } from '../common/sha256.js';
+import { FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1, FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1, resolveFinancialChargeInclusionPolicyV1, } from './financialChargeComposition.js';
+import { canonicalizeFinancialDataflowJsonV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowCurrencyV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowRecordV1, isFinancialDataflowValueWithinLimitsV1, } from './financialDataflowValidation.js';
+import { isFinancialBaselinePeriodV2 } from './financialScopeBaselineValidation.js';
+import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+const SOURCES = new Set(['azure-native', 'marketplace', 'unknown']);
+const RECURRENCES = new Set(['one-time', 'recurring', 'usage-based', 'unknown']);
+const CLASSIFICATIONS = new Set(['usage', 'purchase', 'adjustment', 'tax', 'credit', 'refund', 'residual']);
+const COST_BASES = new Set(['billed', 'amortized']);
+const ESTIMATE_LENSES = new Set(['actual-only', 'actual-plus-estimated', 'estimates-only']);
+const isSortedUniqueHashes = (value) => Array.isArray(value) && value.length > 0 && value.length <= 20000 && value.every(isFinancialDataflowHashV1) &&
+    value.every((entry, index) => index === 0 || value[index - 1] < entry);
+const isBucket = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'chargeSource',
+        'chargeRecurrence',
+        'chargeClassification',
+        'amount',
+        'componentIds',
+        'evidenceRefIds',
+    ]) &&
+    SOURCES.has(value.chargeSource) &&
+    RECURRENCES.has(value.chargeRecurrence) &&
+    CLASSIFICATIONS.has(value.chargeClassification) &&
+    isCanonicalExactMoney({ amount: value.amount, currencyCode: 'AUD' }) &&
+    isSortedUniqueHashes(value.componentIds) &&
+    isSortedUniqueHashes(value.evidenceRefIds);
+const isIdentity = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'baselineId',
+            'ownerScopeId',
+            'period',
+            'costBasis',
+            'estimateLens',
+            'accountingCurrencyCode',
+            'buckets',
+            'reconciliation',
+            'algorithmVersion',
+        ]) ||
+        value.schemaVersion !== FINANCIAL_CHARGE_COMPOSITION_SCHEMA_VERSION_V1 ||
+        value.contractVersion !== FINANCIAL_CHARGE_COMPOSITION_CONTRACT_VERSION_V1 ||
+        !isFinancialDataflowHashV1(value.baselineId) ||
+        !isFinancialDataflowIdentityV1(value.ownerScopeId) ||
+        !isFinancialBaselinePeriodV2(value.period) ||
+        !COST_BASES.has(value.costBasis) ||
+        !ESTIMATE_LENSES.has(value.estimateLens) ||
+        !isFinancialDataflowCurrencyV1(value.accountingCurrencyCode) ||
+        !Array.isArray(value.buckets) ||
+        value.buckets.length === 0 ||
+        value.buckets.length > 20000 ||
+        !value.buckets.every(isBucket) ||
+        !isFinancialDataflowIdentityV1(value.algorithmVersion) ||
+        !isFinancialDataflowRecordV1(value.reconciliation) ||
+        !hasFinancialDataflowExactFieldsV1(value.reconciliation, ['status', 'bucketTotal', 'sourceTotal', 'difference']) ||
+        value.reconciliation.status !== 'reconciled' ||
+        value.reconciliation.difference !== '0' ||
+        !isCanonicalExactMoney({ amount: value.reconciliation.bucketTotal, currencyCode: value.accountingCurrencyCode }) ||
+        !isCanonicalExactMoney({ amount: value.reconciliation.sourceTotal, currencyCode: value.accountingCurrencyCode }))
+        return false;
+    const componentIds = value.buckets.flatMap(bucket => bucket.componentIds);
+    if (new Set(componentIds).size !== componentIds.length)
+        return false;
+    const keys = value.buckets.map(bucket => `${bucket.chargeSource}\u0000${bucket.chargeRecurrence}\u0000${bucket.chargeClassification}`);
+    if (!keys.every((key, index) => index === 0 || keys[index - 1] < key))
+        return false;
+    try {
+        const bucketTotal = formatExactDecimalValue(sumCanonicalDecimals(value.buckets.map(bucket => bucket.amount)));
+        return bucketTotal === value.reconciliation.bucketTotal && bucketTotal === value.reconciliation.sourceTotal;
+    }
+    catch {
+        return false;
+    }
+};
+export const canonicalizeFinancialChargeCompositionIdentityV1 = (value) => {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) || !isIdentity(value)) {
+        throw new TypeError('Invalid FinancialChargeCompositionIdentityPreimageV1.');
+    }
+    return canonicalizeFinancialDataflowJsonV1(value);
+};
+export const createFinancialChargeCompositionIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialChargeCompositionIdentityV1(value))}`;
+export const isFinancialChargeCompositionV1 = (value) => {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) ||
+        !isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'chargeCompositionId',
+            'schemaVersion',
+            'contractVersion',
+            'baselineId',
+            'ownerScopeId',
+            'period',
+            'costBasis',
+            'estimateLens',
+            'accountingCurrencyCode',
+            'buckets',
+            'reconciliation',
+            'algorithmVersion',
+        ]))
+        return false;
+    const { chargeCompositionId, ...identity } = value;
+    return isFinancialDataflowHashV1(chargeCompositionId) && isIdentity(identity) &&
+        chargeCompositionId === createFinancialChargeCompositionIdV1(identity);
+};
+export const isFinancialChargeInclusionPolicyRefV1 = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, ['policyId', 'policyDigest']) &&
+    isFinancialDataflowIdentityV1(value.policyId) &&
+    isFinancialDataflowHashV1(value.policyDigest) &&
+    resolveFinancialChargeInclusionPolicyV1(value) !== undefined;
+const sumBuckets = (buckets) => formatExactDecimalValue(sumCanonicalDecimals(buckets.map(bucket => bucket.amount)));
+const sourcesFor = (policy, role) => role === 'include' ? policy.includeSources : role === 'exclude' ? policy.excludeSources : policy.withholdSources;
+export const selectFinancialChargesV1 = (composition, policyRef) => {
+    if (!isFinancialChargeCompositionV1(composition))
+        throw new TypeError('Invalid financial charge composition.');
+    const policy = resolveFinancialChargeInclusionPolicyV1(policyRef);
+    if (!policy)
+        throw new TypeError('Unregistered financial charge-inclusion policy.');
+    const partition = (role) => composition.buckets.filter(bucket => sourcesFor(policy, role).includes(bucket.chargeSource));
+    const included = partition('include');
+    const excluded = partition('exclude');
+    const withheld = partition('withhold');
+    if (included.length + excluded.length + withheld.length !== composition.buckets.length) {
+        throw new TypeError('Financial charge-inclusion policy does not partition every charge source.');
+    }
+    const includedAmount = sumBuckets(included);
+    const excludedAmount = sumBuckets(excluded);
+    const withheldAmount = sumBuckets(withheld);
+    const forecastEligibleAmount = sumBuckets(included.filter(bucket => bucket.chargeRecurrence === 'recurring' || bucket.chargeRecurrence === 'usage-based'));
+    const oneTimeAmount = sumBuckets(included.filter(bucket => bucket.chargeRecurrence === 'one-time'));
+    const unknownRecurrenceAmount = sumBuckets(included.filter(bucket => bucket.chargeRecurrence === 'unknown'));
+    const reasonCodes = [];
+    if (withheldAmount !== '0')
+        reasonCodes.push('charge-source-unknown');
+    const forecastReasonCodes = [...reasonCodes];
+    if (unknownRecurrenceAmount !== '0')
+        forecastReasonCodes.push('charge-recurrence-unknown');
+    const result = {
+        status: withheldAmount === '0' ? 'available' : 'partial',
+        includedAmount,
+        excludedAmount,
+        withheldAmount,
+        forecastEligibleAmount,
+        oneTimeAmount,
+        unknownRecurrenceAmount,
+        forecastStatus: withheldAmount === '0' && unknownRecurrenceAmount === '0' ? 'available' : 'partial',
+        currencyCode: composition.accountingCurrencyCode,
+        ...(reasonCodes.length === 0 ? {} : { reasonCodes: reasonCodes }),
+        ...(forecastReasonCodes.length === 0
+            ? {}
+            : { forecastReasonCodes: forecastReasonCodes }),
+    };
+    return result;
+};

package/dist/esm/azure/financialDataflowKernel.js

@@ -1,5 +1,6 @@
 import { formatExactDecimalValue, parseCanonicalDecimal, subtractExactDecimalValues, sumCanonicalDecimals, } from '../common/exactDecimal.js';
 import { FINANCIAL_CURRENT_SPEND_COMPOSITION_CONTRACT_VERSION_V1, FINANCIAL_DATAFLOW_SCHEMA_VERSION_V1, } from './financialDataflow.js';
+import { selectFinancialChargesV1 } from './financialChargeCompositionValidation.js';
 import { createCurrentSpendCompositionIdV1, createCurrentSpendMembershipDigestV1, isCurrentSpendCompositionCompatibleV1, } from './financialDataflowValidation.js';
 import { isCompleteFinancialBaselinePeriodV2 } from './financialScopeBaseline.js';
 export const CURRENT_SPEND_COMPOSITION_ALGORITHM_VERSION_V1 = 'current-spend-composition/shared-v1';
@@ -58,17 +59,49 @@ export const composeCurrentSpendV1 = (request) => {
     }
     if (request.baselines.length === 0)
         throw new TypeError('Current-spend composition requires an authoritative baseline member.');
+    if (request.chargeCompositions.length > request.baselines.length) {
+        throw new TypeError('Current-spend composition has more charge compositions than baseline members.');
+    }
+    const chargeCompositionByBaselineId = new Map(request.chargeCompositions.map(composition => [composition.baselineId, composition]));
+    if (chargeCompositionByBaselineId.size !== request.chargeCompositions.length) {
+        throw new TypeError('Current-spend composition cannot contain duplicate charge compositions.');
+    }
     const sortedBaselines = [...request.baselines].sort((left, right) => left.scopeId.localeCompare(right.scopeId));
     if (new Set(sortedBaselines.map(baseline => baseline.scopeId)).size !== sortedBaselines.length) {
         throw new TypeError('Current-spend composition cannot contain duplicate member scopes.');
     }
-    const members = sortedBaselines.map(baseline => baseline.status === 'available'
-        ? { memberScopeId: baseline.scopeId, baselineId: baseline.baselineId, status: 'included' }
-        : { memberScopeId: baseline.scopeId, status: 'unavailable', reasonCode: baseline.unavailableReason });
+    const selections = new Map();
+    const members = sortedBaselines.map(baseline => {
+        if (baseline.status === 'unavailable') {
+            return { memberScopeId: baseline.scopeId, status: 'unavailable', reasonCode: baseline.unavailableReason };
+        }
+        if (baseline.baselineKind !== 'owner') {
+            return { memberScopeId: baseline.scopeId, status: 'unavailable', reasonCode: 'charge-composition-requires-owner-baseline' };
+        }
+        const chargeComposition = chargeCompositionByBaselineId.get(baseline.baselineId);
+        if (!chargeComposition || chargeComposition.ownerScopeId !== baseline.scopeId) {
+            return { memberScopeId: baseline.scopeId, status: 'unavailable', reasonCode: 'charge-composition-unavailable' };
+        }
+        const selection = selectFinancialChargesV1(chargeComposition, request.coordinate.chargeInclusionPolicyRef);
+        selections.set(baseline.baselineId, selection);
+        return {
+            memberScopeId: baseline.scopeId,
+            baselineId: baseline.baselineId,
+            chargeCompositionId: chargeComposition.chargeCompositionId,
+            status: 'included',
+        };
+    });
     const available = sortedBaselines.filter((baseline) => baseline.status === 'available');
+    const includedBaselines = available.filter(baseline => members.some(member => member.status === 'included' && member.baselineId === baseline.baselineId));
     const unavailableReasons = new Set(sortedBaselines
         .filter((baseline) => baseline.status === 'unavailable')
         .map(baseline => baseline.unavailableReason));
+    members.filter(member => member.status === 'unavailable').forEach(member => unavailableReasons.add(member.reasonCode));
+    const selectionReasonCodes = new Set();
+    selections.forEach(selection => selection.reasonCodes?.forEach(reason => {
+        selectionReasonCodes.add(reason);
+        unavailableReasons.add(reason);
+    }));
     if (available.some(baseline => !isCompleteFinancialBaselinePeriodV2(baseline.period)))
         unavailableReasons.add('coverage-incomplete');
     if (request.coordinate.accountingCurrency.status === 'unresolved') {
@@ -84,7 +117,7 @@ export const composeCurrentSpendV1 = (request) => {
     };
     const currency = request.coordinate.accountingCurrency.status === 'resolved' ? request.coordinate.accountingCurrency.currencyCode : undefined;
     let identity;
-    if (!currency || available.length === 0) {
+    if (!currency || includedBaselines.length === 0) {
         identity = {
             ...common,
             amount: {
@@ -94,17 +127,36 @@ export const composeCurrentSpendV1 = (request) => {
         };
     }
     else {
-        const knownAmount = formatExactDecimalValue(sumCanonicalDecimals(available.map(baseline => baseline.total.amount)));
+        const includedSelections = members.flatMap(member => member.status === 'included' ? [selections.get(member.baselineId)] : []);
+        const aggregateSelection = {
+            status: includedSelections.some(selection => selection.status === 'partial') ? 'partial' : 'available',
+            includedAmount: formatExactDecimalValue(sumCanonicalDecimals(includedSelections.map(selection => selection.includedAmount))),
+            excludedAmount: formatExactDecimalValue(sumCanonicalDecimals(includedSelections.map(selection => selection.excludedAmount))),
+            withheldAmount: formatExactDecimalValue(sumCanonicalDecimals(includedSelections.map(selection => selection.withheldAmount))),
+            forecastEligibleAmount: formatExactDecimalValue(sumCanonicalDecimals(includedSelections.map(selection => selection.forecastEligibleAmount))),
+            oneTimeAmount: formatExactDecimalValue(sumCanonicalDecimals(includedSelections.map(selection => selection.oneTimeAmount))),
+            unknownRecurrenceAmount: formatExactDecimalValue(sumCanonicalDecimals(includedSelections.map(selection => selection.unknownRecurrenceAmount))),
+            forecastStatus: includedSelections.some(selection => selection.forecastStatus === 'partial') ? 'partial' : 'available',
+            currencyCode: currency,
+            ...(selectionReasonCodes.size === 0 ? {} : { reasonCodes: uniqueSorted(selectionReasonCodes) }),
+            ...(includedSelections.every(selection => selection.forecastReasonCodes === undefined)
+                ? {}
+                : {
+                    forecastReasonCodes: uniqueSorted(includedSelections.flatMap(selection => selection.forecastReasonCodes ?? [])),
+                }),
+        };
+        const knownAmount = aggregateSelection.includedAmount;
         identity =
             unavailableReasons.size === 0
-                ? { ...common, amount: { status: 'available', amount: knownAmount, currencyCode: currency } }
+                ? { ...common, amount: { status: 'available', amount: knownAmount, currencyCode: currency }, chargeSelection: aggregateSelection }
                 : {
                     ...common,
                     amount: { status: 'partial', knownAmount, currencyCode: currency, reasonCodes: uniqueSorted(unavailableReasons) },
+                    chargeSelection: aggregateSelection,
                 };
     }
     const composition = { ...identity, compositionId: createCurrentSpendCompositionIdV1(identity) };
-    if (!isCurrentSpendCompositionCompatibleV1(composition, sortedBaselines)) {
+    if (!isCurrentSpendCompositionCompatibleV1(composition, sortedBaselines, request.chargeCompositions)) {
         throw new TypeError('Current-spend composition does not reconcile to its authoritative baseline members.');
     }
     return composition;