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

package/dist/esm/azure/financialSavingsSurfaceProjectionKernel.js

@@ -0,0 +1,318 @@
+import { AZURE_BILLED_ALL_CHARGES_POLICY_V1 } from './financialChargeComposition.js';
+import { FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1, FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1, } from './financialSavingsSurfaceProjection.js';
+import { createFinancialSavingsSurfaceProjectionIdV1, isFinancialSavingsSurfaceProjectionV1, } from './financialSavingsSurfaceProjectionValidation.js';
+export class FinancialSavingsSurfaceProjectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FinancialSavingsSurfaceProjectionError';
+    }
+}
+const sameGeneration = (left, right) => Boolean(left && right && left.runId === right.runId && left.generatedAt === right.generatedAt);
+const exactMinorUnitSum = (values) => {
+    const sum = values.reduce((total, value) => total + BigInt(value), 0n);
+    if (sum > BigInt(Number.MAX_SAFE_INTEGER) || sum < BigInt(Number.MIN_SAFE_INTEGER)) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings surface contribution exceeds the safe integer boundary');
+    }
+    return Number(sum);
+};
+const projectLifecycleBindings = (allocations) => {
+    const byLifecycleIdentity = new Map();
+    for (const allocation of allocations) {
+        const key = `${allocation.ownerScopeId}\u0000${allocation.recommendationId}`;
+        const existing = byLifecycleIdentity.get(key);
+        if (existing) {
+            existing.allocationIds.push(allocation.allocationId);
+            continue;
+        }
+        byLifecycleIdentity.set(key, {
+            resourceId: allocation.ownerScopeId,
+            recommendationId: allocation.recommendationId,
+            allocationIds: [allocation.allocationId],
+        });
+    }
+    return [...byLifecycleIdentity.values()]
+        .map(binding => ({ ...binding, allocationIds: [...binding.allocationIds].sort() }))
+        .sort((left, right) => left.resourceId.localeCompare(right.resourceId) || left.recommendationId.localeCompare(right.recommendationId));
+};
+export const projectFinancialSavingsSurfaceQueryV1 = (source, recommendationIds, filterFingerprint) => {
+    if (!isFinancialSavingsSurfaceProjectionV1(source) || source.surface !== 'recommendations') {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings source projection is invalid for recommendation filtering');
+    }
+    const uniqueRecommendationIds = [...new Set(recommendationIds)];
+    if (uniqueRecommendationIds.length !== recommendationIds.length ||
+        uniqueRecommendationIds.some(id => !id.trim()) ||
+        !filterFingerprint.trim()) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings query identity is invalid');
+    }
+    const scope = {
+        kind: 'recommendation-query',
+        filterFingerprint,
+        recommendationIds: uniqueRecommendationIds,
+    };
+    const includedRecommendationIds = new Set(uniqueRecommendationIds);
+    const lifecycleBindings = source.lifecycleBindings
+        ?.filter(binding => includedRecommendationIds.has(binding.recommendationId))
+        .map(binding => ({ ...binding, allocationIds: [...binding.allocationIds] }));
+    const coordinates = source.coordinates.map((coordinate) => {
+        if (coordinate.status === 'unavailable')
+            return coordinate;
+        const recommendationContributions = coordinate.recommendationContributions.filter(contribution => includedRecommendationIds.has(contribution.recommendationId));
+        const filteredAmounts = {
+            recommendationContributions,
+            aggregate: {
+                allocationIds: recommendationContributions.flatMap(contribution => contribution.allocationIds),
+                savingsMinorUnits: exactMinorUnitSum(recommendationContributions.map(contribution => contribution.savingsMinorUnits)),
+            },
+        };
+        if (coordinate.status === 'available')
+            return { ...coordinate, ...filteredAmounts };
+        const { unavailableRecommendationIds: _sourceUnavailableRecommendationIds, ...common } = coordinate;
+        void _sourceUnavailableRecommendationIds;
+        const unavailableRecommendationIds = coordinate.unavailableRecommendationIds.filter(recommendationId => includedRecommendationIds.has(recommendationId));
+        return unavailableRecommendationIds.length > 0
+            ? {
+                ...common,
+                ...filteredAmounts,
+                status: 'partial',
+                unavailableRecommendationIds: unavailableRecommendationIds,
+            }
+            : { ...common, ...filteredAmounts, status: 'available' };
+    });
+    const identity = {
+        schemaVersion: source.schemaVersion,
+        contractVersion: source.contractVersion,
+        surface: source.surface,
+        scope,
+        provider: source.provider,
+        providerAccountRefs: source.providerAccountRefs,
+        artifactGeneration: source.artifactGeneration,
+        financialAuthorityId: source.financialAuthorityId,
+        savingsAuthorityId: source.savingsAuthorityId,
+        ...(lifecycleBindings?.length ? { lifecycleBindings: lifecycleBindings } : {}),
+        coordinates,
+    };
+    const projection = {
+        ...identity,
+        projectionId: createFinancialSavingsSurfaceProjectionIdV1(identity),
+    };
+    if (!isFinancialSavingsSurfaceProjectionV1(projection)) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings query projection failed validation');
+    }
+    return projection;
+};
+const projectRecommendationContributions = (allocations) => {
+    const byRecommendation = new Map();
+    for (const allocation of allocations) {
+        const existing = byRecommendation.get(allocation.recommendationId) ?? {
+            allocationIds: [],
+            savingsMinorUnits: [],
+            allocations: [],
+        };
+        existing.allocationIds.push(allocation.allocationId);
+        existing.savingsMinorUnits.push(allocation.savingsMinorUnits);
+        existing.allocations.push({ allocationId: allocation.allocationId, savingsMinorUnits: allocation.savingsMinorUnits });
+        byRecommendation.set(allocation.recommendationId, existing);
+    }
+    return Array.from(byRecommendation.entries())
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([recommendationId, contribution]) => ({
+        recommendationId,
+        allocationIds: [...contribution.allocationIds].sort(),
+        savingsMinorUnits: exactMinorUnitSum(contribution.savingsMinorUnits),
+        allocations: contribution.allocations
+            .sort((left, right) => left.allocationId.localeCompare(right.allocationId)),
+    }));
+};
+export const projectFinancialSavingsSurfaceResourceQueryV1 = (source, allocationIds, recommendationIds, filterFingerprint) => {
+    if (!isFinancialSavingsSurfaceProjectionV1(source) || source.surface !== 'resources') {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings source projection is invalid for resource filtering');
+    }
+    const uniqueAllocationIds = [...new Set(allocationIds)];
+    const uniqueRecommendationIds = [...new Set(recommendationIds)];
+    if (uniqueAllocationIds.length !== allocationIds.length ||
+        uniqueRecommendationIds.length !== recommendationIds.length ||
+        uniqueAllocationIds.some(id => !id.trim()) ||
+        uniqueRecommendationIds.some(id => !id.trim()) ||
+        !filterFingerprint.trim()) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings resource query identity is invalid');
+    }
+    const includedAllocationIds = new Set(uniqueAllocationIds);
+    const includedRecommendationIds = new Set(uniqueRecommendationIds);
+    const lifecycleBindings = source.lifecycleBindings
+        ?.map(binding => {
+        const filteredAllocationIds = binding.allocationIds.filter(allocationId => includedAllocationIds.has(allocationId));
+        return filteredAllocationIds.length
+            ? {
+                ...binding,
+                allocationIds: filteredAllocationIds,
+            }
+            : undefined;
+    })
+        .filter((binding) => binding !== undefined);
+    const scope = {
+        kind: 'resource-query',
+        filterFingerprint,
+        allocationIds: uniqueAllocationIds,
+        recommendationIds: uniqueRecommendationIds,
+    };
+    const coordinates = source.coordinates.map((coordinate) => {
+        if (coordinate.status === 'unavailable')
+            return coordinate;
+        const recommendationContributions = coordinate.recommendationContributions
+            .map(contribution => {
+            if (contribution.allocations === undefined) {
+                throw new FinancialSavingsSurfaceProjectionError('Financial savings resource query requires exact allocation contribution evidence');
+            }
+            const allocations = contribution.allocations.filter(allocation => includedAllocationIds.has(allocation.allocationId));
+            if (allocations.length === 0)
+                return undefined;
+            return {
+                recommendationId: contribution.recommendationId,
+                allocationIds: allocations.map(allocation => allocation.allocationId),
+                allocations: allocations,
+                savingsMinorUnits: exactMinorUnitSum(allocations.map(allocation => allocation.savingsMinorUnits)),
+            };
+        })
+            .filter((contribution) => contribution !== undefined);
+        const filteredAmounts = {
+            recommendationContributions,
+            aggregate: {
+                allocationIds: recommendationContributions.flatMap(contribution => contribution.allocationIds),
+                savingsMinorUnits: exactMinorUnitSum(recommendationContributions.map(contribution => contribution.savingsMinorUnits)),
+            },
+        };
+        if (coordinate.status === 'available')
+            return { ...coordinate, ...filteredAmounts };
+        const { unavailableRecommendationIds: _sourceUnavailableRecommendationIds, ...common } = coordinate;
+        void _sourceUnavailableRecommendationIds;
+        const unavailableRecommendationIds = coordinate.unavailableRecommendationIds.filter(id => includedRecommendationIds.has(id));
+        return unavailableRecommendationIds.length > 0
+            ? {
+                ...common,
+                ...filteredAmounts,
+                status: 'partial',
+                unavailableRecommendationIds: unavailableRecommendationIds,
+            }
+            : { ...common, ...filteredAmounts, status: 'available' };
+    });
+    const identity = {
+        schemaVersion: source.schemaVersion,
+        contractVersion: source.contractVersion,
+        surface: source.surface,
+        scope,
+        provider: source.provider,
+        providerAccountRefs: source.providerAccountRefs,
+        artifactGeneration: source.artifactGeneration,
+        financialAuthorityId: source.financialAuthorityId,
+        savingsAuthorityId: source.savingsAuthorityId,
+        ...(lifecycleBindings?.length ? { lifecycleBindings: lifecycleBindings } : {}),
+        coordinates,
+    };
+    const projection = { ...identity, projectionId: createFinancialSavingsSurfaceProjectionIdV1(identity) };
+    if (!isFinancialSavingsSurfaceProjectionV1(projection)) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings resource query projection failed validation');
+    }
+    return projection;
+};
+/**
+ * Projects a validated Resources authority into a compact, immutable surface.
+ * It partitions canonical allocation amounts for display and never recalculates
+ * scenario economics from legacy recommendation or resource fields.
+ */
+export const buildFinancialSavingsSurfaceProjectionV1 = (resourcesView, surface) => {
+    const authority = resourcesView.financialAuthority;
+    const savingsAuthority = resourcesView.financialSavingsAuthority;
+    if (!authority || !savingsAuthority)
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings authority is unavailable');
+    if (authority.authorityId !== savingsAuthority.financialAuthorityId ||
+        !sameGeneration(resourcesView.artifactGeneration, authority.artifactGeneration) ||
+        !sameGeneration(authority.artifactGeneration, savingsAuthority.artifactGeneration)) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings authority generation or identity binding is invalid');
+    }
+    const financialCoordinateById = new Map(authority.coordinates.map(coordinate => [coordinate.coordinateId, coordinate]));
+    const savingsCoordinateById = new Map(savingsAuthority.coordinates.map(coordinate => [coordinate.coordinateId, coordinate]));
+    if (financialCoordinateById.size !== authority.coordinates.length ||
+        savingsCoordinateById.size !== savingsAuthority.coordinates.length ||
+        financialCoordinateById.size !== savingsCoordinateById.size ||
+        Array.from(financialCoordinateById.keys()).some(coordinateId => !savingsCoordinateById.has(coordinateId))) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings coordinates are not one-to-one with financial authority coordinates');
+    }
+    const coordinates = authority.coordinates.map((financialCoordinate) => {
+        const savingsCoordinate = savingsCoordinateById.get(financialCoordinate.coordinateId);
+        if (!savingsCoordinate) {
+            throw new FinancialSavingsSurfaceProjectionError(`Financial savings coordinate ${financialCoordinate.coordinateId} is missing`);
+        }
+        const common = {
+            coordinateId: financialCoordinate.coordinateId,
+            periodRole: financialCoordinate.periodRole,
+            period: financialCoordinate.period,
+            costBasis: financialCoordinate.costBasis,
+            estimateLens: financialCoordinate.estimateLens,
+            chargeInclusionPolicyRef: AZURE_BILLED_ALL_CHARGES_POLICY_V1.policyRef,
+            ...(financialCoordinate.requestedCurrencyCode === undefined
+                ? {}
+                : { requestedCurrencyCode: financialCoordinate.requestedCurrencyCode }),
+            ...(savingsCoordinate.currentAggregateBaselineId === undefined
+                ? {}
+                : { currentAggregateBaselineId: savingsCoordinate.currentAggregateBaselineId }),
+        };
+        if (savingsCoordinate.status === 'unavailable') {
+            return { ...common, status: 'unavailable', unavailableReason: savingsCoordinate.unavailableReason };
+        }
+        const currentAggregate = financialCoordinate.aggregateBaseline;
+        if (currentAggregate.status !== 'available' ||
+            currentAggregate.baselineId !== savingsCoordinate.currentAggregateBaselineId ||
+            currentAggregate.total.currencyCode !== savingsCoordinate.accountingCurrencyCode) {
+            throw new FinancialSavingsSurfaceProjectionError(`Financial savings coordinate ${financialCoordinate.coordinateId} has no matching available current aggregate baseline`);
+        }
+        const unavailableRecommendationIds = savingsCoordinate.status === 'partial'
+            ? Array.from(new Set(savingsCoordinate.activations
+                .filter(activation => activation.result === 'unavailable')
+                .map(activation => activation.recommendationId))).sort()
+            : [];
+        const composed = {
+            ...common,
+            currentAggregateBaselineId: savingsCoordinate.currentAggregateBaselineId,
+            currentAggregate: { ...currentAggregate.total },
+            accountingCurrencyCode: savingsCoordinate.accountingCurrencyCode,
+            minorUnitScale: savingsCoordinate.minorUnitScale,
+            roundingMode: savingsCoordinate.roundingMode,
+            recommendationContributions: projectRecommendationContributions(savingsCoordinate.allocations),
+            aggregate: {
+                allocationIds: [...savingsCoordinate.aggregate.allocationIds],
+                savingsMinorUnits: savingsCoordinate.aggregate.savingsMinorUnits,
+            },
+        };
+        return savingsCoordinate.status === 'partial'
+            ? {
+                ...composed,
+                status: 'partial',
+                unavailableRecommendationIds: unavailableRecommendationIds,
+            }
+            : { ...composed, status: 'available' };
+    });
+    const lifecycleBindings = projectLifecycleBindings(savingsAuthority.coordinates.flatMap(coordinate => (coordinate.status === 'unavailable' ? [] : coordinate.allocations)));
+    const identity = {
+        schemaVersion: FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1,
+        contractVersion: FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1,
+        surface,
+        scope: { kind: 'subscription-full' },
+        provider: 'azure',
+        providerAccountRefs: [...authority.providerAccountRefs],
+        artifactGeneration: { ...authority.artifactGeneration },
+        financialAuthorityId: authority.authorityId,
+        savingsAuthorityId: savingsAuthority.savingsAuthorityId,
+        ...(lifecycleBindings.length
+            ? { lifecycleBindings: lifecycleBindings }
+            : {}),
+        coordinates,
+    };
+    const projection = {
+        ...identity,
+        projectionId: createFinancialSavingsSurfaceProjectionIdV1(identity),
+    };
+    if (!isFinancialSavingsSurfaceProjectionV1(projection)) {
+        throw new FinancialSavingsSurfaceProjectionError('Financial savings surface projection failed validation');
+    }
+    return projection;
+};

package/dist/esm/azure/financialSavingsSurfaceProjectionValidation.js

@@ -2,6 +2,7 @@ import { sha256Utf8 } from '../common/sha256.js';
 import { canonicalizeFinancialSavingsJsonValue, hasExactFinancialSavingsFields, haveSameFinancialSavingsSet, isFinancialSavingsHash, isFinancialSavingsIdentity, isFinancialSavingsIsoInstant, isFinancialSavingsMinorUnits, isFinancialSavingsRecord, sumFinancialSavingsMinorUnits, } from './financialSavingsAuthorityValidationPrimitives.js';
 import { FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1, FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1, } from './financialSavingsSurfaceProjection.js';
 import { isFinancialBaselinePeriodV2 } from './financialScopeBaselineValidation.js';
+import { isFinancialChargeInclusionPolicyRefV1 } from './financialChargeCompositionValidation.js';
 import { isCanonicalExactMoney } from './financialValidationPrimitives.js';
 const COST_BASES = new Set(['billed', 'amortized']);
 const ESTIMATE_LENSES = new Set(['actual-only', 'actual-plus-estimated', 'estimates-only']);
@@ -18,7 +19,22 @@ const MAX_ALLOCATIONS = 20000;
 export const canonicalizeFinancialSavingsSurfaceProjectionIdentityV1 = (value) => JSON.stringify(canonicalizeFinancialSavingsJsonValue({
     ...value,
     providerAccountRefs: [...value.providerAccountRefs].sort(),
-    scope: value.scope.kind === 'subscription-full' ? value.scope : { ...value.scope, recommendationIds: [...value.scope.recommendationIds].sort() },
+    ...(value.lifecycleBindings === undefined
+        ? {}
+        : {
+            lifecycleBindings: [...value.lifecycleBindings]
+                .sort((left, right) => left.resourceId.localeCompare(right.resourceId) || left.recommendationId.localeCompare(right.recommendationId))
+                .map(binding => ({ ...binding, allocationIds: [...binding.allocationIds].sort() })),
+        }),
+    scope: value.scope.kind === 'subscription-full'
+        ? value.scope
+        : value.scope.kind === 'recommendation-query'
+            ? { ...value.scope, recommendationIds: [...value.scope.recommendationIds].sort() }
+            : {
+                ...value.scope,
+                allocationIds: [...value.scope.allocationIds].sort(),
+                recommendationIds: [...value.scope.recommendationIds].sort(),
+            },
     coordinates: [...value.coordinates]
         .sort((left, right) => left.coordinateId.localeCompare(right.coordinateId))
         .map(coordinate => coordinate.status === 'unavailable'
@@ -27,7 +43,15 @@ export const canonicalizeFinancialSavingsSurfaceProjectionIdentityV1 = (value) =
             ...coordinate,
             recommendationContributions: [...coordinate.recommendationContributions]
                 .sort((left, right) => left.recommendationId.localeCompare(right.recommendationId))
-                .map(contribution => ({ ...contribution, allocationIds: [...contribution.allocationIds].sort() })),
+                .map(contribution => ({
+                ...contribution,
+                allocationIds: [...contribution.allocationIds].sort(),
+                ...(contribution.allocations === undefined
+                    ? {}
+                    : {
+                        allocations: [...contribution.allocations].sort((left, right) => left.allocationId.localeCompare(right.allocationId)),
+                    }),
+            })),
             aggregate: { ...coordinate.aggregate, allocationIds: [...coordinate.aggregate.allocationIds].sort() },
         }),
 }));
@@ -38,12 +62,24 @@ const isScope = (value) => {
         return false;
     if (value.kind === 'subscription-full')
         return hasExactFinancialSavingsFields(value, ['kind']);
-    return (value.kind === 'recommendation-query' &&
+    if (value.kind === 'recommendation-query' &&
         hasExactFinancialSavingsFields(value, ['kind', 'filterFingerprint', 'recommendationIds']) &&
         isFinancialSavingsHash(value.filterFingerprint) &&
         Array.isArray(value.recommendationIds) &&
         value.recommendationIds.length <= MAX_ALLOCATIONS &&
         value.recommendationIds.every(isFinancialSavingsIdentity) &&
+        new Set(value.recommendationIds).size === value.recommendationIds.length)
+        return true;
+    return (value.kind === 'resource-query' &&
+        hasExactFinancialSavingsFields(value, ['kind', 'filterFingerprint', 'allocationIds', 'recommendationIds']) &&
+        isFinancialSavingsHash(value.filterFingerprint) &&
+        Array.isArray(value.allocationIds) &&
+        value.allocationIds.length <= MAX_ALLOCATIONS &&
+        value.allocationIds.every(isFinancialSavingsHash) &&
+        new Set(value.allocationIds).size === value.allocationIds.length &&
+        Array.isArray(value.recommendationIds) &&
+        value.recommendationIds.length <= MAX_ALLOCATIONS &&
+        value.recommendationIds.every(isFinancialSavingsIdentity) &&
         new Set(value.recommendationIds).size === value.recommendationIds.length);
 };
 const isCoordinateCommon = (value) => isFinancialSavingsHash(value.coordinateId) &&
@@ -53,9 +89,20 @@ const isCoordinateCommon = (value) => isFinancialSavingsHash(value.coordinateId)
     COST_BASES.has(value.costBasis) &&
     typeof value.estimateLens === 'string' &&
     ESTIMATE_LENSES.has(value.estimateLens) &&
+    isFinancialChargeInclusionPolicyRefV1(value.chargeInclusionPolicyRef) &&
     (value.requestedCurrencyCode === undefined || isCurrency(value.requestedCurrencyCode)) &&
     (value.currentAggregateBaselineId === undefined || isFinancialSavingsHash(value.currentAggregateBaselineId));
-const isAvailableCoordinate = (value, queryRecommendationIds) => {
+const isLifecycleBinding = (value) => isFinancialSavingsRecord(value) &&
+    hasExactFinancialSavingsFields(value, ['resourceId', 'recommendationId', 'allocationIds']) &&
+    isFinancialSavingsIdentity(value.resourceId) &&
+    isFinancialSavingsIdentity(value.recommendationId) &&
+    Array.isArray(value.allocationIds) &&
+    value.allocationIds.length > 0 &&
+    value.allocationIds.length <= MAX_ALLOCATIONS &&
+    value.allocationIds.every(isFinancialSavingsHash) &&
+    new Set(value.allocationIds).size === value.allocationIds.length;
+const isComposedCoordinate = (value, queryRecommendationIds, queryAllocationIds) => {
+    const partial = value.status === 'partial';
     if (!hasExactFinancialSavingsFields(value, [
         'status',
         'coordinateId',
@@ -63,6 +110,7 @@ const isAvailableCoordinate = (value, queryRecommendationIds) => {
         'period',
         'costBasis',
         'estimateLens',
+        'chargeInclusionPolicyRef',
         'currentAggregateBaselineId',
         'currentAggregate',
         'accountingCurrencyCode',
@@ -70,6 +118,7 @@ const isAvailableCoordinate = (value, queryRecommendationIds) => {
         'roundingMode',
         'recommendationContributions',
         'aggregate',
+        ...(partial ? ['unavailableRecommendationIds'] : []),
     ], ['requestedCurrencyCode']) ||
         !isCoordinateCommon(value) ||
         !isFinancialSavingsHash(value.currentAggregateBaselineId) ||
@@ -90,12 +139,20 @@ const isAvailableCoordinate = (value, queryRecommendationIds) => {
         new Set(value.aggregate.allocationIds).size !== value.aggregate.allocationIds.length ||
         !isFinancialSavingsMinorUnits(value.aggregate.savingsMinorUnits))
         return false;
+    if (partial &&
+        (!Array.isArray(value.unavailableRecommendationIds) ||
+            value.unavailableRecommendationIds.length === 0 ||
+            value.unavailableRecommendationIds.length > MAX_ALLOCATIONS ||
+            !value.unavailableRecommendationIds.every(isFinancialSavingsIdentity) ||
+            new Set(value.unavailableRecommendationIds).size !== value.unavailableRecommendationIds.length ||
+            (queryRecommendationIds !== undefined && value.unavailableRecommendationIds.some(id => !queryRecommendationIds.has(id)))))
+        return false;
     const recommendationIds = new Set();
     const allocationIds = [];
     const contributionAmounts = [];
     for (const contribution of value.recommendationContributions) {
         if (!isFinancialSavingsRecord(contribution) ||
-            !hasExactFinancialSavingsFields(contribution, ['recommendationId', 'allocationIds', 'savingsMinorUnits']) ||
+            !hasExactFinancialSavingsFields(contribution, ['recommendationId', 'allocationIds', 'savingsMinorUnits'], ['allocations']) ||
             !isFinancialSavingsIdentity(contribution.recommendationId) ||
             recommendationIds.has(contribution.recommendationId) ||
             (queryRecommendationIds !== undefined && !queryRecommendationIds.has(contribution.recommendationId)) ||
@@ -104,7 +161,33 @@ const isAvailableCoordinate = (value, queryRecommendationIds) => {
             contribution.allocationIds.length > MAX_ALLOCATIONS ||
             !contribution.allocationIds.every(isFinancialSavingsHash) ||
             new Set(contribution.allocationIds).size !== contribution.allocationIds.length ||
-            !isFinancialSavingsMinorUnits(contribution.savingsMinorUnits))
+            !isFinancialSavingsMinorUnits(contribution.savingsMinorUnits) ||
+            (queryAllocationIds !== undefined && !Array.isArray(contribution.allocations)) ||
+            (contribution.allocations !== undefined &&
+                (!Array.isArray(contribution.allocations) || contribution.allocations.length !== contribution.allocationIds.length)))
+            return false;
+        const exactAllocations = contribution.allocations;
+        if (exactAllocations === undefined) {
+            recommendationIds.add(contribution.recommendationId);
+            allocationIds.push(...contribution.allocationIds);
+            contributionAmounts.push(contribution.savingsMinorUnits);
+            continue;
+        }
+        const exactAllocationIds = [];
+        const exactAllocationAmounts = [];
+        for (const allocation of exactAllocations) {
+            if (!isFinancialSavingsRecord(allocation) ||
+                !hasExactFinancialSavingsFields(allocation, ['allocationId', 'savingsMinorUnits']) ||
+                !isFinancialSavingsHash(allocation.allocationId) ||
+                (queryAllocationIds !== undefined && !queryAllocationIds.has(allocation.allocationId)) ||
+                !isFinancialSavingsMinorUnits(allocation.savingsMinorUnits))
+                return false;
+            exactAllocationIds.push(allocation.allocationId);
+            exactAllocationAmounts.push(allocation.savingsMinorUnits);
+        }
+        if (new Set(exactAllocationIds).size !== exactAllocationIds.length ||
+            !haveSameFinancialSavingsSet(exactAllocationIds, contribution.allocationIds) ||
+            sumFinancialSavingsMinorUnits(exactAllocationAmounts) !== contribution.savingsMinorUnits)
             return false;
         recommendationIds.add(contribution.recommendationId);
         allocationIds.push(...contribution.allocationIds);
@@ -114,7 +197,7 @@ const isAvailableCoordinate = (value, queryRecommendationIds) => {
         haveSameFinancialSavingsSet(allocationIds, value.aggregate.allocationIds) &&
         sumFinancialSavingsMinorUnits(contributionAmounts) === value.aggregate.savingsMinorUnits);
 };
-const isUnavailableCoordinate = (value) => hasExactFinancialSavingsFields(value, ['status', 'coordinateId', 'periodRole', 'period', 'costBasis', 'estimateLens', 'unavailableReason'], ['requestedCurrencyCode', 'currentAggregateBaselineId']) &&
+const isUnavailableCoordinate = (value) => hasExactFinancialSavingsFields(value, ['status', 'coordinateId', 'periodRole', 'period', 'costBasis', 'estimateLens', 'chargeInclusionPolicyRef', 'unavailableReason'], ['requestedCurrencyCode', 'currentAggregateBaselineId']) &&
     isCoordinateCommon(value) &&
     typeof value.unavailableReason === 'string' &&
     UNAVAILABLE_REASONS.has(value.unavailableReason);
@@ -132,13 +215,15 @@ export const isFinancialSavingsSurfaceProjectionV1 = (value) => {
             'financialAuthorityId',
             'savingsAuthorityId',
             'coordinates',
-        ]) ||
+        ], ['lifecycleBindings']) ||
         value.schemaVersion !== FINANCIAL_SAVINGS_SURFACE_PROJECTION_SCHEMA_VERSION_V1 ||
         value.contractVersion !== FINANCIAL_SAVINGS_SURFACE_PROJECTION_CONTRACT_VERSION_V1 ||
         !isFinancialSavingsHash(value.projectionId) ||
-        (value.surface !== 'recommendations' && value.surface !== 'dashboard') ||
+        (value.surface !== 'recommendations' && value.surface !== 'resources' && value.surface !== 'dashboard') ||
         !isScope(value.scope) ||
         (value.surface === 'dashboard' && value.scope.kind !== 'subscription-full') ||
+        (value.surface === 'recommendations' && value.scope.kind === 'resource-query') ||
+        (value.surface === 'resources' && value.scope.kind === 'recommendation-query') ||
         value.provider !== 'azure' ||
         !Array.isArray(value.providerAccountRefs) ||
         value.providerAccountRefs.length === 0 ||
@@ -151,21 +236,50 @@ export const isFinancialSavingsSurfaceProjectionV1 = (value) => {
         !isFinancialSavingsIsoInstant(value.artifactGeneration.generatedAt) ||
         !isFinancialSavingsHash(value.financialAuthorityId) ||
         !isFinancialSavingsHash(value.savingsAuthorityId) ||
+        (value.lifecycleBindings !== undefined &&
+            (!Array.isArray(value.lifecycleBindings) ||
+                value.lifecycleBindings.length === 0 ||
+                value.lifecycleBindings.length > MAX_ALLOCATIONS ||
+                !value.lifecycleBindings.every(isLifecycleBinding))) ||
         !Array.isArray(value.coordinates) ||
         value.coordinates.length === 0 ||
         value.coordinates.length > MAX_COORDINATES)
         return false;
     const projection = value;
-    const queryRecommendationIds = projection.scope.kind === 'recommendation-query' ? new Set(projection.scope.recommendationIds) : undefined;
+    const queryRecommendationIds = projection.scope.kind === 'recommendation-query' || projection.scope.kind === 'resource-query'
+        ? new Set(projection.scope.recommendationIds)
+        : undefined;
+    const queryAllocationIds = projection.scope.kind === 'resource-query' ? new Set(projection.scope.allocationIds) : undefined;
     if (!projection.coordinates.every(coordinate => {
         if (!isFinancialSavingsRecord(coordinate))
             return false;
-        return coordinate.status === 'available'
-            ? isAvailableCoordinate(coordinate, queryRecommendationIds)
+        return coordinate.status === 'available' || coordinate.status === 'partial'
+            ? isComposedCoordinate(coordinate, queryRecommendationIds, queryAllocationIds)
             : coordinate.status === 'unavailable' && isUnavailableCoordinate(coordinate);
     }) ||
         new Set(projection.coordinates.map(coordinate => coordinate.coordinateId)).size !== projection.coordinates.length)
         return false;
+    if (projection.lifecycleBindings !== undefined) {
+        const lifecycleKeys = projection.lifecycleBindings.map(binding => `${binding.resourceId}\u0000${binding.recommendationId}`);
+        const boundAllocationIds = projection.lifecycleBindings.flatMap(binding => binding.allocationIds);
+        const projectedAllocationOwners = new Map();
+        for (const coordinate of projection.coordinates) {
+            if (coordinate.status === 'unavailable')
+                continue;
+            for (const contribution of coordinate.recommendationContributions) {
+                for (const allocationId of contribution.allocationIds) {
+                    if (projectedAllocationOwners.has(allocationId))
+                        return false;
+                    projectedAllocationOwners.set(allocationId, contribution.recommendationId);
+                }
+            }
+        }
+        if (new Set(lifecycleKeys).size !== lifecycleKeys.length ||
+            new Set(boundAllocationIds).size !== boundAllocationIds.length ||
+            boundAllocationIds.length !== projectedAllocationOwners.size ||
+            projection.lifecycleBindings.some(binding => binding.allocationIds.some(allocationId => projectedAllocationOwners.get(allocationId) !== binding.recommendationId)))
+            return false;
+    }
     const { projectionId: _projectionId, ...identity } = projection;
     return projection.projectionId === createFinancialSavingsSurfaceProjectionIdV1(identity);
 };

package/dist/esm/azure/financialScope.js

@@ -2,6 +2,9 @@ export * from './financialScopeEvidence.js';
 export * from './financialScopeBaseline.js';
 export * from './financialScopeBaselineIdentity.js';
 export * from './financialScopeBaselineValidation.js';
+export * from './financialChargeComposition.js';
+export * from './financialChargeCompositionValidation.js';
+export * from './financialChargeCompositionKernel.js';
 export * from './financialEvidenceAssessmentValidation.js';
 export * from './financialProjection.js';
 export * from './financialProjectionValidation.js';
@@ -9,15 +12,18 @@ export * from './financialDisplayRollup.js';
 export * from './financialDisplayRollupValidation.js';
 export * from './financialAuthorityView.js';
 export * from './financialAuthorityViewValidation.js';
+export * from './financialAuthorityProjectionKernel.js';
 export * from './financialSavingsAuthority.js';
 export * from './financialSavingsAuthorityValidation.js';
 export * from './financialSavingsSurfaceProjection.js';
 export * from './financialSavingsSurfaceProjectionValidation.js';
+export * from './financialSavingsSurfaceProjectionKernel.js';
 export * from './financialDataflow.js';
 export * from './financialDataflowValidation.js';
 export * from './financialDataflowKernel.js';
 export * from './financialAnalytics.js';
 export * from './financialAnalyticsValidation.js';
+export * from './financialAnalyticsDisplayKernel.js';
 export * from './financialAnalyticsDelivery.js';
 export * from './financialAnalyticsDeliveryValidation.js';
 export * from './financialPolicy.js';

package/dist/esm/azure/governance.js

@@ -6,6 +6,7 @@ export const TENANT_GOVERNANCE_GRAPH_SCHEMA_VERSION = '2026-05-02.tenant-graph-v
 export const GLOBAL_ADMIN_RAW_SCHEMA_VERSION = '2026-06-24.global-admin-raw-v1';
 export const PRIVILEGED_ROLE_SUMMARY_SCHEMA_VERSION = '2026-06-24.privileged-role-summary-v1';
 export const TENANT_GOVERNANCE_ACCESS_SCHEMA_VERSION = '2026-06-24.tenant-governance-access-v1';
+export const TENANT_MFA_POSTURE_SCHEMA_VERSION = '2026-08-25.tenant-mfa-posture-v1';
 export const GOVERNANCE_REPORT_PORTAL_FILE = 'governance.json.gz';
 export const GOVERNANCE_GRAPH_PORTAL_FILE = 'governance-graph.json.gz';
 export const GOVERNANCE_ACCESS_PORTAL_FILE = 'governance-access.json.gz';

package/dist/esm/azure/vmPatchManagement.js

@@ -0,0 +1,3 @@
+export const VM_PATCH_MANAGEMENT_SCHEMA_VERSION = 1;
+export const PATCH_MANAGEMENT_PORTAL_FILE_NAME = 'patch-management.json.gz';
+export const AZURE_VM_PATCH_MANAGEMENT_RESOURCE_TYPE = 'microsoft.compute/virtualmachines';

package/dist/esm/entries/commitments-planning.js

@@ -1,3 +1,3 @@
-export * from '../aws/commitmentsPlanningValidation.js';
-import * as namespace from '../aws/commitmentsPlanningValidation.js';
+export * from '../aws/commitments-planning.js';
+import * as namespace from '../aws/commitments-planning.js';
 export default namespace;

package/dist/esm/entries/environment.js

@@ -0,0 +1,3 @@
+export * from '../environment/index.js';
+import * as namespace from '../environment/index.js';
+export default namespace;

package/dist/esm/environment/canonicalization.js

@@ -0,0 +1,34 @@
+import { isEnvironmentDocumentDescriptorSetV1, isEnvironmentScopeV1 } from './validation.js';
+const compareUnicodeCodePoints = (left, right) => {
+    const leftPoints = Array.from(left, character => character.codePointAt(0));
+    const rightPoints = Array.from(right, character => character.codePointAt(0));
+    const length = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = leftPoints[index] - rightPoints[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return leftPoints.length - rightPoints.length;
+};
+/**
+ * Builds the canonical scope-qualified artifact subject used inside opaque
+ * logical references. The JSON tuple is an identifier, never a storage path.
+ */
+export const buildEnvironmentScopeQualifiedSubjectV1 = (scope) => {
+    if (!isEnvironmentScopeV1(scope))
+        throw new TypeError('Invalid V1 environment scope.');
+    return JSON.stringify([scope.kind, scope.tenantId, scope.companyId, scope.subscriptionId]);
+};
+/**
+ * Produces the exact compact UTF-8 tree-digest preimage. Hashing remains the
+ * caller's responsibility so this helper stays browser-safe.
+ */
+export const buildEnvironmentTreeDigestPreimageV1 = (descriptors) => {
+    if (!isEnvironmentDocumentDescriptorSetV1(descriptors)) {
+        throw new TypeError('V1 environment tree digests require each allowlisted document exactly once.');
+    }
+    const pairs = descriptors
+        .map(descriptor => [descriptor.name, descriptor.contentSha256])
+        .sort((left, right) => compareUnicodeCodePoints(left[0], right[0]));
+    return JSON.stringify(pairs);
+};