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

package/dist/esm/azure/financialPolicyValidation.js

@@ -1,8 +1,9 @@
 import { multiplyExactDecimalValues, parseCanonicalDecimal, subtractExactDecimalValues } from '../common/exactDecimal.js';
 import { sha256Utf8 } from '../common/sha256.js';
 import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+import { isFinancialChargeInclusionPolicyRefV1 } from './financialChargeCompositionValidation.js';
 import { FINANCIAL_POLICY_DEFINITION_CONTRACT_VERSION_V1, FINANCIAL_POLICY_EVALUATION_CONTRACT_VERSION_V1, } from './financialPolicy.js';
-import { FINANCIAL_DATAFLOW_LIMITS_V1, canonicalizeFinancialDataflowJsonV1, canonicalizeFinancialDataflowCoordinateV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowCurrencyV1, createFinancialDataflowCoordinateIdV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowRecordV1, isFinancialDataflowScopeV1, isFinancialDataflowSortedUniqueStringsV1, isFinancialDataflowValueWithinLimitsV1, } from './financialDataflowValidation.js';
+import { FINANCIAL_DATAFLOW_LIMITS_V1, canonicalizeFinancialDataflowJsonV1, canonicalizeFinancialDataflowCoordinateV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowCurrencyV1, createFinancialDataflowCoordinateIdV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowRecordV1, isFinancialDataflowScopeSelectorV1, isFinancialDataflowSortedUniqueStringsV1, isFinancialDataflowValueWithinLimitsV1, } from './financialDataflowValidation.js';
 import { isCurrentSpendCompositionV1 } from './financialDataflowValidation.js';
 import { isFinancialAnalyticsProjectionV1 } from './financialAnalyticsValidation.js';
 const COST_BASES = new Set(['billed', 'amortized']);
@@ -10,6 +11,12 @@ const ESTIMATE_LENSES = new Set(['billing-only', 'include-estimates', 'estimates
 const MATCHED_THRESHOLD_KINDS = new Set(['amount', 'percent', 'minimum-amount', 'minimum-delta', 'minimum-percent-change']);
 const MAX_THRESHOLDS = 64;
 const MAX_DESTINATIONS = 256;
+const isCanonicalPolicyRevision = (value) => {
+    if (typeof value !== 'string' || !/^[1-9]\d*$/.test(value))
+        return false;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && String(parsed) === value;
+};
 const isCanonicalDecimal = (value) => typeof value === 'string' && isCanonicalExactMoney({ amount: value, currencyCode: 'AUD' });
 const isNonNegativeDecimal = (value) => {
     if (!isCanonicalDecimal(value))
@@ -46,28 +53,63 @@ const isThresholdSet = (value) => {
     }
     return new Set(value.amounts).size === value.amounts.length && new Set(value.percents).size === value.percents.length;
 };
+const isScopeSelectorBoundToProviderAccounts = (selector, providerAccountRefs) => {
+    if (!isFinancialDataflowScopeSelectorV1(selector) || !Array.isArray(providerAccountRefs))
+        return false;
+    const providerSubscriptions = providerAccountRefs.map(value => {
+        if (typeof value !== 'string' || !value.toLowerCase().startsWith('azure-subscription:'))
+            return undefined;
+        const subscriptionId = value.slice('azure-subscription:'.length).trim().toLowerCase();
+        return subscriptionId || undefined;
+    });
+    if (providerSubscriptions.some(value => value === undefined))
+        return false;
+    const authorized = new Set(providerSubscriptions);
+    if (selector.kind === 'subscription' || selector.kind === 'multi-subscription') {
+        const selected = selector.subscriptionIds.map(value => value.trim().toLowerCase());
+        return selected.length === authorized.size && selected.every(value => authorized.has(value));
+    }
+    if (selector.kind === 'tag-scope')
+        return true;
+    const ids = selector.kind === 'resource' ? selector.resourceIds : selector.resourceGroupIds;
+    return ids.every(value => {
+        const match = /^\/subscriptions\/([^/]+)(?:\/|$)/i.exec(value.trim());
+        return match?.[1] !== undefined && authorized.has(match[1].toLowerCase());
+    });
+};
 const isCoordinateRequest = (value, companyId) => isFinancialDataflowRecordV1(value) &&
     hasFinancialDataflowExactFieldsV1(value, [
         'provider',
         'providerAccountRefs',
         'scope',
+        'scopeSelector',
         'period',
         'costBasis',
         'estimateLens',
+        'chargeInclusionPolicyRef',
         'requiredAccountingCurrencyCode',
     ]) &&
     value.provider === 'azure' &&
     isFinancialDataflowSortedUniqueStringsV1(value.providerAccountRefs, FINANCIAL_DATAFLOW_LIMITS_V1.maximumProviderAccounts) &&
     value.providerAccountRefs.length > 0 &&
-    isFinancialDataflowScopeV1(value.scope) &&
+    isFinancialDataflowRecordV1(value.scope) &&
+    hasFinancialDataflowExactFieldsV1(value.scope, ['kind', 'scopeId']) &&
+    ['resource', 'resource-group', 'subscription', 'tag-scope', 'multi-subscription'].includes(String(value.scope.kind)) &&
+    isFinancialDataflowIdentityV1(value.scope.scopeId) &&
+    isFinancialDataflowScopeSelectorV1(value.scopeSelector) &&
+    value.scopeSelector.kind === value.scope.kind &&
+    isScopeSelectorBoundToProviderAccounts(value.scopeSelector, value.providerAccountRefs) &&
     isFinancialDataflowRecordV1(value.period) &&
-    hasFinancialDataflowExactFieldsV1(value.period, ['kind', 'timeZone']) &&
+    hasFinancialDataflowExactFieldsV1(value.period, ['kind', 'dateBasis'], ['timeZone']) &&
     (value.period.kind === 'calendar-month' || value.period.kind === 'rolling-30-days') &&
-    isFinancialDataflowIdentityV1(value.period.timeZone) &&
+    (value.period.dateBasis === 'utc'
+        ? value.period.timeZone === undefined
+        : value.period.dateBasis === 'company-local' && isFinancialDataflowIdentityV1(value.period.timeZone)) &&
     typeof value.costBasis === 'string' &&
     COST_BASES.has(value.costBasis) &&
     typeof value.estimateLens === 'string' &&
     ESTIMATE_LENSES.has(value.estimateLens) &&
+    isFinancialChargeInclusionPolicyRefV1(value.chargeInclusionPolicyRef) &&
     isFinancialDataflowCurrencyV1(value.requiredAccountingCurrencyCode) &&
     isFinancialDataflowIdentityV1(companyId);
 const isCriteria = (value, currencyCode) => {
@@ -89,13 +131,14 @@ const isCriteria = (value, currencyCode) => {
         (value.minimumDelta === undefined || isNonNegativeDecimal(value.minimumDelta)) &&
         (value.minimumPercentChange === undefined || isNonNegativeDecimal(value.minimumPercentChange)));
 };
-const isDefinitionIdentity = (value) => {
+export const isFinancialPolicyDefinitionRevisionIdentityPreimageV1 = (value) => {
     if (!isFinancialDataflowRecordV1(value) ||
         !hasFinancialDataflowExactFieldsV1(value, [
             'schemaVersion',
             'contractVersion',
             'companyId',
             'definitionId',
+            'displayName',
             'revision',
             'effectiveState',
             'coordinateRequest',
@@ -110,7 +153,8 @@ const isDefinitionIdentity = (value) => {
         value.contractVersion !== FINANCIAL_POLICY_DEFINITION_CONTRACT_VERSION_V1 ||
         !isFinancialDataflowIdentityV1(value.companyId) ||
         !isFinancialDataflowIdentityV1(value.definitionId) ||
-        !isFinancialDataflowIdentityV1(value.revision) ||
+        !isFinancialDataflowIdentityV1(value.displayName) ||
+        !isCanonicalPolicyRevision(value.revision) ||
         !['enabled', 'disabled', 'deleted'].includes(String(value.effectiveState)) ||
         !isCoordinateRequest(value.coordinateRequest, value.companyId) ||
         !isFinancialDataflowRecordV1(value.coordinateRequest) ||
@@ -126,10 +170,22 @@ const isDefinitionIdentity = (value) => {
         !isFinancialDataflowIdentityV1(value.authoredByUserId)) {
         return false;
     }
-    return value.effectiveState !== 'enabled' || value.destinationRefIds.length > 0;
+    if (value.criteria.kind === 'budget' &&
+        value.criteria.forecastThresholds !== undefined &&
+        (value.coordinateRequest.period.kind !== 'calendar-month' || value.coordinateRequest.estimateLens !== 'billing-only')) {
+        return false;
+    }
+    if (value.criteria.kind === 'cost-anomaly' &&
+        (value.coordinateRequest.period.kind !== 'rolling-30-days' || value.coordinateRequest.estimateLens !== 'billing-only')) {
+        return false;
+    }
+    // Alert Instance state is the canonical internal policy side effect.
+    // External destinations are optional and must not determine whether an
+    // enabled policy is valid or evaluable.
+    return true;
 };
 export const canonicalizeFinancialPolicyDefinitionRevisionIdentityV1 = (value) => {
-    if (!isFinancialDataflowValueWithinLimitsV1(value) || !isDefinitionIdentity(value)) {
+    if (!isFinancialDataflowValueWithinLimitsV1(value) || !isFinancialPolicyDefinitionRevisionIdentityPreimageV1(value)) {
         throw new TypeError('Invalid FinancialPolicyDefinitionRevisionIdentityPreimageV1.');
     }
     const criteria = value.criteria.kind === 'budget'
@@ -171,7 +227,7 @@ export const isFinancialPolicyDefinitionRevisionV1 = (value) => {
         return false;
     const { policyDefinitionRevisionId, ...identity } = value;
     return (isFinancialDataflowHashV1(policyDefinitionRevisionId) &&
-        isDefinitionIdentity(identity) &&
+        isFinancialPolicyDefinitionRevisionIdentityPreimageV1(identity) &&
         policyDefinitionRevisionId === createFinancialPolicyDefinitionRevisionIdV1(identity));
 };
 const isMatchedThresholds = (value) => Array.isArray(value) &&
@@ -216,8 +272,12 @@ const isEvaluationIdentity = (value) => {
         !isMatchedThresholds(value.matchedThresholds)) {
         return false;
     }
-    const analyticsRequired = value.signalKind === 'budget-forecast' || value.signalKind === 'cost-anomaly';
-    return analyticsRequired ? isFinancialDataflowHashV1(value.analyticsProjectionId) : value.analyticsProjectionId === undefined;
+    const analyticsSignal = value.signalKind === 'budget-forecast' || value.signalKind === 'cost-anomaly';
+    if (!analyticsSignal)
+        return value.analyticsProjectionId === undefined;
+    if (value.result !== 'unavailable')
+        return isFinancialDataflowHashV1(value.analyticsProjectionId);
+    return value.analyticsProjectionId === undefined || isFinancialDataflowHashV1(value.analyticsProjectionId);
 };
 export const canonicalizeFinancialPolicyEvaluationIdentityV1 = (value) => {
     if (!isFinancialDataflowValueWithinLimitsV1(value) || !isEvaluationIdentity(value)) {
@@ -332,6 +392,10 @@ const safeAnomalyMatchedThresholds = (definition, analyticsProjection) => {
         return undefined;
     }
 };
+const isExpectedCalendarMonthTargetPartial = (composition) => composition.coordinate.period.windowKind === 'calendar-month' &&
+    composition.amount.status === 'partial' &&
+    composition.amount.reasonCodes.length === 1 &&
+    composition.amount.reasonCodes[0] === 'coverage-incomplete';
 /** Validates definition, coordinate, financial input, and signal links after authorization. */
 export const isFinancialPolicyEvaluationCompatibleV1 = (evaluation, definition, currentSpendComposition, analyticsProjection) => {
     if (!isFinancialPolicyEvaluationV1(evaluation) ||
@@ -355,13 +419,17 @@ export const isFinancialPolicyEvaluationCompatibleV1 = (evaluation, definition,
         !sameStrings(request.providerAccountRefs, coordinate.providerAccountRefs) ||
         request.scope.kind !== coordinate.scope.kind ||
         request.scope.scopeId !== coordinate.scope.scopeId ||
-        request.scope.scopeFingerprint !== coordinate.scope.scopeFingerprint ||
         request.costBasis !== coordinate.costBasis ||
         request.estimateLens !== coordinate.estimateLens ||
-        request.requiredAccountingCurrencyCode !== currency ||
+        canonicalizeFinancialDataflowJsonV1(request.chargeInclusionPolicyRef) !==
+            canonicalizeFinancialDataflowJsonV1(coordinate.chargeInclusionPolicyRef) ||
         coordinate.requestedCurrencyCode !== request.requiredAccountingCurrencyCode ||
+        (currency === undefined
+            ? currentSpendComposition.amount.status !== 'unavailable'
+            : request.requiredAccountingCurrencyCode !== currency) ||
         request.period.kind !== coordinate.period.windowKind ||
-        request.period.timeZone !== periodTimeZone) {
+        request.period.dateBasis !== coordinate.period.requested.dateBasis ||
+        (request.period.dateBasis === 'company-local' && request.period.timeZone !== periodTimeZone)) {
         return false;
     }
     if (evaluation.result === 'matched' ? evaluation.matchedThresholds.length === 0 : evaluation.matchedThresholds.length > 0)
@@ -403,7 +471,16 @@ export const isFinancialPolicyEvaluationCompatibleV1 = (evaluation, definition,
             return evaluation.result === 'unavailable' && evaluation.matchedThresholds.length === 0;
         }
         if (currentSpendComposition.amount.status === 'partial') {
-            return evaluation.result === 'partial' && evaluation.matchedThresholds.length === 0;
+            if (!isExpectedCalendarMonthTargetPartial(currentSpendComposition)) {
+                return evaluation.result === 'partial' && evaluation.matchedThresholds.length === 0;
+            }
+            if (definition.criteria.kind !== 'budget' || definition.criteria.currentSpendThresholds === undefined)
+                return false;
+            const expectedThresholds = safeBudgetMatchedThresholds(currentSpendComposition.amount.knownAmount, definition.criteria.budget.amount, definition.criteria.currentSpendThresholds);
+            if (expectedThresholds === undefined)
+                return false;
+            return (evaluation.result === (expectedThresholds.length > 0 ? 'matched' : 'not-matched') &&
+                hasExactMatchedThresholds(evaluation.matchedThresholds, expectedThresholds));
         }
         if (definition.criteria.kind !== 'budget' || definition.criteria.currentSpendThresholds === undefined)
             return false;
@@ -413,6 +490,12 @@ export const isFinancialPolicyEvaluationCompatibleV1 = (evaluation, definition,
         return (evaluation.result === (expectedThresholds.length > 0 ? 'matched' : 'not-matched') &&
             hasExactMatchedThresholds(evaluation.matchedThresholds, expectedThresholds));
     }
+    if (evaluation.result === 'unavailable' &&
+        evaluation.analyticsProjectionId === undefined &&
+        analyticsProjection === undefined &&
+        (evaluation.signalKind === 'budget-forecast' || evaluation.signalKind === 'cost-anomaly')) {
+        return evaluation.matchedThresholds.length === 0 && evaluation.reasonCode === 'analytics-projection-unavailable';
+    }
     if (!isFinancialAnalyticsProjectionV1(analyticsProjection) ||
         evaluation.analyticsProjectionId !== analyticsProjection.analyticsProjectionId ||
         analyticsProjection.coordinate.companyId !== coordinate.companyId ||
@@ -429,10 +512,21 @@ export const isFinancialPolicyEvaluationCompatibleV1 = (evaluation, definition,
     const actualAnalyticsKind = analyticsProjection.status === 'unavailable' ? analyticsProjection.resultKind : analyticsProjection.result.kind;
     if (actualAnalyticsKind !== expectedAnalyticsKind)
         return false;
+    if (analyticsProjection.currentSpendCompositionId !== undefined &&
+        analyticsProjection.currentSpendCompositionId !== currentSpendComposition.compositionId) {
+        return false;
+    }
+    if (evaluation.signalKind === 'budget-forecast' &&
+        analyticsProjection.status !== 'unavailable' &&
+        analyticsProjection.currentSpendCompositionId !== currentSpendComposition.compositionId) {
+        return false;
+    }
     if (currentSpendComposition.amount.status === 'unavailable' || analyticsProjection.status === 'unavailable') {
         return evaluation.result === 'unavailable' && evaluation.matchedThresholds.length === 0;
     }
-    if (currentSpendComposition.amount.status === 'partial' || analyticsProjection.status === 'partial') {
+    if (analyticsProjection.status === 'partial' ||
+        (currentSpendComposition.amount.status === 'partial' &&
+            !(evaluation.signalKind === 'budget-forecast' && isExpectedCalendarMonthTargetPartial(currentSpendComposition)))) {
         return evaluation.result === 'partial' && evaluation.matchedThresholds.length === 0;
     }
     if (evaluation.result !== 'matched' && evaluation.result !== 'not-matched')

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/financialResourceSurfaceProjection.js

@@ -0,0 +1,2 @@
+export const FINANCIAL_RESOURCE_SURFACE_PROJECTION_SCHEMA_VERSION_V1 = 1;
+export const FINANCIAL_RESOURCE_SURFACE_PROJECTION_CONTRACT_VERSION_V1 = 'financial-resource-surface-projection/v1';

package/dist/esm/azure/financialResourceSurfaceProjectionValidation.js

@@ -0,0 +1,243 @@
+import { formatExactDecimalValue, parseCanonicalDecimal, subtractExactDecimalValues } from '../common/exactDecimal.js';
+import { sha256Utf8 } from '../common/sha256.js';
+import { FINANCIAL_RESOURCE_SURFACE_PROJECTION_CONTRACT_VERSION_V1, FINANCIAL_RESOURCE_SURFACE_PROJECTION_SCHEMA_VERSION_V1, } from './financialResourceSurfaceProjection.js';
+import { isFinancialSurfaceCoordinateDefinitionV1, isFinancialSurfaceMoneyV1, } from './financialCurrentSpendSurfaceProjectionValidation.js';
+import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsRecord, } from './financialSavingsAuthorityValidationPrimitives.js';
+import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+const MAX_COORDINATES = 128;
+const MAX_RESOURCES = 50000;
+const MAX_VALUES_PER_RESOURCE = 128;
+const MAX_SCENARIOS_PER_RESOURCE = 1024;
+const MAX_REASONS = 64;
+const RESOURCE_ROLES = new Set(['owner', 'display-only', 'unclassified']);
+const SCENARIO_CATEGORIES = new Set(['cost', 'security', 'reliability', 'performance', 'operational-excellence', 'compliance']);
+const CURRENCY = /^[A-Z]{3}$/;
+const isCurrency = (value) => typeof value === 'string' && CURRENCY.test(value);
+const isReasonCodes = (value) => Array.isArray(value) &&
+    value.length > 0 &&
+    value.length <= MAX_REASONS &&
+    value.every(isFinancialSavingsIdentity) &&
+    new Set(value).size === value.length;
+const isExactAmount = (amount, currencyCode) => isCurrency(currencyCode) && isCanonicalExactMoney({ amount, currencyCode });
+const isScenario = (value, coordinateIds, requestedCurrencyCode) => {
+    if (!isFinancialSavingsRecord(value))
+        return false;
+    const commonValid = isFinancialSavingsIdentity(value.scenarioId) &&
+        isFinancialSavingsHash(value.coordinateId) &&
+        coordinateIds.has(value.coordinateId) &&
+        (value.recommendationId === undefined || isFinancialSavingsIdentity(value.recommendationId)) &&
+        typeof value.category === 'string' &&
+        SCENARIO_CATEGORIES.has(value.category) &&
+        value.additivity === 'non-additive';
+    if (!commonValid)
+        return false;
+    const optionalCommon = ['recommendationId'];
+    if (value.status === 'available') {
+        if (!hasExactFinancialSavingsFields(value, [
+            'scenarioId',
+            'coordinateId',
+            'category',
+            'additivity',
+            'status',
+            'currentAmount',
+            'targetAmount',
+            'changeAmount',
+            'currencyCode',
+        ], optionalCommon) ||
+            !isExactAmount(value.currentAmount, value.currencyCode) ||
+            !isExactAmount(value.targetAmount, value.currencyCode) ||
+            !isExactAmount(value.changeAmount, value.currencyCode) ||
+            (requestedCurrencyCode !== undefined && value.currencyCode !== requestedCurrencyCode))
+            return false;
+        return (value.changeAmount ===
+            formatExactDecimalValue(subtractExactDecimalValues(parseCanonicalDecimal(value.targetAmount), parseCanonicalDecimal(value.currentAmount))));
+    }
+    if (value.status === 'unavailable') {
+        return hasExactFinancialSavingsFields(value, ['scenarioId', 'coordinateId', 'category', 'additivity', 'status', 'reasonCodes'], optionalCommon) && isReasonCodes(value.reasonCodes);
+    }
+    if (value.status !== 'partial')
+        return false;
+    if (!hasExactFinancialSavingsFields(value, ['scenarioId', 'coordinateId', 'category', 'additivity', 'status', 'reasonCodes'], [...optionalCommon, 'currentAmount', 'targetAmount', 'changeAmount', 'currencyCode']) ||
+        !isReasonCodes(value.reasonCodes))
+        return false;
+    const monetaryFields = [value.currentAmount, value.targetAmount, value.changeAmount];
+    const presentAmounts = monetaryFields.filter(amount => amount !== undefined);
+    if (presentAmounts.length === 0)
+        return value.currencyCode === undefined;
+    return (isCurrency(value.currencyCode) &&
+        (requestedCurrencyCode === undefined || value.currencyCode === requestedCurrencyCode) &&
+        presentAmounts.every(amount => isExactAmount(amount, value.currencyCode)));
+};
+const canonicalizeValue = (value) => value.status === 'available' ? value : { ...value, reasonCodes: [...value.reasonCodes].sort() };
+const canonicalizeScenario = (value) => value.status === 'available' ? value : { ...value, reasonCodes: [...value.reasonCodes].sort() };
+export const canonicalizeFinancialResourceSurfaceProjectionIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
+    ...value,
+    providerAccountRefs: [...value.providerAccountRefs].sort(),
+    coordinates: [...value.coordinates].sort((left, right) => left.coordinateId.localeCompare(right.coordinateId)),
+    resources: [...value.resources]
+        .sort((left, right) => left.resourceId.localeCompare(right.resourceId))
+        .map(resource => ({
+        ...resource,
+        values: [...resource.values]
+            .sort((left, right) => left.coordinateId.localeCompare(right.coordinateId))
+            .map(canonicalizeValue),
+        ...(resource.scenarios === undefined
+            ? {}
+            : {
+                scenarios: [...resource.scenarios]
+                    .sort((left, right) => left.scenarioId.localeCompare(right.scenarioId) || left.coordinateId.localeCompare(right.coordinateId))
+                    .map(canonicalizeScenario),
+            }),
+    })),
+}));
+export const createFinancialResourceSurfaceProjectionIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialResourceSurfaceProjectionIdentityV1(value))}`;
+/**
+ * Selects one resource member without copying unrelated members or coordinates.
+ * The returned projection remains independently content-addressed and valid.
+ */
+export const projectFinancialResourceSurfaceMemberV1 = (source, resourceId) => {
+    if (!isFinancialResourceSurfaceProjectionV1(source)) {
+        throw new TypeError('Invalid FinancialResourceSurfaceProjectionV1.');
+    }
+    const normalizedResourceId = resourceId.trim().toLowerCase().replace(/\/+$/, '');
+    const member = source.resources.find(candidate => candidate.resourceId.trim().toLowerCase().replace(/\/+$/, '') === normalizedResourceId);
+    if (!member)
+        return undefined;
+    const coordinateIds = new Set([
+        ...member.values.map(value => value.coordinateId),
+        ...(member.scenarios ?? []).map(scenario => scenario.coordinateId),
+    ]);
+    const identity = {
+        schemaVersion: source.schemaVersion,
+        contractVersion: source.contractVersion,
+        provider: source.provider,
+        providerAccountRefs: [...source.providerAccountRefs],
+        artifactGeneration: source.artifactGeneration,
+        financialAuthorityId: source.financialAuthorityId,
+        coordinates: source.coordinates.filter(coordinate => coordinateIds.has(coordinate.coordinateId)),
+        resources: [member],
+    };
+    const projection = {
+        ...identity,
+        projectionId: createFinancialResourceSurfaceProjectionIdV1(identity),
+    };
+    if (!isFinancialResourceSurfaceProjectionV1(projection)) {
+        throw new TypeError('Invalid projected FinancialResourceSurfaceProjectionV1.');
+    }
+    return projection;
+};
+/**
+ * Removes mutable recommendation scenarios while preserving authoritative
+ * current-spend values. Used when lifecycle state is newer than the immutable
+ * financial artifact.
+ */
+export const projectFinancialResourceSurfaceWithoutScenariosV1 = (source) => {
+    if (!isFinancialResourceSurfaceProjectionV1(source)) {
+        throw new TypeError('Invalid FinancialResourceSurfaceProjectionV1.');
+    }
+    const referencedCoordinateIds = new Set(source.resources.flatMap(resource => resource.values.map(value => value.coordinateId)));
+    const identity = {
+        schemaVersion: source.schemaVersion,
+        contractVersion: source.contractVersion,
+        provider: source.provider,
+        providerAccountRefs: [...source.providerAccountRefs],
+        artifactGeneration: source.artifactGeneration,
+        financialAuthorityId: source.financialAuthorityId,
+        coordinates: source.coordinates.filter(coordinate => referencedCoordinateIds.has(coordinate.coordinateId)),
+        resources: source.resources.map(resource => {
+            const { scenarios: _scenarios, ...currentSpendOnly } = resource;
+            return currentSpendOnly;
+        }),
+    };
+    const projection = {
+        ...identity,
+        projectionId: createFinancialResourceSurfaceProjectionIdV1(identity),
+    };
+    if (!isFinancialResourceSurfaceProjectionV1(projection)) {
+        throw new TypeError('Invalid current-spend-only FinancialResourceSurfaceProjectionV1.');
+    }
+    return projection;
+};
+export const isFinancialResourceSurfaceProjectionV1 = (value) => {
+    if (!isFinancialSavingsRecord(value) ||
+        !hasExactFinancialSavingsFields(value, [
+            'schemaVersion',
+            'contractVersion',
+            'projectionId',
+            'provider',
+            'providerAccountRefs',
+            'artifactGeneration',
+            'financialAuthorityId',
+            'coordinates',
+            'resources',
+        ]) ||
+        value.schemaVersion !== FINANCIAL_RESOURCE_SURFACE_PROJECTION_SCHEMA_VERSION_V1 ||
+        value.contractVersion !== FINANCIAL_RESOURCE_SURFACE_PROJECTION_CONTRACT_VERSION_V1 ||
+        !isFinancialSavingsHash(value.projectionId) ||
+        value.provider !== 'azure' ||
+        !Array.isArray(value.providerAccountRefs) ||
+        value.providerAccountRefs.length === 0 ||
+        value.providerAccountRefs.length > 64 ||
+        !value.providerAccountRefs.every(isFinancialSavingsIdentity) ||
+        new Set(value.providerAccountRefs).size !== value.providerAccountRefs.length ||
+        !isFinancialSavingsRecord(value.artifactGeneration) ||
+        !hasExactFinancialSavingsFields(value.artifactGeneration, ['runId', 'generatedAt']) ||
+        !isFinancialSavingsIdentity(value.artifactGeneration.runId) ||
+        !isFinancialSavingsIsoInstant(value.artifactGeneration.generatedAt) ||
+        !isFinancialSavingsHash(value.financialAuthorityId) ||
+        !Array.isArray(value.coordinates) ||
+        value.coordinates.length === 0 ||
+        value.coordinates.length > MAX_COORDINATES ||
+        !value.coordinates.every(isFinancialSurfaceCoordinateDefinitionV1) ||
+        new Set(value.coordinates.map(coordinate => coordinate.coordinateId)).size !== value.coordinates.length ||
+        !Array.isArray(value.resources) ||
+        value.resources.length > MAX_RESOURCES)
+        return false;
+    const coordinateById = new Map(value.coordinates.map(coordinate => [coordinate.coordinateId, coordinate]));
+    const coordinateIds = new Set(coordinateById.keys());
+    const resourceIds = new Set();
+    for (const resource of value.resources) {
+        if (!isFinancialSavingsRecord(resource) ||
+            !hasExactFinancialSavingsFields(resource, ['resourceId', 'resourceType', 'financialRole', 'values'], ['scenarios']) ||
+            !isFinancialSavingsIdentity(resource.resourceId) ||
+            resourceIds.has(resource.resourceId.toLowerCase()) ||
+            !isFinancialSavingsIdentity(resource.resourceType) ||
+            typeof resource.financialRole !== 'string' ||
+            !RESOURCE_ROLES.has(resource.financialRole) ||
+            !Array.isArray(resource.values) ||
+            resource.values.length === 0 ||
+            resource.values.length > MAX_VALUES_PER_RESOURCE)
+            return false;
+        resourceIds.add(resource.resourceId.toLowerCase());
+        const valueCoordinates = new Set();
+        for (const memberValue of resource.values) {
+            if (!isFinancialSavingsRecord(memberValue) || !isFinancialSavingsHash(memberValue.coordinateId))
+                return false;
+            const definition = coordinateById.get(memberValue.coordinateId);
+            if (definition === undefined || valueCoordinates.has(memberValue.coordinateId))
+                return false;
+            const money = Object.fromEntries(Object.entries(memberValue).filter(([key]) => key !== 'coordinateId'));
+            if (!isFinancialSurfaceMoneyV1(money, definition.requestedCurrencyCode))
+                return false;
+            valueCoordinates.add(memberValue.coordinateId);
+        }
+        if (resource.scenarios !== undefined) {
+            if (!Array.isArray(resource.scenarios) || resource.scenarios.length > MAX_SCENARIOS_PER_RESOURCE)
+                return false;
+            const scenarioCoordinates = new Set();
+            for (const scenario of resource.scenarios) {
+                if (!isFinancialSavingsRecord(scenario) || !isFinancialSavingsHash(scenario.coordinateId))
+                    return false;
+                const definition = coordinateById.get(scenario.coordinateId);
+                if (definition === undefined ||
+                    !isScenario(scenario, coordinateIds, definition.requestedCurrencyCode) ||
+                    scenarioCoordinates.has(`${scenario.scenarioId}\u0000${scenario.coordinateId}`))
+                    return false;
+                scenarioCoordinates.add(`${scenario.scenarioId}\u0000${scenario.coordinateId}`);
+            }
+        }
+    }
+    const projection = value;
+    const { projectionId: _projectionId, ...identity } = projection;
+    return projection.projectionId === createFinancialResourceSurfaceProjectionIdV1(identity);
+};

package/dist/esm/azure/financialSavingsAuthority.js

@@ -1,4 +1,5 @@
 export const FINANCIAL_SAVINGS_AUTHORITY_SCHEMA_VERSION_V1 = 1;
 export const FINANCIAL_SAVINGS_AUTHORITY_CONTRACT_VERSION_V1 = 'financial-savings-authority/v1';
+export const FINANCIAL_SAVINGS_RESOURCE_PROJECTION_CONTRACT_VERSION_V1 = 'financial-savings-resource-projection/v1';
 export const FINANCIAL_ELIGIBILITY_ASSESSMENT_SCHEMA_VERSION_V1 = 1;
 export const FINANCIAL_ELIGIBILITY_ASSESSMENT_CONTRACT_VERSION_V1 = 'financial-eligibility-assessment/v1';