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

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

package/dist/esm/azure/financialSavingsSurfaceProjection.js

@@ -1,2 +1,4 @@
 export const FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1 = 1;
 export const FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1 = 'financial-savings-surface-projection/v1';
+export const FINANCIAL_SAVINGS_QUERY_SELECTION_CONTRACT_VERSION_V1 = 'financial-savings-query-selection/v1';
+export const FINANCIAL_SAVINGS_RESOURCE_QUERY_SELECTION_CONTRACT_VERSION_V1 = 'financial-savings-resource-query-selection/v1';