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

package/dist/esm/azure/financialAnalyticsDisplayKernel.js

@@ -0,0 +1,139 @@
+import { formatExactDecimalValue, parseCanonicalDecimal, sumCanonicalDecimals } from '../common/exactDecimal.js';
+import { isFinancialAnalyticsInputSeriesV1 } from './financialAnalyticsValidation.js';
+const DAY_MS = 86400000;
+const HISTORY_NOT_PRODUCED = 'history-not-produced';
+const CALENDAR_PERIOD_INCOMPLETE = 'calendar-period-incomplete';
+const addUtcDays = (date, days) => new Date(Date.parse(`${date}T00:00:00.000Z`) + days * DAY_MS).toISOString().slice(0, 10);
+const shiftUtcMonths = (date, months) => {
+    const parsed = new Date(`${date}T00:00:00.000Z`);
+    return new Date(Date.UTC(parsed.getUTCFullYear(), parsed.getUTCMonth() + months, 1)).toISOString().slice(0, 10);
+};
+const uniqueReasons = (values) => {
+    const reasons = [...new Set(values)].sort();
+    return (reasons.length > 0 ? reasons : [HISTORY_NOT_PRODUCED]);
+};
+/** Twelve-decimal half-away-from-zero display average; totals remain exact. */
+const averageKnownPerDay = (amount, dayCount) => {
+    if (!Number.isSafeInteger(dayCount) || dayCount < 1)
+        throw new RangeError('Display average requires a positive day count.');
+    const value = parseCanonicalDecimal(amount);
+    const precision = 12;
+    const numerator = (value.coefficient < 0n ? -value.coefficient : value.coefficient) * 10n ** BigInt(precision);
+    const scaledDivisor = BigInt(dayCount) * 10n ** BigInt(value.scale);
+    let quotient = numerator / scaledDivisor;
+    const remainder = numerator % scaledDivisor;
+    if (remainder * 2n >= scaledDivisor)
+        quotient += 1n;
+    return formatExactDecimalValue({ coefficient: value.coefficient < 0n ? -quotient : quotient, scale: precision });
+};
+const requestedInterval = (input, periodKey) => {
+    const endDateExclusive = input.coordinate.period.requested.endDateExclusive;
+    const startDate = periodKey === 'last-7-days'
+        ? addUtcDays(endDateExclusive, -7)
+        : periodKey === 'rolling-30-days'
+            ? addUtcDays(endDateExclusive, -30)
+            : periodKey === 'rolling-90-days'
+                ? addUtcDays(endDateExclusive, -90)
+                : shiftUtcMonths(addUtcDays(endDateExclusive, -1), -11);
+    return {
+        startDate,
+        endDateExclusive,
+        dateBasis: input.coordinate.period.requested.dateBasis,
+        ...(input.coordinate.period.requested.timeZone === undefined
+            ? {}
+            : { timeZone: input.coordinate.period.requested.timeZone }),
+    };
+};
+const displayDays = (input, startDate, endDateExclusive) => {
+    const pointByDate = new Map(input.points.map(point => [point.date, point]));
+    const gapReasons = (date) => input.gaps
+        .filter(gap => gap.startDate <= date && gap.endDateExclusive > date)
+        .flatMap(gap => gap.reasonCodes);
+    const days = [];
+    for (let date = startDate; date < endDateExclusive; date = addUtcDays(date, 1)) {
+        const point = pointByDate.get(date);
+        if (point?.status === 'available') {
+            days.push({ date, status: 'available', knownAmount: point.amount, reasonCodes: [] });
+        }
+        else if (point?.status === 'partial') {
+            days.push({ date, status: 'partial', knownAmount: point.knownAmount, reasonCodes: point.reasonCodes });
+        }
+        else {
+            const reasons = gapReasons(date);
+            days.push({ date, status: 'unavailable', reasonCodes: reasons.length > 0 ? reasons : [HISTORY_NOT_PRODUCED] });
+        }
+    }
+    return days;
+};
+const toBucket = (bucketKey, startDate, endDateExclusive, days) => {
+    const knownAmounts = days.flatMap(day => (day.knownAmount === undefined ? [] : [day.knownAmount]));
+    const coversWholeBucket = days[0]?.date === startDate && days.length > 0 && addUtcDays(days[days.length - 1].date, 1) === endDateExclusive;
+    const reasonCodes = uniqueReasons([
+        ...days.flatMap(day => day.reasonCodes),
+        ...(coversWholeBucket ? [] : [CALENDAR_PERIOD_INCOMPLETE]),
+    ]);
+    if (knownAmounts.length === 0) {
+        return { bucketKey, startDate, endDateExclusive, status: 'unavailable', reasonCodes };
+    }
+    const knownAmount = formatExactDecimalValue(sumCanonicalDecimals(knownAmounts));
+    const average = averageKnownPerDay(knownAmount, knownAmounts.length);
+    if (coversWholeBucket && days.every(day => day.status === 'available')) {
+        return { bucketKey, startDate, endDateExclusive, status: 'available', amount: knownAmount, averageKnownPerDay: average };
+    }
+    return { bucketKey, startDate, endDateExclusive, status: 'partial', knownAmount, averageKnownPerDay: average, reasonCodes };
+};
+const dailyBuckets = (days) => days.map(day => toBucket(day.date, day.date, addUtcDays(day.date, 1), [day]));
+const monthlyBuckets = (days) => {
+    const byMonth = new Map();
+    days.forEach(day => {
+        const month = day.date.slice(0, 7);
+        byMonth.set(month, [...(byMonth.get(month) ?? []), day]);
+    });
+    return [...byMonth.entries()].map(([month, monthDays]) => toBucket(month, `${month}-01`, shiftUtcMonths(`${month}-01`, 1), monthDays));
+};
+/**
+ * Exact, non-authoritative display rollup over one producer-owned analytics
+ * input. The function never changes charge inclusion, estimates, cost basis,
+ * currency, or source evidence; uncovered dates remain explicit.
+ */
+export const projectFinancialAnalyticsDisplayPeriodV1 = (request) => {
+    if (!isFinancialAnalyticsInputSeriesV1(request.input)) {
+        throw new TypeError('Financial analytics display projection requires a valid input series.');
+    }
+    const current = request.input.referenceCompositions.find(composition => composition.coordinate.periodRole === 'current-spend' && composition.compositionId === request.currentSpendCompositionId);
+    if (!current) {
+        throw new TypeError('Financial analytics input does not bind the requested current-spend composition.');
+    }
+    const accountingCurrency = request.input.coordinate.accountingCurrency;
+    if (accountingCurrency.status !== 'resolved') {
+        throw new TypeError('Financial analytics display projection requires a resolved accounting currency.');
+    }
+    const requested = requestedInterval(request.input, request.periodKey);
+    const days = displayDays(request.input, requested.startDate, requested.endDateExclusive);
+    const buckets = request.periodKey === 'trailing-12-calendar-months' ? monthlyBuckets(days) : dailyBuckets(days);
+    const common = {
+        analyticsInputId: request.input.analyticsInputId,
+        currentSpendCompositionId: current.compositionId,
+        chargeInclusionPolicyRef: current.coordinate.chargeInclusionPolicyRef,
+        periodKey: request.periodKey,
+        requested,
+        bucketGranularity: request.periodKey === 'trailing-12-calendar-months' ? 'calendar-month' : 'daily',
+        currencyCode: accountingCurrency.currencyCode,
+        buckets,
+    };
+    const knownAmounts = days.flatMap(day => (day.knownAmount === undefined ? [] : [day.knownAmount]));
+    const calendarPeriodIncomplete = request.periodKey === 'trailing-12-calendar-months' &&
+        requested.endDateExclusive !== shiftUtcMonths(addUtcDays(requested.endDateExclusive, -1), 1);
+    const reasonCodes = uniqueReasons([
+        ...days.flatMap(day => day.reasonCodes),
+        ...(calendarPeriodIncomplete ? [CALENDAR_PERIOD_INCOMPLETE] : []),
+    ]);
+    if (knownAmounts.length === 0)
+        return { ...common, status: 'unavailable', reasonCodes };
+    const knownAmount = formatExactDecimalValue(sumCanonicalDecimals(knownAmounts));
+    const average = averageKnownPerDay(knownAmount, knownAmounts.length);
+    if (!calendarPeriodIncomplete && days.every(day => day.status === 'available')) {
+        return { ...common, status: 'available', amount: knownAmount, averageKnownPerDay: average };
+    }
+    return { ...common, status: 'partial', knownAmount, averageKnownPerDay: average, reasonCodes };
+};

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