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

package/dist/esm/azure/financialDataflowValidation.js

@@ -2,6 +2,7 @@ import { sha256Utf8 } from '../common/sha256.js';
 import { formatExactDecimalValue, sumCanonicalDecimals } from '../common/exactDecimal.js';
 import { toCanonicalEstimateLensV1 } from './costComposition.js';
 import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
+import { isCompleteFinancialBaselinePeriodV2 } from './financialScopeBaseline.js';
 import { isFinancialScopeBaselineEnvelopeV2 } from './financialScopeBaselineValidation.js';
 import { FINANCIAL_CURRENT_SPEND_COMPOSITION_CONTRACT_VERSION_V1, FINANCIAL_DATAFLOW_SCHEMA_VERSION_V1, } from './financialDataflow.js';
 import { isFinancialBaselinePeriodV2 } from './financialScopeBaselineValidation.js';
@@ -141,6 +142,14 @@ export const isFinancialDataflowIdentityV1 = (value) => typeof value === 'string
 export const isFinancialDataflowHashV1 = (value) => typeof value === 'string' && SHA256_ID.test(value);
 export const isFinancialDataflowCurrencyV1 = (value) => typeof value === 'string' && CURRENCY.test(value);
 export const isFinancialDataflowIsoInstantV1 = (value) => typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value) && Number.isFinite(Date.parse(value));
+export const isFinancialDataflowJsonGzipArtifactDescriptorV1 = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, ['path', 'sha256', 'byteCount', 'mediaType', 'contentEncoding']) &&
+    isFinancialDataflowIdentityV1(value.path) &&
+    isFinancialDataflowHashV1(value.sha256) &&
+    Number.isSafeInteger(value.byteCount) &&
+    Number(value.byteCount) > 0 &&
+    value.mediaType === 'application/json' &&
+    value.contentEncoding === 'gzip';
 export const isFinancialDataflowCalendarDateV1 = (value) => {
     if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value))
         return false;
@@ -310,6 +319,46 @@ export const isFinancialDataflowScopeV1 = (value) => isFinancialDataflowRecordV1
     SCOPE_KINDS.has(value.kind) &&
     isFinancialDataflowIdentityV1(value.scopeId) &&
     isFinancialDataflowHashV1(value.scopeFingerprint);
+export const isFinancialDataflowPeriodV1 = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, ['windowKind', 'requested'], ['providerBillingPeriodId']) &&
+    isFinancialBaselinePeriodV2({ ...value, coverage: [], gaps: [] });
+export const isFinancialDataflowScopeSelectorV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) || typeof value.kind !== 'string' || !SCOPE_KINDS.has(value.kind))
+        return false;
+    if (value.kind === 'resource') {
+        return (hasFinancialDataflowExactFieldsV1(value, ['kind', 'resourceIds']) &&
+            isFinancialDataflowSortedUniqueStringsV1(value.resourceIds, FINANCIAL_DATAFLOW_LIMITS_V1.maximumMembers) &&
+            value.resourceIds.length === 1);
+    }
+    if (value.kind === 'resource-group') {
+        return (hasFinancialDataflowExactFieldsV1(value, ['kind', 'resourceGroupIds']) &&
+            isFinancialDataflowSortedUniqueStringsV1(value.resourceGroupIds, FINANCIAL_DATAFLOW_LIMITS_V1.maximumMembers) &&
+            value.resourceGroupIds.length === 1);
+    }
+    if (value.kind === 'subscription' || value.kind === 'multi-subscription') {
+        return (hasFinancialDataflowExactFieldsV1(value, ['kind', 'subscriptionIds']) &&
+            isFinancialDataflowSortedUniqueStringsV1(value.subscriptionIds, FINANCIAL_DATAFLOW_LIMITS_V1.maximumProviderAccounts) &&
+            value.subscriptionIds.length > 0 &&
+            (value.kind !== 'subscription' || value.subscriptionIds.length === 1));
+    }
+    if (!hasFinancialDataflowExactFieldsV1(value, ['kind', 'tags', 'tagMatch']) ||
+        (value.tagMatch !== 'any' && value.tagMatch !== 'all') ||
+        !Array.isArray(value.tags) ||
+        value.tags.length === 0 ||
+        value.tags.length > 256) {
+        return false;
+    }
+    const keys = value.tags.map(tag => {
+        if (!isFinancialDataflowRecordV1(tag) ||
+            !hasFinancialDataflowExactFieldsV1(tag, ['key', 'value']) ||
+            !isFinancialDataflowIdentityV1(tag.key) ||
+            !isFinancialDataflowIdentityV1(tag.value)) {
+            return undefined;
+        }
+        return `${tag.key}\u0000${tag.value}`;
+    });
+    return keys.every((key) => key !== undefined) && keys.every((key, index) => index === 0 || keys[index - 1] < key);
+};
 export const isFinancialDataflowCoordinateV1 = (value) => {
     if (!isFinancialDataflowRecordV1(value) ||
         !hasFinancialDataflowExactFieldsV1(value, ['companyId', 'provider', 'providerAccountRefs', 'scope', 'periodRole', 'period', 'costBasis', 'estimateLens', 'accountingCurrency'], ['requestedCurrencyCode']) ||
@@ -320,7 +369,7 @@ export const isFinancialDataflowCoordinateV1 = (value) => {
         !isFinancialDataflowScopeV1(value.scope) ||
         typeof value.periodRole !== 'string' ||
         !PERIOD_ROLES.has(value.periodRole) ||
-        !isFinancialBaselinePeriodV2(value.period) ||
+        !isFinancialDataflowPeriodV1(value.period) ||
         typeof value.costBasis !== 'string' ||
         !COST_BASES.has(value.costBasis) ||
         typeof value.estimateLens !== 'string' ||
@@ -411,7 +460,7 @@ const isCompositionIdentity = (value) => {
             value.amount.currencyCode === currency &&
             isReasonCodes(value.amount.reasonCodes) &&
             value.members.some(member => member.status === 'included') &&
-            value.members.some(member => member.status === 'unavailable'));
+            (value.members.some(member => member.status === 'unavailable') || value.amount.reasonCodes.includes('coverage-incomplete')));
     }
     const unresolvedCurrency = value.coordinate.accountingCurrency;
     return (value.amount.status === 'unavailable' &&
@@ -491,6 +540,9 @@ export const isCurrentSpendCompositionCompatibleV1 = (composition, baselines) =>
                 return false;
             }
             includedAmounts.push(baseline.total.amount);
+            if (baseline.status === 'available' && !isCompleteFinancialBaselinePeriodV2(baseline.period)) {
+                expectedReasonCodes.add('coverage-incomplete');
+            }
             continue;
         }
         if (baseline.status !== 'unavailable' || member.reasonCode !== baseline.unavailableReason)
@@ -514,7 +566,7 @@ export const isCurrentSpendCompositionCompatibleV1 = (composition, baselines) =>
     catch {
         return false;
     }
-    if (includedAmounts.length === composition.members.length) {
+    if (includedAmounts.length === composition.members.length && expectedReasonCodes.size === 0) {
         return composition.amount.status === 'available' && composition.amount.amount === includedTotal;
     }
     return (composition.amount.status === 'partial' &&

package/dist/esm/azure/financialEvidenceAssessmentValidation.js

@@ -12,6 +12,13 @@ const EVIDENCE_ROLES = new Set([
     'retail-rate',
     'commitment-quote',
     'fx-conversion',
+    'commercial-arrangement',
+    'provider-access-observation',
+    'configuration-timeline',
+    'provider-price-schedule',
+    'pricing-function',
+    'charge-inclusion-policy',
+    'settlement-revision',
     'eligibility-rule',
     'recommendation-scenario-set',
     'recommendation-lifecycle',

package/dist/esm/azure/financialPolicyDelivery.js

@@ -1,2 +1,6 @@
 export const FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1 = 'financial-policy-read-projection/v1';
 export const FINANCIAL_POLICY_ACTION_ATTEMPT_CONTRACT_VERSION_V1 = 'financial-policy-action-attempt/v1';
+export const FINANCIAL_POLICY_DEFINITION_COMMAND_CONTRACT_VERSION_V1 = 'financial-policy-definition-command/v1';
+export const FINANCIAL_POLICY_READ_CURRENT_POINTER_CONTRACT_VERSION_V1 = 'financial-policy-read-current-pointer/v1';
+export const FINANCIAL_POLICY_ACTION_COMPLETION_CONTRACT_VERSION_V1 = 'financial-policy-action-completion/v1';
+export const FINANCIAL_POLICY_READ_MANIFEST_CONTRACT_VERSION_V1 = 'financial-policy-read-manifest/v1';

package/dist/esm/azure/financialPolicyDeliveryValidation.js

@@ -1,12 +1,52 @@
 import { sha256Utf8 } from '../common/sha256.js';
 import { parseCanonicalDecimal } from '../common/exactDecimal.js';
 import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
-import { FINANCIAL_POLICY_ACTION_ATTEMPT_CONTRACT_VERSION_V1, FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1, } from './financialPolicyDelivery.js';
-import { canonicalizeFinancialDataflowJsonV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowRecordV1, } from './financialDataflowValidation.js';
-import { createFinancialPolicyEvaluationActionAuditIdV1, createFinancialPolicyEvaluationReadProjectionIdV1, isFinancialPolicyDefinitionRevisionV1, isFinancialPolicyEvaluationV1, } from './financialPolicyValidation.js';
+import { isFinancialAnalyticsProjectionV1 } from './financialAnalyticsValidation.js';
+import { FINANCIAL_POLICY_ACTION_ATTEMPT_CONTRACT_VERSION_V1, FINANCIAL_POLICY_ACTION_COMPLETION_CONTRACT_VERSION_V1, FINANCIAL_POLICY_DEFINITION_COMMAND_CONTRACT_VERSION_V1, FINANCIAL_POLICY_READ_CURRENT_POINTER_CONTRACT_VERSION_V1, FINANCIAL_POLICY_READ_MANIFEST_CONTRACT_VERSION_V1, FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1, } from './financialPolicyDelivery.js';
+import { canonicalizeFinancialDataflowJsonV1, hasFinancialDataflowExactFieldsV1, isFinancialDataflowHashV1, isFinancialDataflowIdentityV1, isFinancialDataflowIsoInstantV1, isFinancialDataflowJsonGzipArtifactDescriptorV1, isFinancialDataflowRecordV1, } from './financialDataflowValidation.js';
+import { createFinancialPolicyDefinitionRevisionIdV1, createFinancialPolicyEvaluationActionAuditIdV1, createFinancialPolicyEvaluationReadProjectionIdV1, isFinancialPolicyDefinitionRevisionIdentityPreimageV1, isFinancialPolicyDefinitionRevisionV1, isFinancialPolicyEvaluationV1, } from './financialPolicyValidation.js';
 const SIGNAL_KINDS = new Set(['budget-current-spend', 'budget-forecast', 'cost-anomaly']);
 const RESULTS = new Set(['matched', 'not-matched', 'partial', 'unavailable']);
 const ACTION_STATUSES = new Set(['succeeded', 'retryable-failure', 'terminal-failure']);
+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;
+};
+export const createFinancialPolicyDestinationsDigestV1 = (destinationRefIds) => `sha256:${sha256Utf8(canonicalizeFinancialDataflowJsonV1([...destinationRefIds].sort()))}`;
+export const isFinancialPolicyDefinitionCommandV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, ['schemaVersion', 'contractVersion', 'displayName', 'effectiveState', 'coordinateRequest', 'criteria', 'schedule', 'destinationRefIds'], ['expectedRevision']) ||
+        value.schemaVersion !== 1 ||
+        value.contractVersion !== FINANCIAL_POLICY_DEFINITION_COMMAND_CONTRACT_VERSION_V1 ||
+        (value.expectedRevision !== undefined && !isCanonicalPolicyRevision(value.expectedRevision)) ||
+        !isFinancialDataflowIdentityV1(value.displayName) ||
+        (value.effectiveState !== 'enabled' && value.effectiveState !== 'disabled') ||
+        !Array.isArray(value.destinationRefIds)) {
+        return false;
+    }
+    const identity = {
+        schemaVersion: 1,
+        contractVersion: 'financial-policy-definition/v1',
+        companyId: 'contract-company',
+        definitionId: 'contract-definition',
+        displayName: value.displayName,
+        revision: '1',
+        effectiveState: value.effectiveState,
+        coordinateRequest: value.coordinateRequest,
+        criteria: value.criteria,
+        schedule: value.schedule,
+        destinationRefIds: value.destinationRefIds,
+        destinationsDigest: createFinancialPolicyDestinationsDigestV1(value.destinationRefIds),
+        authoredAt: '2026-01-01T00:00:00.000Z',
+        authoredByUserId: 'contract-author',
+    };
+    if (!isFinancialPolicyDefinitionRevisionIdentityPreimageV1(identity))
+        return false;
+    const definition = { ...identity, policyDefinitionRevisionId: createFinancialPolicyDefinitionRevisionIdV1(identity) };
+    return isFinancialPolicyDefinitionRevisionV1(definition);
+};
 const isNonNegativeDecimal = (value) => {
     if (typeof value !== 'string' || !isCanonicalExactMoney({ amount: value, currencyCode: 'AUD' }))
         return false;
@@ -33,6 +73,7 @@ export const isFinancialPolicyEvaluationReadProjectionV1 = (value) => isFinancia
         'companyId',
         'definitionId',
         'definitionRevision',
+        'policyDefinitionRevisionId',
         'coordinateId',
         'currentSpendCompositionId',
         'signalKind',
@@ -40,7 +81,7 @@ export const isFinancialPolicyEvaluationReadProjectionV1 = (value) => isFinancia
         'result',
         'reasonCode',
         'matchedThresholds',
-    ], ['analyticsProjectionId']) &&
+    ], ['analyticsProjectionId', 'analyticsProjection']) &&
     value.schemaVersion === 1 &&
     value.contractVersion === FINANCIAL_POLICY_READ_PROJECTION_CONTRACT_VERSION_V1 &&
     isFinancialDataflowHashV1(value.evaluationId) &&
@@ -48,12 +89,24 @@ export const isFinancialPolicyEvaluationReadProjectionV1 = (value) => isFinancia
     isFinancialDataflowIdentityV1(value.companyId) &&
     isFinancialDataflowIdentityV1(value.definitionId) &&
     isFinancialDataflowIdentityV1(value.definitionRevision) &&
+    isFinancialDataflowHashV1(value.policyDefinitionRevisionId) &&
     isFinancialDataflowHashV1(value.coordinateId) &&
     isFinancialDataflowHashV1(value.currentSpendCompositionId) &&
     (value.analyticsProjectionId === undefined || isFinancialDataflowHashV1(value.analyticsProjectionId)) &&
+    (value.analyticsProjection === undefined || isFinancialAnalyticsProjectionV1(value.analyticsProjection)) &&
+    (value.analyticsProjectionId === undefined
+        ? value.analyticsProjection === undefined
+        : value.analyticsProjection?.analyticsProjectionId === value.analyticsProjectionId &&
+            value.analyticsProjection.currentSpendCompositionId === value.currentSpendCompositionId &&
+            value.analyticsProjection.coordinate.companyId === value.companyId &&
+            value.analyticsProjection.coordinate.periodRole === 'projection-target') &&
     typeof value.signalKind === 'string' &&
     SIGNAL_KINDS.has(value.signalKind) &&
-    (value.signalKind === 'budget-current-spend' ? value.analyticsProjectionId === undefined : value.analyticsProjectionId !== undefined) &&
+    (value.signalKind === 'budget-current-spend'
+        ? value.analyticsProjectionId === undefined
+        : value.result === 'unavailable'
+            ? value.analyticsProjectionId === undefined || isFinancialDataflowHashV1(value.analyticsProjectionId)
+            : value.analyticsProjectionId !== undefined) &&
     isFinancialDataflowIsoInstantV1(value.evaluatedAt) &&
     typeof value.result === 'string' &&
     RESULTS.has(value.result) &&
@@ -61,7 +114,7 @@ export const isFinancialPolicyEvaluationReadProjectionV1 = (value) => isFinancia
     isMatchedThresholds(value.matchedThresholds) &&
     Array.isArray(value.matchedThresholds) &&
     (value.result === 'matched' ? value.matchedThresholds.length > 0 : value.matchedThresholds.length === 0);
-export const isFinancialPolicyEvaluationReadProjectionCompatibleV1 = (projection, evaluation) => {
+export const isFinancialPolicyEvaluationReadProjectionCompatibleV1 = (projection, evaluation, analyticsProjection) => {
     if (!isFinancialPolicyEvaluationReadProjectionV1(projection) || !isFinancialPolicyEvaluationV1(evaluation))
         return false;
     const expected = {
@@ -72,17 +125,138 @@ export const isFinancialPolicyEvaluationReadProjectionCompatibleV1 = (projection
         companyId: evaluation.companyId,
         definitionId: evaluation.definitionId,
         definitionRevision: evaluation.definitionRevision,
+        policyDefinitionRevisionId: evaluation.policyDefinitionRevisionId,
         coordinateId: evaluation.coordinateId,
         currentSpendCompositionId: evaluation.currentSpendCompositionId,
         ...(evaluation.analyticsProjectionId === undefined ? {} : { analyticsProjectionId: evaluation.analyticsProjectionId }),
+        ...(analyticsProjection === undefined ? {} : { analyticsProjection }),
         signalKind: evaluation.signalKind,
         evaluatedAt: evaluation.evaluatedAt,
         result: evaluation.result,
         reasonCode: evaluation.reasonCode,
         matchedThresholds: evaluation.matchedThresholds,
     };
-    return canonicalizeFinancialDataflowJsonV1(projection) === canonicalizeFinancialDataflowJsonV1(expected);
+    return ((evaluation.analyticsProjectionId === undefined
+        ? analyticsProjection === undefined
+        : analyticsProjection?.analyticsProjectionId === evaluation.analyticsProjectionId) &&
+        canonicalizeFinancialDataflowJsonV1(projection) === canonicalizeFinancialDataflowJsonV1(expected));
+};
+export const canonicalizeFinancialPolicyEvaluationReadCurrentPointerIdentityV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'companyId',
+            'definitionId',
+            'signalKind',
+            'pointerRevision',
+            'definitionRevision',
+            'policyDefinitionRevisionId',
+            'evaluationId',
+            'readProjectionId',
+            'projectionArtifactDigest',
+            'evaluatedAt',
+            'promotedAt',
+        ]) ||
+        value.schemaVersion !== 1 ||
+        value.contractVersion !== FINANCIAL_POLICY_READ_CURRENT_POINTER_CONTRACT_VERSION_V1 ||
+        !isFinancialDataflowIdentityV1(value.companyId) ||
+        !isFinancialDataflowIdentityV1(value.definitionId) ||
+        typeof value.signalKind !== 'string' ||
+        !SIGNAL_KINDS.has(value.signalKind) ||
+        !Number.isSafeInteger(value.pointerRevision) ||
+        value.pointerRevision < 1 ||
+        !isFinancialDataflowIdentityV1(value.definitionRevision) ||
+        !isFinancialDataflowHashV1(value.policyDefinitionRevisionId) ||
+        !isFinancialDataflowHashV1(value.evaluationId) ||
+        value.readProjectionId !== createFinancialPolicyEvaluationReadProjectionIdV1(value.evaluationId) ||
+        !isFinancialDataflowHashV1(value.projectionArtifactDigest) ||
+        !isFinancialDataflowIsoInstantV1(value.evaluatedAt) ||
+        !isFinancialDataflowIsoInstantV1(value.promotedAt)) {
+        throw new TypeError('Invalid FinancialPolicyEvaluationReadCurrentPointerIdentityPreimageV1.');
+    }
+    return canonicalizeFinancialDataflowJsonV1(value);
+};
+export const createFinancialPolicyEvaluationReadCurrentPointerDigestV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialPolicyEvaluationReadCurrentPointerIdentityV1(value))}`;
+export const isFinancialPolicyEvaluationReadCurrentPointerV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) || !Object.prototype.hasOwnProperty.call(value, 'pointerDigest'))
+        return false;
+    const { pointerDigest, ...identity } = value;
+    try {
+        return (isFinancialDataflowHashV1(pointerDigest) &&
+            pointerDigest === createFinancialPolicyEvaluationReadCurrentPointerDigestV1(identity));
+    }
+    catch {
+        return false;
+    }
+};
+export const isFinancialPolicyEvaluationReadCurrentPointerCompatibleV1 = (pointer, projection, projectionArtifactDigest) => isFinancialPolicyEvaluationReadCurrentPointerV1(pointer) &&
+    isFinancialPolicyEvaluationReadProjectionV1(projection) &&
+    isFinancialDataflowHashV1(projectionArtifactDigest) &&
+    pointer.companyId === projection.companyId &&
+    pointer.definitionId === projection.definitionId &&
+    pointer.signalKind === projection.signalKind &&
+    pointer.definitionRevision === projection.definitionRevision &&
+    pointer.policyDefinitionRevisionId === projection.policyDefinitionRevisionId &&
+    pointer.evaluationId === projection.evaluationId &&
+    pointer.readProjectionId === projection.readProjectionId &&
+    pointer.projectionArtifactDigest === projectionArtifactDigest &&
+    pointer.evaluatedAt === projection.evaluatedAt;
+const isReadManifestIdentity = (value) => isFinancialDataflowRecordV1(value) &&
+    hasFinancialDataflowExactFieldsV1(value, [
+        'schemaVersion',
+        'contractVersion',
+        'companyId',
+        'definitionId',
+        'policyDefinitionRevisionId',
+        'definitionRevision',
+        'evaluationId',
+        'readProjectionId',
+        'signalKind',
+        'projection',
+        'publishedAt',
+    ]) &&
+    value.schemaVersion === 1 &&
+    value.contractVersion === FINANCIAL_POLICY_READ_MANIFEST_CONTRACT_VERSION_V1 &&
+    isFinancialDataflowIdentityV1(value.companyId) &&
+    isFinancialDataflowIdentityV1(value.definitionId) &&
+    isFinancialDataflowHashV1(value.policyDefinitionRevisionId) &&
+    isFinancialDataflowIdentityV1(value.definitionRevision) &&
+    isFinancialDataflowHashV1(value.evaluationId) &&
+    value.readProjectionId === createFinancialPolicyEvaluationReadProjectionIdV1(value.evaluationId) &&
+    typeof value.signalKind === 'string' &&
+    SIGNAL_KINDS.has(value.signalKind) &&
+    isFinancialDataflowJsonGzipArtifactDescriptorV1(value.projection) &&
+    isFinancialDataflowIsoInstantV1(value.publishedAt);
+export const createFinancialPolicyEvaluationReadManifestDigestV1 = (value) => {
+    if (!isReadManifestIdentity(value))
+        throw new TypeError('Invalid FinancialPolicyEvaluationReadManifestIdentityPreimageV1.');
+    return `sha256:${sha256Utf8(canonicalizeFinancialDataflowJsonV1(value))}`;
+};
+export const isFinancialPolicyEvaluationReadManifestV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) || !Object.prototype.hasOwnProperty.call(value, 'manifestDigest'))
+        return false;
+    const { manifestDigest, ...identity } = value;
+    try {
+        return (isFinancialDataflowHashV1(manifestDigest) &&
+            manifestDigest === createFinancialPolicyEvaluationReadManifestDigestV1(identity));
+    }
+    catch {
+        return false;
+    }
 };
+export const isFinancialPolicyEvaluationReadManifestCompatibleV1 = (manifest, projection, verifiedProjectionArtifactDigest) => isFinancialPolicyEvaluationReadManifestV1(manifest) &&
+    isFinancialPolicyEvaluationReadProjectionV1(projection) &&
+    isFinancialDataflowHashV1(verifiedProjectionArtifactDigest) &&
+    manifest.companyId === projection.companyId &&
+    manifest.definitionId === projection.definitionId &&
+    manifest.policyDefinitionRevisionId === projection.policyDefinitionRevisionId &&
+    manifest.definitionRevision === projection.definitionRevision &&
+    manifest.evaluationId === projection.evaluationId &&
+    manifest.readProjectionId === projection.readProjectionId &&
+    manifest.signalKind === projection.signalKind &&
+    manifest.publishedAt === projection.evaluatedAt &&
+    manifest.projection.sha256 === verifiedProjectionArtifactDigest;
 const isActionAttemptIdentity = (value) => isFinancialDataflowRecordV1(value) &&
     hasFinancialDataflowExactFieldsV1(value, [
         'schemaVersion',
@@ -135,3 +309,49 @@ export const isFinancialPolicyActionAttemptCompatibleV1 = (attempt, evaluation,
     Date.parse(attempt.attemptedAt) >= Date.parse(evaluation.evaluatedAt) &&
     evaluation.policyDefinitionRevisionId === definition.policyDefinitionRevisionId &&
     definition.destinationRefIds.includes(attempt.destinationRefId);
+export const canonicalizeFinancialPolicyActionCompletionIdentityV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) ||
+        !hasFinancialDataflowExactFieldsV1(value, [
+            'schemaVersion',
+            'contractVersion',
+            'actionAuditId',
+            'evaluationId',
+            'companyId',
+            'destinationRefId',
+            'completedAt',
+            'executorVersion',
+        ]) ||
+        value.schemaVersion !== 1 ||
+        value.contractVersion !== FINANCIAL_POLICY_ACTION_COMPLETION_CONTRACT_VERSION_V1 ||
+        !isFinancialDataflowHashV1(value.actionAuditId) ||
+        !isFinancialDataflowHashV1(value.evaluationId) ||
+        !isFinancialDataflowIdentityV1(value.companyId) ||
+        !isFinancialDataflowIdentityV1(value.destinationRefId) ||
+        !isFinancialDataflowIsoInstantV1(value.completedAt) ||
+        !isFinancialDataflowIdentityV1(value.executorVersion)) {
+        throw new TypeError('Invalid FinancialPolicyActionCompletionIdentityPreimageV1.');
+    }
+    return canonicalizeFinancialDataflowJsonV1(value);
+};
+export const createFinancialPolicyActionCompletionIdV1 = (value) => `sha256:${sha256Utf8(canonicalizeFinancialPolicyActionCompletionIdentityV1(value))}`;
+export const isFinancialPolicyActionCompletionV1 = (value) => {
+    if (!isFinancialDataflowRecordV1(value) || !Object.prototype.hasOwnProperty.call(value, 'completionId'))
+        return false;
+    const { completionId, ...identity } = value;
+    try {
+        return (isFinancialDataflowHashV1(completionId) &&
+            completionId === createFinancialPolicyActionCompletionIdV1(identity));
+    }
+    catch {
+        return false;
+    }
+};
+export const isFinancialPolicyActionCompletionCompatibleV1 = (completion, evaluation, definition) => isFinancialPolicyActionCompletionV1(completion) &&
+    isFinancialPolicyEvaluationV1(evaluation) &&
+    isFinancialPolicyDefinitionRevisionV1(definition) &&
+    completion.actionAuditId === evaluation.actionAuditId &&
+    completion.evaluationId === evaluation.evaluationId &&
+    completion.companyId === evaluation.companyId &&
+    completion.completedAt === evaluation.evaluatedAt &&
+    definition.companyId === completion.companyId &&
+    definition.destinationRefIds.includes(completion.destinationRefId);

package/dist/esm/azure/financialPolicyKernel.js

@@ -0,0 +1,225 @@
+import { formatExactDecimalValue, multiplyExactDecimalValues, parseCanonicalDecimal, subtractExactDecimalValues, } from '../common/exactDecimal.js';
+import { createFinancialDataflowCoordinateIdV1 } from './financialDataflowValidation.js';
+import { FINANCIAL_POLICY_EVALUATION_CONTRACT_VERSION_V1, } from './financialPolicy.js';
+import { createFinancialPolicyEvaluationActionAuditIdV1, createFinancialPolicyEvaluationIdV1, createFinancialPolicyEvaluationReadProjectionIdV1, isFinancialPolicyEvaluationCompatibleV1, } from './financialPolicyValidation.js';
+export const FINANCIAL_POLICY_ALGORITHM_VERSION_V1 = 'financial-policy/shared-v1';
+const compare = (left, right) => {
+    const difference = subtractExactDecimalValues(parseCanonicalDecimal(left), parseCanonicalDecimal(right)).coefficient;
+    return difference < 0n ? -1 : difference > 0n ? 1 : 0;
+};
+const percentageMatched = (amount, denominator, threshold) => {
+    const parsedDenominator = parseCanonicalDecimal(denominator);
+    if (parsedDenominator.coefficient <= 0n)
+        return false;
+    const left = multiplyExactDecimalValues(parseCanonicalDecimal(amount), parseCanonicalDecimal('100'));
+    const right = multiplyExactDecimalValues(parsedDenominator, parseCanonicalDecimal(threshold));
+    return subtractExactDecimalValues(left, right).coefficient >= 0n;
+};
+/**
+ * Shared exact-decimal display classification for Budget surfaces. This is a
+ * read-model policy only; alert matching continues to use the thresholds in a
+ * versioned Financial Policy Definition.
+ */
+export const classifyFinancialBudgetPositionV1 = (request) => {
+    if (request.budgetAmount === undefined)
+        return { status: 'unbudgeted' };
+    if (request.amount === undefined)
+        return { status: 'unavailable' };
+    try {
+        const atRiskPercent = request.atRiskPercent ?? '95';
+        const amount = parseCanonicalDecimal(request.amount);
+        const budget = parseCanonicalDecimal(request.budgetAmount);
+        const risk = parseCanonicalDecimal(atRiskPercent);
+        if (budget.coefficient <= 0n || risk.coefficient < 0n || compare(atRiskPercent, '100') > 0) {
+            return { status: 'unbudgeted' };
+        }
+        const varianceAmount = formatExactDecimalValue(subtractExactDecimalValues(amount, budget));
+        const status = compare(request.amount, request.budgetAmount) > 0
+            ? 'over-budget'
+            : percentageMatched(request.amount, request.budgetAmount, atRiskPercent)
+                ? 'at-risk'
+                : 'on-track';
+        return {
+            status,
+            varianceAmount,
+            amount: request.amount,
+            budgetAmount: request.budgetAmount,
+            atRiskPercent,
+        };
+    }
+    catch {
+        return { status: 'unavailable' };
+    }
+};
+const isExpectedCalendarMonthTargetPartial = (composition) => composition.coordinate.period.windowKind === 'calendar-month' &&
+    composition.amount.status === 'partial' &&
+    composition.amount.reasonCodes.length === 1 &&
+    composition.amount.reasonCodes[0] === 'coverage-incomplete';
+/**
+ * Returns the exact current amount that Budget semantics may compare. An open
+ * calendar month is intentionally partial until the period closes; every
+ * other partial/unavailable state remains non-comparable.
+ */
+export const selectFinancialBudgetComparableCurrentAmountV1 = (composition) => composition.amount.status === 'available'
+    ? composition.amount.amount
+    : isExpectedCalendarMonthTargetPartial(composition)
+        ? composition.amount.knownAmount
+        : undefined;
+const budgetThresholds = (amount, budget, thresholds) => [
+    ...thresholds.amounts
+        .filter(threshold => compare(amount, threshold) >= 0)
+        .map(configuredValue => ({ thresholdKind: 'amount', configuredValue })),
+    ...thresholds.percents
+        .filter(threshold => percentageMatched(amount, budget, threshold))
+        .map(configuredValue => ({ thresholdKind: 'percent', configuredValue })),
+];
+const anomalyThresholds = (definition, projection) => {
+    if (definition.criteria.kind !== 'cost-anomaly' || projection.status === 'unavailable' || projection.result.kind !== 'anomaly')
+        return [];
+    const configured = [
+        ...(definition.criteria.minimumAmount === undefined
+            ? []
+            : [{ thresholdKind: 'minimum-amount', configuredValue: definition.criteria.minimumAmount }]),
+        ...(definition.criteria.minimumDelta === undefined
+            ? []
+            : [{ thresholdKind: 'minimum-delta', configuredValue: definition.criteria.minimumDelta }]),
+        ...(definition.criteria.minimumPercentChange === undefined
+            ? []
+            : [{ thresholdKind: 'minimum-percent-change', configuredValue: definition.criteria.minimumPercentChange }]),
+    ];
+    return projection.result.events.some(event => configured.every(threshold => {
+        if (threshold.thresholdKind === 'minimum-amount')
+            return compare(event.observed.amount, threshold.configuredValue) >= 0;
+        if (threshold.thresholdKind === 'minimum-delta')
+            return compare(event.delta.amount, threshold.configuredValue) >= 0;
+        return percentageMatched(event.delta.amount, event.expected.amount, threshold.configuredValue);
+    }))
+        ? configured
+        : [];
+};
+const materialize = (identity, definition, currentSpend, analytics) => {
+    const evaluationId = createFinancialPolicyEvaluationIdV1(identity);
+    const evaluation = {
+        ...identity,
+        evaluationId,
+        readProjectionId: createFinancialPolicyEvaluationReadProjectionIdV1(evaluationId),
+        actionAuditId: createFinancialPolicyEvaluationActionAuditIdV1(evaluationId),
+    };
+    if (!isFinancialPolicyEvaluationCompatibleV1(evaluation, definition, currentSpend, analytics)) {
+        throw new TypeError('Financial policy evaluation does not bind its definition and exact financial inputs.');
+    }
+    return evaluation;
+};
+export const evaluateFinancialPolicyV1 = (request) => {
+    if (request.definition.effectiveState !== 'enabled')
+        return [];
+    const common = {
+        schemaVersion: 1,
+        contractVersion: FINANCIAL_POLICY_EVALUATION_CONTRACT_VERSION_V1,
+        companyId: request.definition.companyId,
+        policyDefinitionRevisionId: request.definition.policyDefinitionRevisionId,
+        definitionId: request.definition.definitionId,
+        definitionRevision: request.definition.revision,
+        coordinateId: createFinancialDataflowCoordinateIdV1(request.currentSpend.coordinate),
+        currentSpendCompositionId: request.currentSpend.compositionId,
+        evaluatedAt: request.evaluatedAt,
+        policyAlgorithmVersion: FINANCIAL_POLICY_ALGORITHM_VERSION_V1,
+    };
+    if (request.definition.criteria.kind === 'budget') {
+        const evaluations = [];
+        const currentThresholds = request.definition.criteria.currentSpendThresholds;
+        if (currentThresholds) {
+            const expectedOpenCalendarMonth = isExpectedCalendarMonthTargetPartial(request.currentSpend);
+            const comparableCurrentAmount = selectFinancialBudgetComparableCurrentAmountV1(request.currentSpend);
+            const matched = comparableCurrentAmount === undefined
+                ? []
+                : budgetThresholds(comparableCurrentAmount, request.definition.criteria.budget.amount, currentThresholds);
+            const unavailable = request.currentSpend.amount.status === 'unavailable';
+            const partial = request.currentSpend.amount.status === 'partial' && !expectedOpenCalendarMonth;
+            evaluations.push(materialize({
+                ...common,
+                signalKind: 'budget-current-spend',
+                result: unavailable ? 'unavailable' : partial ? 'partial' : matched.length > 0 ? 'matched' : 'not-matched',
+                reasonCode: unavailable
+                    ? 'current-spend-unavailable'
+                    : partial
+                        ? 'current-spend-partial'
+                        : expectedOpenCalendarMonth && matched.length > 0
+                            ? 'current-spend-threshold-matched-open-period'
+                            : expectedOpenCalendarMonth
+                                ? 'current-spend-threshold-not-matched-open-period'
+                                : matched.length > 0
+                                    ? 'current-spend-threshold-matched'
+                                    : 'current-spend-threshold-not-matched',
+                matchedThresholds: matched,
+            }, request.definition, request.currentSpend));
+        }
+        const forecastThresholds = request.definition.criteria.forecastThresholds;
+        if (forecastThresholds) {
+            const projection = request.analytics?.forecast;
+            if (!projection) {
+                evaluations.push(materialize({
+                    ...common,
+                    signalKind: 'budget-forecast',
+                    result: 'unavailable',
+                    reasonCode: 'analytics-projection-unavailable',
+                    matchedThresholds: [],
+                }, request.definition, request.currentSpend));
+            }
+            else {
+                const unavailable = projection.status === 'unavailable' || request.currentSpend.amount.status === 'unavailable';
+                const partial = projection.status === 'partial' ||
+                    (request.currentSpend.amount.status === 'partial' && !isExpectedCalendarMonthTargetPartial(request.currentSpend));
+                const matched = !unavailable && !partial && projection.result.kind === 'forecast'
+                    ? budgetThresholds(projection.result.projectedTotal.amount, request.definition.criteria.budget.amount, forecastThresholds)
+                    : [];
+                evaluations.push(materialize({
+                    ...common,
+                    analyticsProjectionId: projection.analyticsProjectionId,
+                    signalKind: 'budget-forecast',
+                    result: unavailable ? 'unavailable' : partial ? 'partial' : matched.length > 0 ? 'matched' : 'not-matched',
+                    reasonCode: unavailable
+                        ? 'forecast-unavailable'
+                        : partial
+                            ? 'forecast-partial'
+                            : matched.length > 0
+                                ? 'forecast-threshold-matched'
+                                : 'forecast-threshold-not-matched',
+                    matchedThresholds: matched,
+                }, request.definition, request.currentSpend, projection));
+            }
+        }
+        return evaluations;
+    }
+    const projection = request.analytics?.anomaly;
+    if (!projection) {
+        return [
+            materialize({
+                ...common,
+                signalKind: 'cost-anomaly',
+                result: 'unavailable',
+                reasonCode: 'analytics-projection-unavailable',
+                matchedThresholds: [],
+            }, request.definition, request.currentSpend),
+        ];
+    }
+    const unavailable = projection.status === 'unavailable' || request.currentSpend.amount.status === 'unavailable';
+    const partial = projection.status === 'partial' || request.currentSpend.amount.status === 'partial';
+    const matched = unavailable || partial ? [] : anomalyThresholds(request.definition, projection);
+    return [
+        materialize({
+            ...common,
+            analyticsProjectionId: projection.analyticsProjectionId,
+            signalKind: 'cost-anomaly',
+            result: unavailable ? 'unavailable' : partial ? 'partial' : matched.length > 0 ? 'matched' : 'not-matched',
+            reasonCode: unavailable
+                ? 'anomaly-unavailable'
+                : partial
+                    ? 'anomaly-partial'
+                    : matched.length > 0
+                        ? 'anomaly-threshold-matched'
+                        : 'anomaly-threshold-not-matched',
+            matchedThresholds: matched,
+        }, request.definition, request.currentSpend, projection),
+    ];
+};