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

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

package/dist/esm/azure/views.js

@@ -1,6 +1,14 @@
-import { allowedArtifactReferenceField, containsForbiddenArtifactControlData, } from '../common/artifactControlData.js';
+import { allowedArtifactReferenceField, allowedArtifactTraversalField, containsForbiddenArtifactControlData, } from '../common/artifactControlData.js';
 import { isArtifactOwnershipBinding, isArtifactPublicationDecision, isEnforceableArtifactOwnershipBinding, } from '../common/artifactEvidence.js';
 import { isArtifactRevisionVector, isStrictLogicalArtifactReference } from '../common/artifactEvidenceValidation.js';
+export const PUBLISHED_VIEW_OBJECT_LIMITS_V1 = {
+    maxArtifacts: 512,
+    maxClaims: 128,
+    maxDependencies: 256,
+    maxIssues: 512,
+    maxClaimBindings: 512,
+    maxSectionPaths: 512,
+};
 const isNonEmptyString = (value) => typeof value === 'string' && value.trim().length > 0;
 const isCanonicalIsoTimestamp = (value) => {
     if (!isNonEmptyString(value))
@@ -41,6 +49,9 @@ const isPositiveSafeInteger = (value) => Number.isSafeInteger(value) && Number(v
 const isNonNegativeSafeInteger = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
 const isSha256 = (value) => typeof value === 'string' && SHA256_PATTERN.test(value);
 const allowedViewArtifactPaths = (artifacts) => Array.isArray(artifacts) ? artifacts.flatMap(artifact => allowedArtifactReferenceField(artifact, 'path')) : [];
+const containsForbiddenViewArtifactControlData = (value, allowedReferenceFields = []) => containsForbiddenArtifactControlData(value, allowedReferenceFields, {
+    requireAllowedFieldTraversalContext: true,
+});
 const isSafePathSegment = (value) => isStrictNonEmptyString(value) && !/[\\/?#%]/.test(value) && value !== '.' && value !== '..';
 const isStrictCanonicalIsoTimestamp = (value) => {
     if (!isStrictNonEmptyString(value))
@@ -70,6 +81,120 @@ const isViewArtifactDescriptor = (value, runId) => isRecord(value) &&
     VIEW_CONTENT_ENCODINGS.has(value.contentEncoding) &&
     isNonNegativeSafeInteger(value.byteLength) &&
     isSha256(value.sha256);
+const isPublishedViewCoverage = (value) => value === 'complete' || value === 'partial';
+const isProjectedSectionPathForArtifact = (value, artifactPath) => {
+    if (!isStrictNonEmptyString(value))
+        return false;
+    if (value === artifactPath)
+        return true;
+    if (!value.startsWith(`${artifactPath}#/`))
+        return false;
+    const pointer = value.slice(artifactPath.length + 1);
+    return !pointer.includes('\\') && !pointer.includes('?') && !/%(?:2f|2F|5c|5C)/.test(pointer);
+};
+const parseProjectedSectionPath = (value) => {
+    const fragmentIndex = value.indexOf('#');
+    const artifactPath = fragmentIndex < 0 ? value : value.slice(0, fragmentIndex);
+    if (!isStrictLogicalArtifactReference(artifactPath) || !isProjectedSectionPathForArtifact(value, artifactPath))
+        return undefined;
+    return {
+        artifactPath,
+        pointerSegments: fragmentIndex < 0 ? [] : value.slice(fragmentIndex + 2).split('/'),
+    };
+};
+const doProjectedSectionsOverlap = (left, right) => {
+    const parsedLeft = parseProjectedSectionPath(left);
+    const parsedRight = parseProjectedSectionPath(right);
+    if (!parsedLeft || !parsedRight || parsedLeft.artifactPath !== parsedRight.artifactPath)
+        return false;
+    if (parsedLeft.pointerSegments.length === 0 || parsedRight.pointerSegments.length === 0)
+        return true;
+    const sharedLength = Math.min(parsedLeft.pointerSegments.length, parsedRight.pointerSegments.length);
+    for (let index = 0; index < sharedLength; index += 1) {
+        const leftSegment = parsedLeft.pointerSegments[index];
+        const rightSegment = parsedRight.pointerSegments[index];
+        if (leftSegment === rightSegment)
+            continue;
+        if (leftSegment === '*' || leftSegment === '**' || rightSegment === '*' || rightSegment === '**')
+            return true;
+        return false;
+    }
+    return true;
+};
+const hasUnambiguousPublishedClaimSections = (decision) => {
+    const declaredSections = [];
+    for (const claim of decision.claims) {
+        if (new Set(claim.sectionPaths).size !== claim.sectionPaths.length)
+            return false;
+        for (const sectionPath of claim.sectionPaths) {
+            if (!parseProjectedSectionPath(sectionPath))
+                return false;
+            if (declaredSections.some(declaredSection => doProjectedSectionsOverlap(declaredSection, sectionPath)))
+                return false;
+            declaredSections.push(sectionPath);
+        }
+    }
+    return true;
+};
+const isPublishedViewArtifactDescriptor = (value, runId) => {
+    if (!isViewArtifactDescriptor(value, runId) || !isRecord(value))
+        return false;
+    const runPrefix = `runs/${runId}/`;
+    if (value.name !== value.path.slice(runPrefix.length))
+        return false;
+    if (!Array.isArray(value.claimBindings) ||
+        value.claimBindings.length === 0 ||
+        value.claimBindings.length > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxClaimBindings) {
+        return false;
+    }
+    const claimIds = new Set();
+    for (const binding of value.claimBindings) {
+        if (!isRecord(binding) || !isStrictNonEmptyString(binding.claimId) || claimIds.has(binding.claimId))
+            return false;
+        claimIds.add(binding.claimId);
+        if (!Array.isArray(binding.sectionPaths) ||
+            binding.sectionPaths.length === 0 ||
+            binding.sectionPaths.length > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxSectionPaths) {
+            return false;
+        }
+        if (new Set(binding.sectionPaths).size !== binding.sectionPaths.length)
+            return false;
+        if (!binding.sectionPaths.every(sectionPath => isProjectedSectionPathForArtifact(sectionPath, value.path)))
+            return false;
+    }
+    return true;
+};
+const hasPublishedViewDecisionBounds = (decision) => {
+    if (decision.claims.length === 0 ||
+        decision.claims.length > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxClaims ||
+        decision.dependencies.length > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxDependencies ||
+        decision.issues.length > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxIssues) {
+        return false;
+    }
+    let sectionPathCount = 0;
+    let issueCount = decision.issues.length;
+    for (const claim of decision.claims) {
+        sectionPathCount += claim.sectionPaths.length;
+        issueCount += claim.issues.length;
+        if (sectionPathCount > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxSectionPaths || issueCount > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxIssues) {
+            return false;
+        }
+    }
+    return true;
+};
+const hasPublishedViewArtifactBounds = (artifacts) => {
+    let claimBindingCount = 0;
+    let sectionPathCount = 0;
+    for (const artifact of artifacts) {
+        claimBindingCount += artifact.claimBindings.length;
+        for (const binding of artifact.claimBindings)
+            sectionPathCount += binding.sectionPaths.length;
+        if (claimBindingCount > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxClaimBindings || sectionPathCount > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxSectionPaths) {
+            return false;
+        }
+    }
+    return true;
+};
 const hasRequiredViewDependencies = (decision) => {
     const dependencies = new Map(decision.dependencies.map(dependency => [dependency.name, dependency]));
     const billing = dependencies.get('billing');
@@ -86,7 +211,11 @@ const hasRequiredViewDependencies = (decision) => {
 };
 /** Validates an evidence-aware completed portal or plugin generation manifest. */
 export const isCompletedViewManifestV3 = (value) => {
-    if (!isRecord(value) || containsForbiddenArtifactControlData(value, allowedViewArtifactPaths(value.artifacts)))
+    if (!isRecord(value) ||
+        containsForbiddenViewArtifactControlData(value, [
+            ...allowedArtifactTraversalField(value, 'artifacts'),
+            ...allowedViewArtifactPaths(value.artifacts),
+        ]))
         return false;
     if (value.schemaVersion !== 3 || value.status !== 'completed')
         return false;
@@ -116,6 +245,90 @@ export const isCompletedViewManifestV3 = (value) => {
     }
     return isArtifactPublicationDecision(value.publicationDecision) && hasRequiredViewDependencies(value.publicationDecision);
 };
+const hasExactPublishedClaimProjection = (artifacts, decision) => {
+    if (!hasUnambiguousPublishedClaimSections(decision))
+        return false;
+    const claimById = new Map(decision.claims.map(claim => [claim.claimId, claim]));
+    const completedClaims = decision.claims.filter(claim => claim.publication === 'completed');
+    if (completedClaims.length === 0)
+        return false;
+    const expectedBindings = new Set();
+    for (const claim of completedClaims) {
+        if (claim.sectionPaths.length === 0 || new Set(claim.sectionPaths).size !== claim.sectionPaths.length)
+            return false;
+        for (const sectionPath of claim.sectionPaths)
+            expectedBindings.add(`${claim.claimId}\0${sectionPath}`);
+    }
+    const actualBindings = new Set();
+    for (const artifact of artifacts) {
+        for (const binding of artifact.claimBindings) {
+            const claim = claimById.get(binding.claimId);
+            if (!claim || claim.publication !== 'completed')
+                return false;
+            for (const sectionPath of binding.sectionPaths) {
+                if (!claim.sectionPaths.includes(sectionPath))
+                    return false;
+                const key = `${binding.claimId}\0${sectionPath}`;
+                if (actualBindings.has(key))
+                    return false;
+                actualBindings.add(key);
+            }
+        }
+    }
+    return expectedBindings.size === actualBindings.size && Array.from(expectedBindings).every(binding => actualBindings.has(binding));
+};
+const isPublishedDecisionForCoverage = (decision, coverage) => {
+    if (!hasRequiredViewDependencies(decision) || decision.processing !== 'succeeded')
+        return false;
+    const completedClaimCount = decision.claims.filter(claim => claim.publication === 'completed').length;
+    if (coverage === 'complete') {
+        return decision.publication === 'completed' && decision.evidence === 'complete' && completedClaimCount === decision.claims.length;
+    }
+    return (decision.publication === 'partial' && decision.evidence === 'partial' && completedClaimCount > 0 && completedClaimCount < decision.claims.length);
+};
+/** Validates a claim-projected portal or plugin generation, including observe-mode epoch-free manifests. */
+export const isPublishedViewManifestV4 = (value) => {
+    if (!isRecord(value) ||
+        containsForbiddenViewArtifactControlData(value, [
+            ...allowedArtifactTraversalField(value, 'artifacts'),
+            ...allowedViewArtifactPaths(value.artifacts),
+        ])) {
+        return false;
+    }
+    if (value.schemaVersion !== 4 || value.status !== 'published' || !isPublishedViewCoverage(value.coverage))
+        return false;
+    if (!isSafePathSegment(value.runId) || !hasMatchingViewOwnership(value.subscriptionId, value.ownership, value.revision, false))
+        return false;
+    if (!isRecord(value.artifactGeneration) ||
+        value.artifactGeneration.runId !== value.runId ||
+        !isStrictCanonicalIsoTimestamp(value.artifactGeneration.generatedAt)) {
+        return false;
+    }
+    if (!Array.isArray(value.artifacts) || value.artifacts.length === 0 || value.artifacts.length > PUBLISHED_VIEW_OBJECT_LIMITS_V1.maxArtifacts) {
+        return false;
+    }
+    if (!value.artifacts.every(artifact => isPublishedViewArtifactDescriptor(artifact, value.runId)))
+        return false;
+    if (!hasPublishedViewArtifactBounds(value.artifacts))
+        return false;
+    if (new Set(value.artifacts.map(artifact => artifact.path)).size !== value.artifacts.length ||
+        new Set(value.artifacts.map(artifact => artifact.name)).size !== value.artifacts.length) {
+        return false;
+    }
+    if (!isPositiveSafeInteger(value.requestedArtifactCount) ||
+        value.requestedArtifactCount !== value.artifacts.length ||
+        !isNonNegativeSafeInteger(value.requestedResourceCount) ||
+        value.failedArtifactCount !== 0 ||
+        value.failedResourceCount !== 0 ||
+        !isSha256(value.compositeDependencyDigest) ||
+        !isStrictCanonicalIsoTimestamp(value.completedAt) ||
+        !isArtifactPublicationDecision(value.publicationDecision) ||
+        !hasPublishedViewDecisionBounds(value.publicationDecision)) {
+        return false;
+    }
+    return (isPublishedDecisionForCoverage(value.publicationDecision, value.coverage) &&
+        hasExactPublishedClaimProjection(value.artifacts, value.publicationDecision));
+};
 const hasSameOwnership = (left, right) => left.provider === right.provider &&
     left.tenantId === right.tenantId &&
     left.companyId === right.companyId &&
@@ -141,6 +354,22 @@ const isViewSetV2SurfaceReference = (value, surface, subscriptionId, ownership,
         value.compositeDependencyDigest === compositeDependencyDigest &&
         isStrictCanonicalIsoTimestamp(value.completedAt));
 };
+const isPublishedViewSetV3SurfaceReference = (value, surface, subscriptionId, ownership, revision, compositeDependencyDigest) => {
+    if (!isRecord(value) || !isSafePathSegment(value.runId) || !isPublishedViewCoverage(value.coverage))
+        return false;
+    const expectedManifestName = surface === 'portal' ? 'published-view-manifest.json' : 'published-plugin-generation.json';
+    if (value.manifestPath !== `runs/${value.runId}/${expectedManifestName}` || !isStrictLogicalArtifactReference(value.manifestPath))
+        return false;
+    if (!isEnforceableAzureOwnershipBinding(value.ownership) || !isArtifactRevisionVector(value.revision))
+        return false;
+    if (!hasMatchingViewOwnership(subscriptionId, value.ownership, value.revision, true))
+        return false;
+    if (!hasSameOwnership(ownership, value.ownership) || !hasSameRevision(revision, value.revision))
+        return false;
+    return (isSha256(value.manifestDigest) &&
+        value.compositeDependencyDigest === compositeDependencyDigest &&
+        isStrictCanonicalIsoTimestamp(value.completedAt));
+};
 const hasMatchingSurfaceDependency = (decision, name, surface) => {
     const dependency = decision.dependencies.find(candidate => candidate.name === name);
     return (dependency !== undefined &&
@@ -152,9 +381,14 @@ const hasMatchingSurfaceDependency = (decision, name, surface) => {
 /** Validates the promoted pointer for an evidence-enforced portal/plugin view pair. */
 export const isCompletedAzureViewSetV2 = (value) => {
     const allowedReferences = isRecord(value)
-        ? [...allowedArtifactReferenceField(value.portal, 'manifestPath'), ...allowedArtifactReferenceField(value.plugin, 'manifestPath')]
+        ? [
+            ...allowedArtifactTraversalField(value, 'portal'),
+            ...allowedArtifactTraversalField(value, 'plugin'),
+            ...allowedArtifactReferenceField(value.portal, 'manifestPath'),
+            ...allowedArtifactReferenceField(value.plugin, 'manifestPath'),
+        ]
         : [];
-    if (!isRecord(value) || containsForbiddenArtifactControlData(value, allowedReferences))
+    if (!isRecord(value) || containsForbiddenViewArtifactControlData(value, allowedReferences))
         return false;
     if (value.schemaVersion !== 2 || value.status !== 'completed')
         return false;
@@ -179,3 +413,43 @@ export const isCompletedAzureViewSetV2 = (value) => {
         hasMatchingSurfaceDependency(value.publicationDecision, 'portal', value.portal) &&
         hasMatchingSurfaceDependency(value.publicationDecision, 'plugin', value.plugin));
 };
+/** Validates the promoted pointer for one claim-projected portal/plugin generation pair. */
+export const isPublishedAzureViewSetV3 = (value) => {
+    const allowedReferences = isRecord(value)
+        ? [
+            ...allowedArtifactTraversalField(value, 'portal'),
+            ...allowedArtifactTraversalField(value, 'plugin'),
+            ...allowedArtifactReferenceField(value.portal, 'manifestPath'),
+            ...allowedArtifactReferenceField(value.plugin, 'manifestPath'),
+        ]
+        : [];
+    if (!isRecord(value) || containsForbiddenViewArtifactControlData(value, allowedReferences))
+        return false;
+    if (value.schemaVersion !== 3 || value.status !== 'published' || !isPublishedViewCoverage(value.coverage))
+        return false;
+    if (!isSafePathSegment(value.subscriptionId) ||
+        !isStrictNonEmptyString(value.publicationId) ||
+        !isEnforceableAzureOwnershipBinding(value.ownership) ||
+        !isArtifactRevisionVector(value.revision) ||
+        !hasMatchingViewOwnership(value.subscriptionId, value.ownership, value.revision, true)) {
+        return false;
+    }
+    if (!isSha256(value.compositeDependencyDigest) || !isStrictCanonicalIsoTimestamp(value.completedAt))
+        return false;
+    if (!isPublishedViewSetV3SurfaceReference(value.portal, 'portal', value.subscriptionId, value.ownership, value.revision, value.compositeDependencyDigest) ||
+        !isPublishedViewSetV3SurfaceReference(value.plugin, 'plugin', value.subscriptionId, value.ownership, value.revision, value.compositeDependencyDigest)) {
+        return false;
+    }
+    const expectedCoverage = value.portal.coverage === 'complete' && value.plugin.coverage === 'complete' ? 'complete' : 'partial';
+    if (value.coverage !== expectedCoverage)
+        return false;
+    const laterSurfaceCompletedAt = Date.parse(value.portal.completedAt) >= Date.parse(value.plugin.completedAt) ? value.portal.completedAt : value.plugin.completedAt;
+    if (value.completedAt !== laterSurfaceCompletedAt)
+        return false;
+    return (isArtifactPublicationDecision(value.publicationDecision) &&
+        hasPublishedViewDecisionBounds(value.publicationDecision) &&
+        value.publicationDecision.publication === 'completed' &&
+        value.publicationDecision.evidence === value.coverage &&
+        hasMatchingSurfaceDependency(value.publicationDecision, 'portal', value.portal) &&
+        hasMatchingSurfaceDependency(value.publicationDecision, 'plugin', value.plugin));
+};