@spottoai/types-package 1.0.2-beta.360 → 1.0.2-beta.361

package/dist/esm/azure/billingArtifactGeneration.js

@@ -1,11 +1,34 @@
 import { isArtifactOwnershipBinding, isEnforceableArtifactOwnershipBinding, } from '../common/artifactEvidence.js';
 import { isArtifactRevisionVector, isStrictLogicalArtifactReference } from '../common/artifactEvidenceValidation.js';
-import { allowedArtifactIdentityField, allowedArtifactReferenceField, containsForbiddenArtifactControlData, } from '../common/artifactControlData.js';
+import { ARTIFACT_CONTROL_DATA_MAX_VISITED_NODES, allowedArtifactIdentityField, allowedArtifactReferenceField, allowedArtifactTraversalField, containsForbiddenArtifactControlData, } from '../common/artifactControlData.js';
 import { isBillingCompletedArtifactPublicationDecision } from './billingArtifactEvidence.js';
+import { BILLING_ARTIFACT_OBJECT_LIMITS_V1 } from './billingArtifactLimits.js';
+/** Stable diagnostic-only suffix for the latest successfully enqueued observe input. */
+export const BILLING_ANALYZER_INPUT_OBSERVATION_POINTER_RELATIVE_PATH = 'history/billing/analyzer-inputs/latest-enqueued.json';
 const BILLING_BASES = new Set(['actual', 'amortized']);
 const COVERAGE_VERDICTS = new Set(['complete', 'partial', 'none', 'unknown']);
 const DATE_BASES = new Set(['utc', 'billing-calendar', 'company-local']);
 const CONTENT_ENCODINGS = new Set(['identity', 'gzip']);
+const OBSERVATION_COMPARISONS = new Set([
+    'authority-absent',
+    'newer',
+    'equal',
+    'older',
+    'incomparable',
+    'newer-ownership',
+    'older-ownership',
+    'unenforceable',
+]);
+const OBSERVATION_PROJECTED_OUTCOMES = new Map([
+    ['authority-absent', 'would-promote'],
+    ['newer', 'would-promote'],
+    ['newer-ownership', 'would-promote'],
+    ['equal', 'would-be-idempotent'],
+    ['older', 'would-be-superseded'],
+    ['older-ownership', 'would-be-superseded'],
+    ['incomparable', 'would-quarantine'],
+    ['unenforceable', 'not-enforceable'],
+]);
 const SHA256_PATTERN = /^[a-f0-9]{64}$/;
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const isNonEmptyString = (value) => typeof value === 'string' && value.trim() === value && value.length > 0;
@@ -25,7 +48,23 @@ const isCanonicalIsoTimestamp = (value) => {
 };
 const hasControlCharacters = (value) => Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
 const allowedDescriptorPaths = (descriptors) => Array.isArray(descriptors) ? descriptors.flatMap(descriptor => allowedArtifactReferenceField(descriptor, 'path')) : [];
+const containsForbiddenBillingArtifactControlData = (value, allowedReferenceFields = []) => containsForbiddenArtifactControlData(value, allowedReferenceFields, {
+    requireAllowedFieldTraversalContext: true,
+});
 const isPathSegment = (value) => isNonEmptyString(value) && !/[\\/?#%]/.test(value) && !hasControlCharacters(value) && value !== '.' && value !== '..';
+/** Builds the diagnostic-only latest-enqueued observation path for one safe subscription segment. */
+export const buildBillingAnalyzerInputObservationPointerPath = (subscriptionId) => {
+    if (!isPathSegment(subscriptionId))
+        throw new TypeError('subscriptionId must be a safe path segment');
+    return `subscriptions/${subscriptionId}/${BILLING_ANALYZER_INPUT_OBSERVATION_POINTER_RELATIVE_PATH}`;
+};
+/** Validates the exact diagnostic-only latest-enqueued observation logical path. */
+export const isBillingAnalyzerInputObservationPointerPath = (value) => {
+    if (!isStrictLogicalArtifactReference(value))
+        return false;
+    const match = /^subscriptions\/([^/]+)\/history\/billing\/analyzer-inputs\/latest-enqueued\.json$/.exec(value);
+    return match !== null && isPathSegment(match[1]);
+};
 const inputGenerationPrefix = (subscriptionId, generationId) => `subscriptions/${subscriptionId}/history/billing/analyzer-inputs/generations/${generationId}/`;
 const inputManifestPath = (subscriptionId, generationId) => `${inputGenerationPrefix(subscriptionId, generationId)}manifest.json`;
 const outputGenerationPrefix = (subscriptionId, generationId) => `subscriptions/${subscriptionId}/billing/generations/${generationId}/`;
@@ -45,6 +84,9 @@ const hasMatchingIdentity = (subscriptionId, generationId, ownership, revision,
     return !enforceable || isEnforceableArtifactOwnershipBinding(ownership);
 };
 const isSha256 = (value) => typeof value === 'string' && SHA256_PATTERN.test(value);
+const hasDiagnosticObservationDiscriminant = (value) => value.authority === 'diagnostic-only' ||
+    (value.publicationMode === 'observe' &&
+        (value.documentType === 'billing-analyzer-input-observation-pointer' || value.documentType === 'billing-analysis-promotion-observation'));
 const isRequestedPeriod = (value) => {
     if (!isRecord(value) ||
         !isCanonicalIsoTimestamp(value.fromInclusive) ||
@@ -65,6 +107,7 @@ const isInputObjectDescriptor = (value, subscriptionId, generationId) => {
         isNonEmptyString(value.etag) &&
         isSha256(value.sha256) &&
         isPositiveInteger(value.byteCount) &&
+        value.byteCount <= BILLING_ARTIFACT_OBJECT_LIMITS_V1.inputObjectStoredBytes &&
         isNonNegativeInteger(value.rowCount) &&
         isStringIn(value.basis, BILLING_BASES) &&
         (value.currencyCode === undefined || isNonEmptyString(value.currencyCode)) &&
@@ -74,31 +117,76 @@ const isOutputArtifactDescriptor = (value, subscriptionId, generationId) => {
     if (!isRecord(value))
         return false;
     const prefix = outputGenerationPrefix(subscriptionId, generationId);
-    return (isGenerationPath(value.path, prefix, outputManifestPath(subscriptionId, generationId)) &&
-        isNonEmptyString(value.name) &&
-        value.mediaType === 'application/json' &&
-        isStringIn(value.contentEncoding, CONTENT_ENCODINGS) &&
-        isNonNegativeInteger(value.byteLength) &&
-        isSha256(value.sha256));
+    if (!isGenerationPath(value.path, prefix, outputManifestPath(subscriptionId, generationId)) ||
+        !isPathSegment(value.name) ||
+        !((value.name === 'metadata.json' &&
+            value.path === `${prefix}metadata.json` &&
+            isNonNegativeInteger(value.byteLength) &&
+            value.byteLength <= BILLING_ARTIFACT_OBJECT_LIMITS_V1.metadataStoredBytes) ||
+            (value.name !== 'metadata.json' &&
+                value.path === `${prefix}plots/${value.name}` &&
+                isNonNegativeInteger(value.byteLength) &&
+                value.byteLength <= BILLING_ARTIFACT_OBJECT_LIMITS_V1.plotStoredBytes))) {
+        return false;
+    }
+    return value.mediaType === 'application/json' && isStringIn(value.contentEncoding, CONTENT_ENCODINGS) && isSha256(value.sha256);
 };
 const isJsonMetadata = (value) => {
     if (!isRecord(value))
         return false;
-    const visit = (candidate) => {
-        if (candidate === null || typeof candidate === 'string' || typeof candidate === 'boolean')
-            return true;
-        if (isFiniteNumber(candidate))
-            return true;
-        if (Array.isArray(candidate))
-            return candidate.every(visit);
-        return isRecord(candidate) && Object.getPrototypeOf(candidate) === Object.prototype && Object.values(candidate).every(visit);
-    };
-    return visit(value);
+    const pending = [{ kind: 'visit', value }];
+    const activeContainers = new WeakSet();
+    const completedContainers = new WeakSet();
+    let visitedNodeCount = 0;
+    while (pending.length > 0) {
+        const candidate = pending.pop();
+        if (candidate.kind === 'leave') {
+            activeContainers.delete(candidate.container);
+            completedContainers.add(candidate.container);
+            continue;
+        }
+        if (candidate.value === null || typeof candidate.value === 'string' || typeof candidate.value === 'boolean' || isFiniteNumber(candidate.value)) {
+            continue;
+        }
+        if (Array.isArray(candidate.value)) {
+            visitedNodeCount += 1;
+            if (visitedNodeCount > ARTIFACT_CONTROL_DATA_MAX_VISITED_NODES)
+                return false;
+            if (activeContainers.has(candidate.value))
+                return false;
+            if (completedContainers.has(candidate.value))
+                continue;
+            activeContainers.add(candidate.value);
+            pending.push({ kind: 'leave', container: candidate.value });
+            for (let index = candidate.value.length - 1; index >= 0; index -= 1) {
+                pending.push({ kind: 'visit', value: candidate.value[index] });
+            }
+            continue;
+        }
+        if (!isRecord(candidate.value) || Object.getPrototypeOf(candidate.value) !== Object.prototype)
+            return false;
+        visitedNodeCount += 1;
+        if (visitedNodeCount > ARTIFACT_CONTROL_DATA_MAX_VISITED_NODES)
+            return false;
+        if (activeContainers.has(candidate.value))
+            return false;
+        if (completedContainers.has(candidate.value))
+            continue;
+        activeContainers.add(candidate.value);
+        pending.push({ kind: 'leave', container: candidate.value });
+        for (const child of Object.values(candidate.value))
+            pending.push({ kind: 'visit', value: child });
+    }
+    return true;
 };
 /** Validates one immutable billing analyzer input manifest without performing I/O. */
 export const isBillingAnalyzerInputManifestV2 = (value) => {
     if (!isRecord(value) ||
-        containsForbiddenArtifactControlData(value, [...allowedArtifactIdentityField(value, 'publicationKey'), ...allowedDescriptorPaths(value.inputs)])) {
+        containsForbiddenBillingArtifactControlData(value, [
+            ...allowedArtifactIdentityField(value, 'publicationKey'),
+            ...allowedArtifactTraversalField(value, 'inputs'),
+            ...allowedDescriptorPaths(value.inputs),
+        ])) {
         return false;
     }
     if (value.schemaVersion !== 2 || value.status !== 'completed')
@@ -117,7 +205,7 @@ export const isBillingAnalyzerInputManifestV2 = (value) => {
     const periodKeys = value.requestedPeriods.map(period => `${period.fromInclusive}\n${period.throughExclusive}\n${period.dateBasis}\n${period.timeZone ?? ''}\n${period.basis}`);
     if (!hasUniqueValues(periodKeys))
         return false;
-    if (!Array.isArray(value.inputs) || value.inputs.length === 0)
+    if (!Array.isArray(value.inputs) || value.inputs.length === 0 || value.inputs.length > BILLING_ARTIFACT_OBJECT_LIMITS_V1.maxInputObjects)
         return false;
     if (!value.inputs.every(input => isInputObjectDescriptor(input, value.subscriptionId, value.generationId)))
         return false;
@@ -125,7 +213,9 @@ export const isBillingAnalyzerInputManifestV2 = (value) => {
 };
 /** Validates the enforceable current pointer for one published analyzer input generation. */
 export const isBillingAnalyzerInputCurrentPointerV1 = (value) => {
-    if (!isRecord(value) || containsForbiddenArtifactControlData(value, allowedArtifactReferenceField(value, 'manifestPath')))
+    if (!isRecord(value) ||
+        hasDiagnosticObservationDiscriminant(value) ||
+        containsForbiddenBillingArtifactControlData(value, allowedArtifactReferenceField(value, 'manifestPath')))
         return false;
     if (value.schemaVersion !== 1 || value.status !== 'completed')
         return false;
@@ -138,7 +228,7 @@ export const isBillingAnalyzerInputCurrentPointerV1 = (value) => {
 };
 /** Validates the V2 queue envelope and its immutable input-manifest binding. */
 export const isBillingAnalyzerRequestV2 = (value) => {
-    if (!isRecord(value) || containsForbiddenArtifactControlData(value, allowedArtifactReferenceField(value, 'inputManifestPath')))
+    if (!isRecord(value) || containsForbiddenBillingArtifactControlData(value, allowedArtifactReferenceField(value, 'inputManifestPath')))
         return false;
     if (value.schemaVersion !== 2 || (value.publicationMode !== 'observe' && value.publicationMode !== 'enforce'))
         return false;
@@ -157,11 +247,32 @@ export const isBillingAnalyzerRequestV2 = (value) => {
         return false;
     return value.displayMetadata === undefined || isJsonMetadata(value.displayMetadata);
 };
+/** Validates a diagnostic-only latest-enqueued pointer; it is never customer authority. */
+export const isBillingAnalyzerInputObservationPointerV1 = (value) => {
+    if (!isRecord(value) || containsForbiddenBillingArtifactControlData(value, allowedArtifactReferenceField(value, 'inputManifestPath')))
+        return false;
+    if (value.schemaVersion !== 1 ||
+        value.documentType !== 'billing-analyzer-input-observation-pointer' ||
+        value.authority !== 'diagnostic-only' ||
+        value.publicationMode !== 'observe' ||
+        value.inputState !== 'enqueued') {
+        return false;
+    }
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, false))
+        return false;
+    return (isStrictLogicalArtifactReference(value.inputManifestPath) &&
+        value.inputManifestPath === inputManifestPath(value.subscriptionId, value.generationId) &&
+        isSha256(value.inputManifestDigest) &&
+        isSha256(value.messageId) &&
+        isNonEmptyString(value.correlationId) &&
+        isCanonicalIsoTimestamp(value.enqueuedAt));
+};
 /** Validates an immutable analyzer output manifest and its exact input binding. */
 export const isBillingAnalyzerOutputManifestV2 = (value) => {
     if (!isRecord(value) ||
-        containsForbiddenArtifactControlData(value, [
+        containsForbiddenBillingArtifactControlData(value, [
             ...allowedArtifactReferenceField(value, 'inputManifestPath'),
+            ...allowedArtifactTraversalField(value, 'artifacts'),
             ...allowedDescriptorPaths(value.artifacts),
         ])) {
         return false;
@@ -195,16 +306,16 @@ export const isBillingAnalyzerOutputManifestV2 = (value) => {
         publicationDecisionReferencesDigest(value.publicationDecision, new Set([...outputDerivedDigests].filter(digest => digest !== value.inputManifestDigest)))) {
         return false;
     }
-    if (!value.artifacts.some(artifact => artifact.path === `${outputGenerationPrefix(value.subscriptionId, value.generationId)}metadata.json`)) {
+    if (value.artifacts.filter(artifact => artifact.name === 'metadata.json').length !== 1)
         return false;
-    }
     return (isBillingCompletedArtifactPublicationDecision(value.publicationDecision, value.generationId, value.inputManifestDigest) &&
         isCanonicalIsoTimestamp(value.completedAt));
 };
 /** Validates the sole promoted authority pointer for completed billing analysis. */
 export const isBillingAnalysisCurrentPointerV1 = (value) => {
     if (!isRecord(value) ||
-        containsForbiddenArtifactControlData(value, [
+        hasDiagnosticObservationDiscriminant(value) ||
+        containsForbiddenBillingArtifactControlData(value, [
             ...allowedArtifactReferenceField(value, 'inputManifestPath'),
             ...allowedArtifactReferenceField(value, 'outputManifestPath'),
         ])) {
@@ -227,3 +338,53 @@ export const isBillingAnalysisCurrentPointerV1 = (value) => {
     return (isBillingCompletedArtifactPublicationDecision(value.publicationDecision, value.generationId, value.inputManifestDigest) &&
         isCanonicalIsoTimestamp(value.completedAt));
 };
+/** Validates an immutable diagnostic-only promotion evaluation. */
+export const isBillingAnalysisPromotionObservationV1 = (value) => {
+    if (!isRecord(value) ||
+        containsForbiddenBillingArtifactControlData(value, [
+            ...allowedArtifactReferenceField(value, 'inputManifestPath'),
+            ...allowedArtifactReferenceField(value, 'outputManifestPath'),
+        ])) {
+        return false;
+    }
+    if (value.schemaVersion !== 1 ||
+        value.documentType !== 'billing-analysis-promotion-observation' ||
+        value.authority !== 'diagnostic-only' ||
+        value.publicationMode !== 'observe' ||
+        value.processingState !== 'succeeded') {
+        return false;
+    }
+    if (!hasMatchingIdentity(value.subscriptionId, value.generationId, value.ownership, value.revision, false))
+        return false;
+    if (!isStrictLogicalArtifactReference(value.inputManifestPath) ||
+        value.inputManifestPath !== inputManifestPath(value.subscriptionId, value.generationId) ||
+        !isStrictLogicalArtifactReference(value.outputManifestPath) ||
+        value.outputManifestPath !== outputManifestPath(value.subscriptionId, value.generationId)) {
+        return false;
+    }
+    if (!isSha256(value.inputManifestDigest) ||
+        !isSha256(value.outputManifestDigest) ||
+        !isSha256(value.observationDigest) ||
+        !isSha256(value.messageId) ||
+        !isNonEmptyString(value.correlationId) ||
+        !isCanonicalIsoTimestamp(value.observedAt) ||
+        !isRecord(value.evaluation) ||
+        !isStringIn(value.evaluation.comparison, OBSERVATION_COMPARISONS)) {
+        return false;
+    }
+    const hasOwnershipEpoch = value.ownership.ownershipEpochRevision !== undefined;
+    const outputDigestRelation = value.evaluation.outputDigestRelation;
+    if (outputDigestRelation !== undefined && outputDigestRelation !== 'same' && outputDigestRelation !== 'different')
+        return false;
+    if (!hasOwnershipEpoch) {
+        return (outputDigestRelation === undefined && value.evaluation.comparison === 'unenforceable' && value.evaluation.projectedOutcome === 'not-enforceable');
+    }
+    if (value.evaluation.comparison === 'equal') {
+        return outputDigestRelation === 'different'
+            ? value.evaluation.projectedOutcome === 'would-quarantine'
+            : value.evaluation.projectedOutcome === 'would-be-idempotent';
+    }
+    return (outputDigestRelation === undefined &&
+        value.evaluation.comparison !== 'unenforceable' &&
+        OBSERVATION_PROJECTED_OUTCOMES.get(value.evaluation.comparison) === value.evaluation.projectedOutcome);
+};

package/dist/esm/azure/billingArtifactLimits.js

@@ -0,0 +1,18 @@
+/**
+ * V1 billing artifact object limits in bytes.
+ *
+ * `StoredBytes` limits apply to the exact persisted object before content
+ * decoding. `DecodedBytes` limits apply after decoding or decompression.
+ */
+export const BILLING_ARTIFACT_OBJECT_LIMITS_V1 = Object.freeze({
+    pointerStoredBytes: 64 * 1024,
+    observationStoredBytes: 64 * 1024,
+    manifestStoredBytes: 1024 * 1024,
+    metadataStoredBytes: 4 * 1024 * 1024,
+    metadataDecodedBytes: 16 * 1024 * 1024,
+    plotStoredBytes: 32 * 1024 * 1024,
+    plotDecodedBytes: 128 * 1024 * 1024,
+    inputObjectStoredBytes: 32 * 1024 * 1024,
+    inputObjectDecodedBytes: 128 * 1024 * 1024,
+    maxInputObjects: 12,
+});

package/dist/esm/azure/billingPlots.js

@@ -1,11 +1,93 @@
 /**
  * Billing cost analysis types for Azure cost visualization.
  */
-import { isArtifactOwnershipBinding, } from '../common/artifactEvidence.js';
+import { isArtifactOwnershipBinding } from '../common/artifactEvidence.js';
 import { containsForbiddenArtifactControlData } from '../common/artifactControlData.js';
 import { isArtifactRevisionVector } from '../common/artifactEvidenceValidation.js';
 import { isBillingCompletedArtifactPublicationDecision, isBillingPartialArtifactPublicationDecision, } from './billingArtifactEvidence.js';
-const BILLING_DOCUMENT_STATES = new Set(['current', 'stale', 'partial', 'fallback', 'complete-empty']);
+const LEGACY_FALLBACK_FORBIDDEN_OWN_FIELDS = [
+    'schemaVersion',
+    'ownership',
+    'revision',
+    'authority',
+    'documentType',
+    'publicationMode',
+    'status',
+    'generationId',
+    'inputManifestDigest',
+    'outputBindingDigest',
+    'outputManifestDigest',
+    'manifestDigest',
+    'observationDigest',
+    'sha256',
+    'artifactEvidence',
+    'publicationDecision',
+    'artifacts',
+    'manifestPath',
+    'inputManifestPath',
+    'outputManifestPath',
+    'byteLength',
+    'byteCount',
+    'rowCount',
+    'contentEncoding',
+    'mediaType',
+    'etag',
+    'versionId',
+    'publicationKey',
+    'coveragePlanDigest',
+    'messageId',
+    'eventId',
+    'correlationId',
+    'idempotencyKey',
+    'inputState',
+    'processingState',
+    'evaluation',
+    'dependencies',
+    'claims',
+    'issues',
+    'completedAt',
+    'observedAt',
+    'enqueuedAt',
+];
+const BILLING_FORBIDDEN_CONTROL_FIELDS = new Set([
+    ...LEGACY_FALLBACK_FORBIDDEN_OWN_FIELDS,
+    'artifactState',
+    'artifactSource',
+    'digest',
+    'fingerprint',
+    'checksum',
+    'hash',
+    'subscriptionId',
+    'provider',
+    'tenantId',
+    'companyId',
+    'cloudAccountId',
+    'accountId',
+    'ownershipEpochRevision',
+    'sourceRevision',
+    'policyRevision',
+    'processing',
+    'evidence',
+    'publication',
+    'required',
+    'support',
+    'applicability',
+    'attempt',
+    'coverage',
+    'emptyEvidence',
+    'freshness',
+    'reasonCode',
+    'acceptedRowCount',
+    'emptyProofRef',
+    'claimId',
+    'sectionPaths',
+    'requiredDependencies',
+    'code',
+    'blocking',
+    'dependency',
+].map(field => field.toLowerCase()));
+const BILLING_DOCUMENT_STATES = new Set(['current', 'stale', 'partial', 'complete-empty']);
+const BILLING_VERIFIED_READ_STATES = new Set(['current', 'stale', 'complete-empty']);
 const SHA256_PATTERN = /^[a-f0-9]{64}$/;
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const isNonEmptyString = (value) => typeof value === 'string' && value.trim() === value && value.length > 0;
@@ -15,9 +97,145 @@ const isNullableFiniteNumber = (value) => value === null || isFiniteNumber(value
 const isNonNegativeInteger = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
 const isPositiveInteger = (value) => Number.isSafeInteger(value) && Number(value) > 0;
 const isStringArray = (value) => Array.isArray(value) && value.every(isNonEmptyString);
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 const hasControlCharacters = (value) => Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
 const isPathSegment = (value) => isNonEmptyString(value) && !/[\\/?#%]/.test(value) && !hasControlCharacters(value) && value !== '.' && value !== '..';
 const publicationDecisionReferencesDigest = (value, digest) => isRecord(value) && Array.isArray(value.dependencies) && value.dependencies.some(dependency => isRecord(dependency) && dependency.digest === digest);
+const allowedBillingCostAnalysisFields = (value, validationBranch) => {
+    const fields = [];
+    const allowText = (object, ...keys) => {
+        if (!isRecord(object))
+            return;
+        for (const key of keys)
+            fields.push({ object, key, allowUriScheme: true, allowDigestLike: true, allowControlField: true });
+    };
+    const allowTextArray = (object, key) => {
+        if (isRecord(object)) {
+            fields.push({ object, key, allowUriSchemeInStringArray: true, allowDigestLike: true, allowControlField: true });
+        }
+    };
+    const allowControl = (object, ...keys) => {
+        if (!isRecord(object))
+            return;
+        for (const key of keys)
+            fields.push({ object, key, allowControlField: true });
+    };
+    const allowDigest = (object, key) => {
+        if (isRecord(object))
+            fields.push({ object, key, allowDigestLike: true, allowControlField: true });
+    };
+    const allowChildren = (object, ...keys) => {
+        if (!isRecord(object))
+            return;
+        for (const key of keys)
+            fields.push({ object, key, allowChildArtifactFields: true });
+    };
+    allowText(value, 'subscriptionId', 'billingGenerationId', 'currencyCode', 'currencySymbol', 'forecastMethod');
+    allowControl(value, 'schemaVersion', 'ownership', 'revision', 'artifactEvidence');
+    allowChildren(value, 'ownership', 'revision', 'artifactEvidence', 'chartData', 'anomalies');
+    if (validationBranch !== 'business-v1')
+        allowControl(value, 'artifactState');
+    if (validationBranch === 'legacy-fallback')
+        allowControl(value, 'artifactSource');
+    allowDigest(value, 'inputManifestDigest');
+    allowDigest(value, 'outputBindingDigest');
+    if (isRecord(value.ownership)) {
+        allowControl(value.ownership, 'provider', 'ownershipEpochRevision');
+        allowText(value.ownership, 'tenantId', 'companyId', 'cloudAccountId', 'accountId');
+    }
+    if (isRecord(value.revision))
+        allowControl(value.revision, 'ownershipEpochRevision', 'sourceRevision', 'policyRevision');
+    if (isRecord(value.artifactEvidence)) {
+        const evidence = value.artifactEvidence;
+        allowControl(evidence, 'processing', 'evidence', 'publication', 'dependencies', 'claims', 'issues');
+        allowChildren(evidence, 'dependencies', 'claims', 'issues');
+        if (Array.isArray(evidence.dependencies)) {
+            for (const dependency of evidence.dependencies) {
+                allowControl(dependency, 'required', 'support', 'applicability', 'attempt', 'coverage', 'emptyEvidence', 'freshness', 'evidence', 'publication', 'sourceRevision', 'policyRevision', 'acceptedRowCount', 'emptyProofRef');
+                allowText(dependency, 'name', 'reasonCode', 'generationId');
+                allowDigest(dependency, 'digest');
+                if (isRecord(dependency) && isRecord(dependency.observedRange)) {
+                    allowChildren(dependency, 'observedRange');
+                    allowText(dependency.observedRange, 'timeZone');
+                }
+            }
+        }
+        if (Array.isArray(evidence.claims)) {
+            for (const claim of evidence.claims) {
+                allowControl(claim, 'evidence', 'publication', 'issues');
+                allowText(claim, 'claimId');
+                allowTextArray(claim, 'sectionPaths');
+                allowTextArray(claim, 'requiredDependencies');
+                if (!isRecord(claim) || !Array.isArray(claim.issues))
+                    continue;
+                allowChildren(claim, 'issues');
+                for (const issue of claim.issues) {
+                    allowControl(issue, 'blocking');
+                    allowText(issue, 'code', 'dependency');
+                }
+            }
+        }
+        if (Array.isArray(evidence.issues)) {
+            for (const issue of evidence.issues) {
+                allowControl(issue, 'blocking');
+                allowText(issue, 'code', 'dependency');
+            }
+        }
+    }
+    if (isRecord(value.chartData)) {
+        allowControl(value.chartData, 'schemaVersion');
+        allowText(value.chartData, 'source');
+        allowChildren(value.chartData, 'dataWindow', 'views', 'detectors');
+        if (isRecord(value.chartData.views)) {
+            for (const [viewKey, view] of Object.entries(value.chartData.views)) {
+                allowChildren(value.chartData.views, viewKey);
+                allowText(view, 'aggregation', 'forecastMethod');
+                if (!isRecord(view))
+                    continue;
+                allowChildren(view, 'trend', 'points', 'actualPoints', 'forecastPoints', 'fittedPoints');
+                allowText(view.trend, 'method');
+                for (const pointsKey of ['points', 'actualPoints', 'forecastPoints', 'fittedPoints']) {
+                    const points = view[pointsKey];
+                    if (!Array.isArray(points))
+                        continue;
+                    for (const point of points) {
+                        allowText(point, 'date', 'month');
+                        allowTextArray(point, 'anomalyMethods');
+                    }
+                }
+            }
+        }
+        if (isRecord(value.chartData.detectors) && Array.isArray(value.chartData.detectors.methods)) {
+            allowChildren(value.chartData.detectors, 'methods');
+            for (const method of value.chartData.detectors.methods)
+                allowText(method, 'name', 'status', 'error');
+        }
+    }
+    if (!Array.isArray(value.anomalies))
+        return fields;
+    for (const anomaly of value.anomalies) {
+        allowText(anomaly, 'summary', 'confidence');
+        allowTextArray(anomaly, 'notes');
+        if (!isRecord(anomaly) || !Array.isArray(anomaly.drivers))
+            continue;
+        allowChildren(anomaly, 'impact', 'drivers');
+        for (const driver of anomaly.drivers) {
+            allowText(driver, 'type', 'name', 'summary');
+            if (!isRecord(driver) || !Array.isArray(driver.resources))
+                continue;
+            allowChildren(driver, 'resources');
+            for (const resource of driver.resources)
+                allowText(resource, 'name', 'resourceScope', 'summary');
+        }
+    }
+    return fields;
+};
+const containsForbiddenBillingCostAnalysisControlData = (value, validationBranch) => containsForbiddenArtifactControlData(value, allowedBillingCostAnalysisFields(value, validationBranch), {
+    rejectDigestLikeValues: true,
+    requireSafeAzureResourceIds: true,
+    forbiddenControlFields: BILLING_FORBIDDEN_CONTROL_FIELDS,
+    requireAllowedFieldTraversalContext: true,
+});
 const isTrend = (value) => isRecord(value) && isNonEmptyString(value.method) && isFiniteNumber(value.slope) && isFiniteNumber(value.intercept);
 const isDailyPoint = (value) => isRecord(value) &&
     isNonEmptyString(value.date) &&
@@ -139,7 +357,11 @@ const hasValidMetadataEvidenceState = (state, evidence, billingGenerationId, inp
         return false;
     if (state !== 'complete-empty')
         return true;
+    if (!Array.isArray(anomalies))
+        return false;
     const billingHistory = evidence.dependencies.find(dependency => dependency.name === 'billing-history');
+    if (!isRecord(chartData))
+        return false;
     const dataWindow = chartData.dataWindow;
     const views = chartData.views;
     return (billingHistory?.emptyEvidence === 'complete-empty' &&
@@ -151,11 +373,27 @@ const hasValidMetadataEvidenceState = (state, evidence, billingGenerationId, inp
         Object.values(views).every(view => view === undefined) &&
         anomalies.length === 0);
 };
+const hasValidBillingCostAnalysisBusinessFields = (value) => {
+    if (!isPathSegment(value.subscriptionId) || !isPathSegment(value.billingGenerationId))
+        return false;
+    if (!isChartData(value.chartData) || !Array.isArray(value.anomalies) || !value.anomalies.every(isAnomaly))
+        return false;
+    if (!isNonEmptyString(value.currencyCode) || !isNonEmptyString(value.currencySymbol))
+        return false;
+    if (value.forecastMethod !== undefined && !isNonEmptyString(value.forecastMethod))
+        return false;
+    return [value.forecastMonthTotal, value.forecastRemaining, value.forecastPeriodEnd].every(isOptionalFiniteNumber);
+};
+const isBillingCostAnalysisBusinessPayloadForBranch = (value, validationBranch) => !containsForbiddenBillingCostAnalysisControlData(value, validationBranch) &&
+    !LEGACY_FALLBACK_FORBIDDEN_OWN_FIELDS.some(field => hasOwn(value, field)) &&
+    hasValidBillingCostAnalysisBusinessFields(value);
+/** Dependency-free validator for the complete legacy V1 business payload. */
+export const isBillingCostAnalysisBusinessPayloadV1 = (value) => isRecord(value) && isBillingCostAnalysisBusinessPayloadForBranch(value, 'business-v1');
 /** Dependency-free validator for customer-readable V2 billing metadata. */
 export const isBillingCostAnalysisMetadataV2 = (value) => {
-    if (!isRecord(value) || containsForbiddenArtifactControlData(value) || value.schemaVersion !== 2)
+    if (!isRecord(value) || containsForbiddenBillingCostAnalysisControlData(value, 'metadata-v2') || value.schemaVersion !== 2)
         return false;
-    if (Object.prototype.hasOwnProperty.call(value, 'outputManifestDigest'))
+    if (hasOwn(value, 'outputManifestDigest'))
         return false;
     if (!isPathSegment(value.subscriptionId) || !isPathSegment(value.billingGenerationId))
         return false;
@@ -174,14 +412,19 @@ export const isBillingCostAnalysisMetadataV2 = (value) => {
         publicationDecisionReferencesDigest(value.artifactEvidence, value.outputBindingDigest)) {
         return false;
     }
-    if (!isChartData(value.chartData) || !Array.isArray(value.anomalies) || !value.anomalies.every(isAnomaly))
+    if (!hasValidBillingCostAnalysisBusinessFields(value))
         return false;
     if (!hasValidMetadataEvidenceState(value.artifactState, value.artifactEvidence, value.billingGenerationId, value.inputManifestDigest, value.chartData, value.anomalies)) {
         return false;
     }
-    if (!isNonEmptyString(value.currencyCode) || !isNonEmptyString(value.currencySymbol))
-        return false;
-    if (value.forecastMethod !== undefined && !isNonEmptyString(value.forecastMethod))
-        return false;
-    return [value.forecastMonthTotal, value.forecastRemaining, value.forecastPeriodEnd].every(isOptionalFiniteNumber);
+    return true;
 };
+/** Dependency-free validator for an explicit legacy-transition fallback response. */
+export const isBillingCostAnalysisLegacyFallbackResponse = (value) => isRecord(value) &&
+    value.artifactState === 'fallback' &&
+    value.artifactSource === 'legacy-transition' &&
+    isBillingCostAnalysisBusinessPayloadForBranch(value, 'legacy-fallback');
+/** Dependency-free validator for an evidence-verified endpoint response. */
+export const isBillingCostAnalysisVerifiedReadResponse = (value) => isBillingCostAnalysisMetadataV2(value) && BILLING_VERIFIED_READ_STATES.has(value.artifactState);
+/** Dependency-free validator for the successful billing read-response union. */
+export const isBillingCostAnalysisReadResponse = (value) => isBillingCostAnalysisVerifiedReadResponse(value) || isBillingCostAnalysisLegacyFallbackResponse(value);