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

package/dist/esm/azure/financialAuthorityViewValidation.js

@@ -295,7 +295,7 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
             (projection.targetEvidenceBundleId !== undefined && !bundleIds.has(projection.targetEvidenceBundleId)) ||
             (targetAssessment !== undefined &&
                 (targetAssessment.request.scopeId !== projection.scopeId ||
-                    targetAssessment.result !== 'available' ||
+                    (projection.status === 'available' && targetAssessment.result !== 'available') ||
                     targetAssessment.evidenceBundleId !== projection.targetEvidenceBundleId)) ||
             (projection.baselineId !== undefined && (owner.status !== 'available' || projection.baselineId !== owner.baselineId)) ||
             (projection.status === 'available' && owner.status !== 'available'))
@@ -367,6 +367,15 @@ const isCoordinate = (value, coveredScopeIds, financialRoleByScope, providerAcco
                             return false;
                         continue;
                     }
+                    if (projection.operationKind === 'replace-quantity-and-rate') {
+                        if (!('targetQuantity' in applied) || !('targetRate' in applied))
+                            return false;
+                        if (applied.targetQuantity.unit !== applied.targetRate.quantityUnit ||
+                            applied.targetRate.currencyCode !== projection.accountingCurrencyCode ||
+                            formatExactDecimalValue(multiplyExactDecimalValues(parseCanonicalDecimal(applied.targetQuantity.amount), parseCanonicalDecimal(applied.targetRate.amount))) !== applied.targetAmount)
+                            return false;
+                        continue;
+                    }
                     if (!('sourceRate' in applied) || !('targetQuantity' in applied) || component.effectiveRate === undefined)
                         return false;
                     if (applied.sourceRate.amount !== component.effectiveRate.amount ||
@@ -534,3 +543,158 @@ export const isFinancialAuthorityViewV1 = (value) => {
 export const isFinancialAuthorityViewBoundToArtifactGenerationV1 = (value, expected) => isFinancialAuthorityViewV1(value) &&
     value.artifactGeneration.runId === expected.runId &&
     value.artifactGeneration.generatedAt === expected.generatedAt;
+const isSameProviderAccountSet = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    const sortedLeft = [...left].sort();
+    const sortedRight = [...right].sort();
+    return sortedLeft.every((value, index) => value === sortedRight[index]);
+};
+const isResourceProjectionCoordinate = (value, projection, assessmentById, bundleIds) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, [
+            'coordinateId',
+            'periodRole',
+            'period',
+            'costBasis',
+            'estimateLens',
+            'ownerBaseline',
+            'componentDescriptors',
+            'displayRollups',
+            'projections',
+        ], ['requestedCurrencyCode', 'chargeComposition']) ||
+        !isHash(value.coordinateId) ||
+        (value.periodRole !== 'current' && value.periodRole !== 'previous') ||
+        !isFinancialBaselinePeriodV2(value.period) ||
+        typeof value.costBasis !== 'string' ||
+        !COST_BASES.has(value.costBasis) ||
+        typeof value.estimateLens !== 'string' ||
+        !ESTIMATE_LENSES.has(value.estimateLens) ||
+        (value.requestedCurrencyCode !== undefined && (typeof value.requestedCurrencyCode !== 'string' || !CURRENCY.test(value.requestedCurrencyCode))) ||
+        !isFinancialScopeBaselineEnvelopeV2(value.ownerBaseline) ||
+        (value.chargeComposition !== undefined && !isFinancialChargeCompositionV1(value.chargeComposition)) ||
+        !Array.isArray(value.componentDescriptors) ||
+        value.componentDescriptors.length > 20000 ||
+        !value.componentDescriptors.every(isFinancialAuthorityComponentDescriptorV1) ||
+        !Array.isArray(value.displayRollups) ||
+        value.displayRollups.length > 20000 ||
+        !value.displayRollups.every(isFinancialDisplayRollupV1) ||
+        !Array.isArray(value.projections) ||
+        value.projections.length > 20000 ||
+        !value.projections.every(isFinancialProjectionEnvelopeV1))
+        return false;
+    const coordinate = value;
+    const baseline = coordinate.ownerBaseline;
+    const assessment = assessmentById.get(baseline.assessmentId);
+    if (normalizeScopeId(baseline.scopeId) !== projection.scopeId ||
+        baseline.costBasis !== coordinate.costBasis ||
+        baseline.estimateLens !== coordinate.estimateLens ||
+        periodText(baseline.period) !== periodText(coordinate.period) ||
+        baseline.requestedCurrencyCode !== coordinate.requestedCurrencyCode ||
+        !isSameProviderAccountSet(baseline.providerAccountRefs, projection.providerAccountRefs) ||
+        !assessment ||
+        assessment.request.scopeId !== baseline.scopeId ||
+        assessment.request.scopeKind !== baseline.scopeKind ||
+        assessment.result !== baseline.status)
+        return false;
+    if (projection.financialRole === 'display-only' && (baseline.status !== 'unavailable' || baseline.unavailableReason !== 'unsupported-scope')) {
+        return false;
+    }
+    if (projection.financialRole === 'unclassified' && (baseline.status !== 'unavailable' || baseline.unavailableReason !== 'ownership-unresolved')) {
+        return false;
+    }
+    if (baseline.status !== 'available' || baseline.baselineKind !== 'owner') {
+        return (coordinate.chargeComposition === undefined &&
+            coordinate.componentDescriptors.length === 0 &&
+            coordinate.displayRollups.length === 0 &&
+            coordinate.projections.every(projectionValue => normalizeScopeId(projectionValue.scopeId) === projection.scopeId) &&
+            new Set(coordinate.projections.map(projectionValue => projectionValue.scenarioId)).size === coordinate.projections.length);
+    }
+    if (baseline.scopeKind !== 'canonical-resource-owner' && baseline.scopeKind !== 'composite-resource')
+        return false;
+    if (!bundleIds.has(baseline.evidenceBundleId) || assessment.evidenceBundleId !== baseline.evidenceBundleId)
+        return false;
+    const composition = coordinate.chargeComposition;
+    if (!composition ||
+        composition.baselineId !== baseline.baselineId ||
+        normalizeScopeId(composition.ownerScopeId) !== projection.scopeId ||
+        periodText(composition.period) !== periodText(baseline.period) ||
+        composition.costBasis !== baseline.costBasis ||
+        composition.estimateLens !== baseline.estimateLens ||
+        composition.accountingCurrencyCode !== baseline.total.currencyCode ||
+        composition.reconciliation.sourceTotal !== baseline.total.amount)
+        return false;
+    const componentKeys = new Set(baseline.components.map(component => `${baseline.baselineId}\u0000${component.componentId}`));
+    const descriptorKeys = coordinate.componentDescriptors.map(descriptor => `${descriptor.baselineId}\u0000${descriptor.componentId}`);
+    if (descriptorKeys.length !== componentKeys.size ||
+        new Set(descriptorKeys).size !== descriptorKeys.length ||
+        descriptorKeys.some(key => !componentKeys.has(key)) ||
+        coordinate.displayRollups.some(rollup => normalizeScopeId(rollup.displayScopeId) !== projection.scopeId ||
+            rollup.members.some(member => !componentKeys.has(`${member.baselineId}\u0000${member.componentId}`))) ||
+        coordinate.projections.some(projectionValue => normalizeScopeId(projectionValue.scopeId) !== projection.scopeId))
+        return false;
+    const rolledUpKeys = coordinate.displayRollups.flatMap(rollup => rollup.members.map(member => `${member.baselineId}\u0000${member.componentId}`));
+    return (rolledUpKeys.length === componentKeys.size &&
+        new Set(rolledUpKeys).size === rolledUpKeys.length &&
+        rolledUpKeys.every(key => componentKeys.has(key)) &&
+        new Set(coordinate.projections.map(projectionValue => projectionValue.scenarioId)).size === coordinate.projections.length);
+};
+/** Strictly validates one bounded, non-additive resource projection without requiring the full authority ledger. */
+export const isFinancialAuthorityResourceProjectionV1 = (value) => {
+    if (!isRecord(value) ||
+        !hasExactFields(value, [
+            'contractVersion',
+            'authorityId',
+            'provider',
+            'providerAccountRefs',
+            'artifactGeneration',
+            'billingGenerationId',
+            'resourceType',
+            'financialRole',
+            'scopeId',
+            'evidenceBundles',
+            'evidenceAssessments',
+            'coordinates',
+        ]) ||
+        value.contractVersion !== 'financial-authority-resource-projection/v1' ||
+        !isHash(value.authorityId) ||
+        value.provider !== 'azure' ||
+        !Array.isArray(value.providerAccountRefs) ||
+        value.providerAccountRefs.length === 0 ||
+        value.providerAccountRefs.length > 64 ||
+        !value.providerAccountRefs.every(isIdentity) ||
+        new Set(value.providerAccountRefs).size !== value.providerAccountRefs.length ||
+        !isRecord(value.artifactGeneration) ||
+        !hasExactFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
+        !isIdentity(value.artifactGeneration.runId) ||
+        !isIsoInstant(value.artifactGeneration.generatedAt) ||
+        !isIdentity(value.billingGenerationId) ||
+        typeof value.resourceType !== 'string' ||
+        !AZURE_RESOURCE_TYPE.test(value.resourceType) ||
+        value.resourceType !== normalizeScopeId(value.resourceType) ||
+        (value.financialRole !== 'owner' && value.financialRole !== 'display-only' && value.financialRole !== 'unclassified') ||
+        !isIdentity(value.scopeId) ||
+        value.scopeId !== normalizeScopeId(value.scopeId) ||
+        !Array.isArray(value.evidenceBundles) ||
+        value.evidenceBundles.length > 20000 ||
+        !value.evidenceBundles.every(isFinancialEvidenceBundleV1) ||
+        !Array.isArray(value.evidenceAssessments) ||
+        value.evidenceAssessments.length > 20000 ||
+        !value.evidenceAssessments.every(isFinancialEvidenceAssessmentV1) ||
+        !Array.isArray(value.coordinates) ||
+        value.coordinates.length === 0 ||
+        value.coordinates.length > 128)
+        return false;
+    const projection = value;
+    const bundleIds = new Set(projection.evidenceBundles.map(bundle => bundle.bundleId));
+    const assessmentById = new Map(projection.evidenceAssessments.map(assessment => [assessment.assessmentId, assessment]));
+    if (bundleIds.size !== projection.evidenceBundles.length || assessmentById.size !== projection.evidenceAssessments.length)
+        return false;
+    if (projection.evidenceAssessments.some(assessment => (assessment.evidenceBundleId !== undefined && !bundleIds.has(assessment.evidenceBundleId)) ||
+        !isSameProviderAccountSet(assessment.request.providerAccountRefs, projection.providerAccountRefs) ||
+        normalizeScopeId(assessment.request.scopeId) !== projection.scopeId) ||
+        !projection.coordinates.every(coordinate => isResourceProjectionCoordinate(coordinate, projection, assessmentById, bundleIds)) ||
+        new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size !== projection.coordinates.length)
+        return false;
+    return true;
+};

package/dist/esm/azure/financialChargeCompositionKernel.js

@@ -12,7 +12,11 @@ export const createFinancialChargeCompositionV1 = (request) => {
     const groups = new Map();
     for (const component of request.components) {
         const key = bucketKey(component);
-        groups.set(key, [...(groups.get(key) ?? []), component]);
+        const group = groups.get(key);
+        if (group)
+            group.push(component);
+        else
+            groups.set(key, [component]);
     }
     const buckets = [...groups.values()]
         .map(group => ({

package/dist/esm/azure/financialDataflowKernel.js

@@ -92,7 +92,8 @@ export const composeCurrentSpendV1 = (request) => {
         };
     });
     const available = sortedBaselines.filter((baseline) => baseline.status === 'available');
-    const includedBaselines = available.filter(baseline => members.some(member => member.status === 'included' && member.baselineId === baseline.baselineId));
+    const includedBaselineIds = new Set(members.flatMap(member => (member.status === 'included' ? [member.baselineId] : [])));
+    const includedBaselines = available.filter(baseline => includedBaselineIds.has(baseline.baselineId));
     const unavailableReasons = new Set(sortedBaselines
         .filter((baseline) => baseline.status === 'unavailable')
         .map(baseline => baseline.unavailableReason));

package/dist/esm/azure/financialProjectionValidation.js

@@ -4,7 +4,15 @@ import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
 import { FINANCIAL_PROJECTION_CONTRACT_VERSION_V1, FINANCIAL_PROJECTION_SCHEMA_VERSION_V1, FINANCIAL_PROJECTION_UNAVAILABLE_REASONS_V1, } from './financialProjection.js';
 const SHA256_ID = /^sha256:[0-9a-f]{64}$/;
 const CURRENCY = /^[A-Z]{3}$/;
-const OPERATIONS = new Set(['replace-rate', 'replace-quantity', 'remove-component', 'schedule-quantity', 'commitment-coverage']);
+const OPERATIONS = new Set([
+    'unclassified',
+    'replace-rate',
+    'replace-quantity',
+    'replace-quantity-and-rate',
+    'remove-component',
+    'schedule-quantity',
+    'commitment-coverage',
+]);
 const COST_BASES = new Set(['billed', 'amortized']);
 const ESTIMATE_LENSES = new Set(['actual-only', 'actual-plus-estimated', 'estimates-only']);
 const TARGET_PROVENANCE = new Set(['retail-derived', 'provider-quote-derived', 'billing-backed', 'estimated', 'configuration-derived']);
@@ -32,6 +40,16 @@ const isNonNegativeDecimal = (value, currency = 'AUD') => {
     }
 };
 const isUnit = (value) => isIdentity(value) && value.length <= 512;
+const isReplayedProduct = (quantity, rate, targetAmount, currency) => {
+    if (!isNonNegativeDecimal(quantity) || !isNonNegativeDecimal(rate, currency) || !isDecimal(targetAmount, currency))
+        return false;
+    try {
+        return equalsDecimal(multiplyExactDecimalValues(parseCanonicalDecimal(quantity), parseCanonicalDecimal(rate)), parseCanonicalDecimal(targetAmount));
+    }
+    catch {
+        return false;
+    }
+};
 const isCanonicalDate = (value) => typeof value === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(`${value}T00:00:00.000Z`));
 const isNormalizedAverageMonthProfile = (value) => isRecord(value) &&
     hasExactFields(value, ['kind', 'annualDayCount', 'monthDivisor', 'hoursPerDay', 'normalizedHours']) &&
@@ -203,7 +221,8 @@ const isAppliedComponentTargets = (value, operationKind, targetProvenance, targe
                 !isNonNegativeDecimal(target.targetRate.amount) ||
                 target.targetRate.currencyCode !== accountingCurrencyCode ||
                 !isUnit(target.targetRate.quantityUnit) ||
-                target.targetRate.quantityUnit !== target.sourceQuantity.unit)
+                target.targetRate.quantityUnit !== target.sourceQuantity.unit ||
+                !isReplayedProduct(target.sourceQuantity.amount, target.targetRate.amount, target.targetAmount, accountingCurrencyCode))
                 return false;
             continue;
         }
@@ -218,7 +237,24 @@ const isAppliedComponentTargets = (value, operationKind, targetProvenance, targe
                 !hasExactFields(target.targetQuantity, ['amount', 'unit']) ||
                 !isNonNegativeDecimal(target.targetQuantity.amount) ||
                 !isUnit(target.targetQuantity.unit) ||
-                target.targetQuantity.unit !== target.sourceRate.unit)
+                target.targetQuantity.unit !== target.sourceRate.unit ||
+                !isReplayedProduct(target.targetQuantity.amount, target.sourceRate.amount, target.targetAmount, accountingCurrencyCode))
+                return false;
+            continue;
+        }
+        if (operationKind === 'replace-quantity-and-rate') {
+            if (!hasExactFields(target, ['componentId', 'targetAmount', 'targetConfigurationId', 'targetEvidenceRefIds', 'targetQuantity', 'targetRate']) ||
+                !isRecord(target.targetQuantity) ||
+                !hasExactFields(target.targetQuantity, ['amount', 'unit']) ||
+                !isNonNegativeDecimal(target.targetQuantity.amount) ||
+                !isUnit(target.targetQuantity.unit) ||
+                !isRecord(target.targetRate) ||
+                !hasExactFields(target.targetRate, ['amount', 'currencyCode', 'quantityUnit']) ||
+                !isNonNegativeDecimal(target.targetRate.amount, accountingCurrencyCode) ||
+                target.targetRate.currencyCode !== accountingCurrencyCode ||
+                !isUnit(target.targetRate.quantityUnit) ||
+                target.targetRate.quantityUnit !== target.targetQuantity.unit ||
+                !isReplayedProduct(target.targetQuantity.amount, target.targetRate.amount, target.targetAmount, accountingCurrencyCode))
                 return false;
             continue;
         }
@@ -428,6 +464,10 @@ const isUnavailable = (value) => {
         !TARGET_PERIOD_CONVENTIONS.has(value.targetPeriodConvention) ||
         !isTargetPeriodProfileCompatible(value.targetPeriodConvention, value.targetPeriodProfile, false) ||
         (isObservedPeriodProfile(value.targetPeriodProfile) && value.operationKind !== 'commitment-coverage') ||
+        (value.operationKind === 'unclassified' &&
+            (value.unavailableReason !== 'target-evidence-unavailable' ||
+                !Array.isArray(value.affectedComponentIds) ||
+                value.affectedComponentIds.length !== 0)) ||
         (value.targetProvenance === 'configuration-derived' && value.operationKind !== 'remove-component') ||
         (value.operationKind === 'commitment-coverage' && value.targetProvenance !== 'provider-quote-derived') ||
         !isPossiblyEmptyHashArray(value.affectedComponentIds) ||

package/dist/esm/azure/financialSavingsAuthorityValidation.js

@@ -2,7 +2,7 @@ import { sha256Utf8 } from '../common/sha256.js';
 import { FINANCIAL_SAVINGS_AUTHORITY_CONTRACT_VERSION_V1, FINANCIAL_SAVINGS_AUTHORITY_SCHEMA_VERSION_V1, } from './financialSavingsAuthority.js';
 import { validateFinancialEligibilityAssessmentV1, validateFinancialEligibilityBaselineV1, } from './financialEligibilityAssessmentValidation.js';
 import { validateFinancialSavingsCoordinateEnvelopeV1 } from './financialSavingsCoordinateValidation.js';
-import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, isFinancialSavingsHash, isFinancialSavingsRecord, } from './financialSavingsAuthorityValidationPrimitives.js';
+import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, haveSameFinancialSavingsSet, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsMinorUnits, isFinancialSavingsRecord, sumFinancialSavingsMinorUnits, } from './financialSavingsAuthorityValidationPrimitives.js';
 export { canonicalizeFinancialEligibilityAssessmentIdentityV1, createFinancialEligibilityAssessmentIdV1, } from './financialEligibilityAssessmentValidation.js';
 export { canonicalizeFinancialSavingsActivationIdentityV1, canonicalizeFinancialSavingsAllocationIdentityV1, canonicalizeFinancialSavingsDenominatorIdentityV1, createFinancialSavingsActivationIdV1, createFinancialSavingsAllocationIdV1, createFinancialSavingsDenominatorIdV1, } from './financialSavingsCoordinateValidation.js';
 export const canonicalizeFinancialSavingsAuthorityIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
@@ -28,7 +28,7 @@ export const canonicalizeFinancialSavingsAuthorityIdentityV1 = (value) => JSON.s
                 .map(allocation => ({
                 ...allocation,
                 billableComponentIds: [...allocation.billableComponentIds].sort(),
-                eligibility: allocation.eligibility.kind === 'not-applicable'
+                eligibility: allocation.eligibility.kind !== 'mapped'
                     ? allocation.eligibility
                     : {
                         ...allocation.eligibility,
@@ -115,3 +115,125 @@ export const isFinancialSavingsAuthorityBoundToFinancialAuthorityV1 = (value, au
     const { savingsAuthorityId: _savingsAuthorityId, ...identity } = savingsAuthority;
     return savingsAuthority.savingsAuthorityId === createFinancialSavingsAuthorityIdV1(identity);
 };
+const RESOURCE_PROJECTION_UNAVAILABLE_REASONS = new Set([
+    'scenario-coverage-unproven',
+    'unmigrated-scenario-producer',
+    'projection-unavailable',
+    'activation-unavailable',
+    'allocation-unavailable',
+]);
+const RESOURCE_PROJECTION_CURRENCY = /^[A-Z]{3}$/;
+const normalizeResourceScope = (value) => value.trim().toLowerCase().replace(/\/+$/, '');
+const isResourceContribution = (value, scopeId) => isFinancialSavingsRecord(value) &&
+    hasExactFinancialSavingsFields(value, ['ownerScopeId', 'allocationIds', 'savingsMinorUnits']) &&
+    isFinancialSavingsIdentity(value.ownerScopeId) &&
+    normalizeResourceScope(value.ownerScopeId) === scopeId &&
+    Array.isArray(value.allocationIds) &&
+    value.allocationIds.length > 0 &&
+    value.allocationIds.length <= 20000 &&
+    value.allocationIds.every(isFinancialSavingsHash) &&
+    new Set(value.allocationIds).size === value.allocationIds.length &&
+    isFinancialSavingsMinorUnits(value.savingsMinorUnits);
+const isRecommendationContribution = (value, scopeId) => isFinancialSavingsRecord(value) &&
+    hasExactFinancialSavingsFields(value, ['ownerScopeId', 'recommendationId', 'allocationIds', 'savingsMinorUnits']) &&
+    isFinancialSavingsIdentity(value.ownerScopeId) &&
+    normalizeResourceScope(value.ownerScopeId) === scopeId &&
+    isFinancialSavingsIdentity(value.recommendationId) &&
+    Array.isArray(value.allocationIds) &&
+    value.allocationIds.length > 0 &&
+    value.allocationIds.length <= 20000 &&
+    value.allocationIds.every(isFinancialSavingsHash) &&
+    new Set(value.allocationIds).size === value.allocationIds.length &&
+    isFinancialSavingsMinorUnits(value.savingsMinorUnits);
+const isSavingsResourceCoordinate = (value, scopeId) => {
+    if (!isFinancialSavingsRecord(value) || !isFinancialSavingsHash(value.coordinateId))
+        return false;
+    if (value.status === 'unavailable') {
+        return (hasExactFinancialSavingsFields(value, ['status', 'coordinateId', 'unavailableReason'], ['currentAggregateBaselineId']) &&
+            (value.currentAggregateBaselineId === undefined || isFinancialSavingsHash(value.currentAggregateBaselineId)) &&
+            typeof value.unavailableReason === 'string' &&
+            RESOURCE_PROJECTION_UNAVAILABLE_REASONS.has(value.unavailableReason));
+    }
+    const partial = value.status === 'partial';
+    if (value.status !== 'available' &&
+        !partial)
+        return false;
+    if (!hasExactFinancialSavingsFields(value, [
+        'status',
+        'coordinateId',
+        'currentAggregateBaselineId',
+        'accountingCurrencyCode',
+        'minorUnitScale',
+        'roundingMode',
+        'recommendationContributions',
+        ...(partial ? ['unavailableScenarioIds'] : []),
+    ], ['resourceContribution']) ||
+        !isFinancialSavingsHash(value.currentAggregateBaselineId) ||
+        typeof value.accountingCurrencyCode !== 'string' ||
+        !RESOURCE_PROJECTION_CURRENCY.test(value.accountingCurrencyCode) ||
+        !Number.isSafeInteger(value.minorUnitScale) ||
+        Number(value.minorUnitScale) < 0 ||
+        Number(value.minorUnitScale) > 6 ||
+        value.roundingMode !== 'half-away-from-zero' ||
+        (value.resourceContribution !== undefined && !isResourceContribution(value.resourceContribution, scopeId)) ||
+        !Array.isArray(value.recommendationContributions) ||
+        value.recommendationContributions.length > 20000 ||
+        !value.recommendationContributions.every(contribution => isRecommendationContribution(contribution, scopeId)) ||
+        (partial &&
+            (!Array.isArray(value.unavailableScenarioIds) ||
+                value.unavailableScenarioIds.length === 0 ||
+                value.unavailableScenarioIds.length > 20000 ||
+                !value.unavailableScenarioIds.every(isFinancialSavingsIdentity) ||
+                new Set(value.unavailableScenarioIds).size !== value.unavailableScenarioIds.length)))
+        return false;
+    const recommendationIds = value.recommendationContributions.map(contribution => contribution.recommendationId);
+    const allocationIds = value.recommendationContributions.flatMap(contribution => contribution.allocationIds);
+    const contributionSum = sumFinancialSavingsMinorUnits(value.recommendationContributions.map(contribution => contribution.savingsMinorUnits));
+    const resourceContribution = value.resourceContribution;
+    return (new Set(recommendationIds).size === recommendationIds.length &&
+        new Set(allocationIds).size === allocationIds.length &&
+        contributionSum !== undefined &&
+        (resourceContribution === undefined
+            ? allocationIds.length === 0 && contributionSum === 0
+            : haveSameFinancialSavingsSet(allocationIds, resourceContribution.allocationIds) &&
+                contributionSum === resourceContribution.savingsMinorUnits));
+};
+/** Strict structural and arithmetic validation for one bounded resource savings projection. */
+export const isFinancialSavingsResourceProjectionV1 = (value) => {
+    if (!isFinancialSavingsRecord(value) ||
+        !hasExactFinancialSavingsFields(value, [
+            'contractVersion',
+            'savingsAuthorityId',
+            'financialAuthorityId',
+            'artifactGeneration',
+            'scopeId',
+            'coordinates',
+        ]) ||
+        value.contractVersion !== 'financial-savings-resource-projection/v1' ||
+        !isFinancialSavingsHash(value.savingsAuthorityId) ||
+        !isFinancialSavingsHash(value.financialAuthorityId) ||
+        !isFinancialSavingsRecord(value.artifactGeneration) ||
+        !hasExactFinancialSavingsFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
+        !isFinancialSavingsIdentity(value.artifactGeneration.runId) ||
+        !isFinancialSavingsIsoInstant(value.artifactGeneration.generatedAt) ||
+        !isFinancialSavingsIdentity(value.scopeId) ||
+        value.scopeId !== normalizeResourceScope(value.scopeId) ||
+        !Array.isArray(value.coordinates) ||
+        value.coordinates.length === 0 ||
+        value.coordinates.length > 128)
+        return false;
+    const projection = value;
+    return (projection.coordinates.every(coordinate => isSavingsResourceCoordinate(coordinate, projection.scopeId)) &&
+        new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size === projection.coordinates.length);
+};
+/** Verifies that the bounded savings projection is the exact companion of one bounded Financial Authority projection. */
+export const isFinancialSavingsResourceProjectionBoundToFinancialProjectionV1 = (value, financialProjection) => {
+    if (!isFinancialSavingsResourceProjectionV1(value))
+        return false;
+    const financialCoordinateIds = financialProjection.coordinates.map(coordinate => coordinate.coordinateId);
+    return (value.financialAuthorityId === financialProjection.authorityId &&
+        normalizeResourceScope(value.scopeId) === normalizeResourceScope(financialProjection.scopeId) &&
+        value.artifactGeneration.runId === financialProjection.artifactGeneration.runId &&
+        value.artifactGeneration.generatedAt === financialProjection.artifactGeneration.generatedAt &&
+        haveSameFinancialSavingsSet(value.coordinates.map(coordinate => coordinate.coordinateId), financialCoordinateIds));
+};

package/dist/esm/azure/financialSavingsCoordinateValidation.js

@@ -23,8 +23,17 @@ const ACTIVATION_REASONS = new Set([
     'lifecycle-conflict',
     'unrecognized-lifecycle',
     'generation-mismatch',
+    'projection-unavailable',
+    'eligibility-unavailable',
+]);
+const UNAVAILABLE_ACTIVATION_REASONS = new Set([
+    'lifecycle-stale',
+    'lifecycle-unavailable',
+    'lifecycle-conflict',
+    'generation-mismatch',
+    'projection-unavailable',
+    'eligibility-unavailable',
 ]);
-const UNAVAILABLE_ACTIVATION_REASONS = new Set(['lifecycle-stale', 'lifecycle-unavailable', 'lifecycle-conflict', 'generation-mismatch']);
 export const canonicalizeFinancialSavingsDenominatorIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
     kind: value.kind,
     baselineId: value.baselineId,
@@ -35,7 +44,8 @@ export const canonicalizeFinancialSavingsDenominatorIdentityV1 = (value) => JSON
 export const createFinancialSavingsDenominatorIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialSavingsDenominatorIdentityV1(value))}`;
 export const canonicalizeFinancialSavingsActivationIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
     recommendationId: value.recommendationId,
-    projectionId: value.projectionId,
+    scenarioId: value.scenarioId,
+    ...(value.projectionId === undefined ? {} : { projectionId: value.projectionId }),
     lifecycleState: value.lifecycleState,
     lifecycleVersion: value.lifecycleVersion,
     lifecycleEvidenceRefId: value.lifecycleEvidenceRefId,
@@ -49,10 +59,11 @@ export const canonicalizeFinancialSavingsAllocationIdentityV1 = (value) => JSON.
     ownerScopeId: value.ownerScopeId,
     billableComponentIds: [...value.billableComponentIds].sort(),
     recommendationId: value.recommendationId,
+    scenarioId: value.scenarioId,
     baselineId: value.baselineId,
     projectionId: value.projectionId,
     denominatorId: value.denominatorId,
-    eligibility: value.eligibility.kind === 'not-applicable'
+    eligibility: value.eligibility.kind !== 'mapped'
         ? value.eligibility
         : {
             ...value.eligibility,
@@ -98,10 +109,23 @@ const isActivationDecision = (state, result, reason) => {
     return UNAVAILABLE_ACTIVATION_REASONS.has(reason);
 };
 const isEligibility = (value) => {
-    if (!isFinancialSavingsRecord(value) || (value.kind !== 'not-applicable' && value.kind !== 'mapped'))
+    if (!isFinancialSavingsRecord(value) || !['not-applicable', 'unavailable', 'mapped'].includes(String(value.kind)))
         return false;
     if (value.kind === 'not-applicable')
         return Object.keys(value).length === 1;
+    if (value.kind === 'unavailable') {
+        return (Object.keys(value).length === 2 &&
+            typeof value.reason === 'string' &&
+            [
+                'rule-evidence-unavailable',
+                'eligibility-baseline-unavailable',
+                'eligible-components-unavailable',
+                'denominator-unavailable',
+                'current-baseline-mapping-unavailable',
+                'currency-conflict',
+                'reconciliation-failure',
+            ].includes(value.reason));
+    }
     return (Object.keys(value).length === 5 &&
         isFinancialSavingsHash(value.eligibilityId) &&
         isFinancialSavingsHash(value.eligibilityBaselineId) &&
@@ -114,7 +138,7 @@ const isEligibility = (value) => {
         value.eligibilityComponentIds.every(isFinancialSavingsIdentity) &&
         new Set(value.eligibilityComponentIds).size === value.eligibilityComponentIds.length);
 };
-const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId) => {
+const validateComposedCoordinate = (value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId) => {
     if (!hasExactFinancialSavingsFields(value, [
         'status',
         'coordinateId',
@@ -140,7 +164,7 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
         value.roundingMode !== 'half-away-from-zero' ||
         !isFinancialSavingsRecord(value.scenarioCoverage) ||
         !hasExactFinancialSavingsFields(value.scenarioCoverage, ['status', 'evidenceRefId', 'scenarioIds']) ||
-        value.scenarioCoverage.status !== 'complete' ||
+        value.scenarioCoverage.status !== (value.status === 'available' ? 'complete' : 'partial') ||
         !isFinancialSavingsHash(value.scenarioCoverage.evidenceRefId) ||
         !Array.isArray(value.scenarioCoverage.scenarioIds) ||
         value.scenarioCoverage.scenarioIds.length > 20000 ||
@@ -166,15 +190,17 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
         Date.parse(scenarioCoverageEvidence.intrinsicTime.at) > Date.parse(authorityGeneratedAt))
         return false;
     const projectionById = new Map(authorityCoordinate.projections.flatMap(projection => (projection.status === 'available' ? [[projection.projectionId, projection]] : [])));
+    const availableProjectionScenarioIds = new Set(authorityCoordinate.projections.flatMap(projection => (projection.status === 'available' ? [projection.scenarioId] : [])));
+    const unavailableEligibilityScenarioIds = new Set([...eligibilityById.values()].flatMap(assessment => (assessment.status === 'unavailable' ? [assessment.scenarioId] : [])));
     const activationById = new Map();
-    const activationByRecommendationId = new Map();
+    const activationByScenarioId = new Map();
     for (const activation of value.activations) {
         const lifecycleEvidence = evidenceById.get(activation.lifecycleEvidenceRefId);
         if (!isFinancialSavingsRecord(activation) ||
             !hasExactFinancialSavingsFields(activation, [
                 'activationId',
+                'scenarioId',
                 'recommendationId',
-                'projectionId',
                 'lifecycleState',
                 'lifecycleVersion',
                 'lifecycleEvidenceRefId',
@@ -182,19 +208,29 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
                 'reason',
                 'evaluatedAt',
                 'policyVersion',
-            ]) ||
+            ], ['projectionId']) ||
             !isFinancialSavingsHash(activation.activationId) ||
             activationById.has(activation.activationId) ||
-            activationByRecommendationId.has(activation.recommendationId) ||
+            activationByScenarioId.has(activation.scenarioId) ||
+            !isFinancialSavingsIdentity(activation.scenarioId) ||
             !isFinancialSavingsIdentity(activation.recommendationId) ||
-            !isFinancialSavingsHash(activation.projectionId) ||
+            (activation.projectionId !== undefined && !isFinancialSavingsHash(activation.projectionId)) ||
             !isFinancialSavingsIdentity(activation.lifecycleVersion) ||
             !isFinancialSavingsHash(activation.lifecycleEvidenceRefId) ||
             !isActivationDecision(activation.lifecycleState, activation.result, activation.reason) ||
             !isFinancialSavingsIsoInstant(activation.evaluatedAt) ||
             Date.parse(activation.evaluatedAt) > Date.parse(authorityGeneratedAt) ||
             !isFinancialSavingsIdentity(activation.policyVersion) ||
-            projectionById.get(activation.projectionId)?.scenarioId !== activation.recommendationId ||
+            (activation.result === 'included' &&
+                (activation.projectionId === undefined || projectionById.get(activation.projectionId)?.scenarioId !== activation.scenarioId)) ||
+            (activation.result === 'excluded' &&
+                activation.projectionId !== undefined &&
+                projectionById.get(activation.projectionId)?.scenarioId !== activation.scenarioId) ||
+            (activation.result === 'unavailable' &&
+                (activation.projectionId !== undefined ||
+                    (activation.reason === 'projection-unavailable' && availableProjectionScenarioIds.has(activation.scenarioId)) ||
+                    (activation.reason === 'eligibility-unavailable' &&
+                        !unavailableEligibilityScenarioIds.has(activation.scenarioId)))) ||
             lifecycleEvidence?.role !== 'recommendation-lifecycle' ||
             lifecycleEvidence.revisionId !== activation.lifecycleVersion ||
             Date.parse(lifecycleEvidence.intrinsicTime.at) > Date.parse(authorityGeneratedAt))
@@ -203,12 +239,15 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
         if (activation.activationId !== createFinancialSavingsActivationIdV1(activationIdentity))
             return false;
         activationById.set(activation.activationId, activation);
-        activationByRecommendationId.set(activation.recommendationId, activation);
+        activationByScenarioId.set(activation.scenarioId, activation);
     }
     const coveredScenarioIds = new Set(value.scenarioCoverage.scenarioIds);
-    const activatedScenarioIds = new Set(value.activations.map(activation => activation.recommendationId));
+    const activatedScenarioIds = new Set(value.activations.map(activation => activation.scenarioId));
     if (value.scenarioCoverage.scenarioIds.some(scenarioId => !activatedScenarioIds.has(scenarioId)) ||
-        value.activations.some(activation => !coveredScenarioIds.has(activation.recommendationId)))
+        value.activations.some(activation => !coveredScenarioIds.has(activation.scenarioId)))
+        return false;
+    const hasUnavailableActivation = value.activations.some(activation => activation.result === 'unavailable');
+    if ((value.status === 'available' && hasUnavailableActivation) || (value.status === 'partial' && !hasUnavailableActivation))
         return false;
     const allocationById = new Map();
     const allocatedBaselineComponents = new Set();
@@ -218,7 +257,7 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
         const eligibility = allocation.eligibility.kind === 'mapped' ? eligibilityById.get(allocation.eligibility.eligibilityId) : undefined;
         const expectedDenominatorId = allocation.eligibility.kind === 'mapped' && eligibility?.status === 'available'
             ? eligibility.denominator.denominatorId
-            : projection
+            : allocation.eligibility.kind === 'not-applicable' && projection
                 ? createFinancialSavingsDenominatorIdV1({
                     kind: 'projection-affected-current',
                     baselineId: projection.baselineId,
@@ -232,6 +271,7 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
                 'allocationId',
                 'ownerScopeId',
                 'billableComponentIds',
+                'scenarioId',
                 'recommendationId',
                 'baselineId',
                 'projectionId',
@@ -248,6 +288,7 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
             allocation.billableComponentIds.length > 20000 ||
             !allocation.billableComponentIds.every(isFinancialSavingsIdentity) ||
             new Set(allocation.billableComponentIds).size !== allocation.billableComponentIds.length ||
+            !isFinancialSavingsIdentity(allocation.scenarioId) ||
             !isFinancialSavingsIdentity(allocation.recommendationId) ||
             !isFinancialSavingsHash(allocation.baselineId) ||
             !isFinancialSavingsHash(allocation.projectionId) ||
@@ -261,15 +302,17 @@ const validateAvailableCoordinate = (value, authorityCoordinate, eligibilityById
             projection.baselineId !== allocation.baselineId ||
             !haveSameFinancialSavingsSet(projection.affectedComponentIds, allocation.billableComponentIds) ||
             decimalToMinorUnits(projection.change.savings, value.minorUnitScale) !== allocation.savingsMinorUnits ||
+            projection.scenarioId !== allocation.scenarioId ||
             !activation ||
             activation.result !== 'included' ||
+            activation.scenarioId !== allocation.scenarioId ||
             activation.recommendationId !== allocation.recommendationId ||
             activation.projectionId !== allocation.projectionId ||
             (allocation.eligibility.kind === 'mapped' &&
                 (!eligibility ||
                     eligibility.status !== 'available' ||
                     eligibility.scopeId !== allocation.ownerScopeId ||
-                    eligibility.scenarioId !== allocation.recommendationId ||
+                    eligibility.scenarioId !== allocation.scenarioId ||
                     eligibility.eligibilityBaselineId !== allocation.eligibility.eligibilityBaselineId ||
                     eligibility.denominator.denominatorId !== allocation.denominatorId ||
                     eligibility.currentBaselineMapping.currentBaselineId !== allocation.baselineId ||
@@ -360,6 +403,6 @@ export const validateFinancialSavingsCoordinateEnvelopeV1 = (value, authorityCoo
                 ? value.currentAggregateBaselineId === authorityCoordinate.aggregateBaseline.baselineId
                 : value.currentAggregateBaselineId === undefined));
     }
-    return (value.status === 'available' &&
-        validateAvailableCoordinate(value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId));
+    return ((value.status === 'available' || value.status === 'partial') &&
+        validateComposedCoordinate(value, authorityCoordinate, eligibilityById, evidenceById, authorityGeneratedAt, authorityRunId));
 };