@spottoai/types-package 1.0.2-beta.99 → 1.0.2-dev1138.2

package/dist/esm/common/artifactControlData.js

@@ -0,0 +1,200 @@
+const FORBIDDEN_SENSITIVE_FIELDS = new Set([
+    'accountkey',
+    'accesskey',
+    'accesstoken',
+    'apikey',
+    'authorization',
+    'clientsecret',
+    'connectionstring',
+    'credential',
+    'credentials',
+    'password',
+    'refreshtoken',
+    'sastoken',
+    'secret',
+    'sharedaccesssignature',
+    'token',
+]);
+const FORBIDDEN_PROTOTYPE_FIELDS = new Set(['proto', 'prototype', 'constructor']);
+const PHYSICAL_REFERENCE_FIELDS = new Set([
+    'artifactpath',
+    'blobpath',
+    'bloburi',
+    'bloburl',
+    'containerpath',
+    'containeruri',
+    'containerurl',
+    'filepath',
+    'filesystempath',
+    'inputmanifestpath',
+    'manifestpath',
+    'outputmanifestpath',
+    'path',
+    'physicalpath',
+    'physicaluri',
+    'physicalurl',
+    'sourcepath',
+    'sourceuri',
+    'sourceurl',
+    'storagepath',
+    'storageuri',
+    'storageurl',
+    'uri',
+    'url',
+]);
+const PERCENT_ENCODED_BYTE_PATTERN = /%[0-9A-Fa-f]{2}/;
+const URI_SCHEME_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+const SHA256_PATTERN = /^[0-9A-Fa-f]{64}$/;
+export const ARTIFACT_CONTROL_DATA_MAX_VISITED_NODES = 100000;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const hasControlCharacters = (value) => Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+const normalizeFieldName = (key) => key.replace(/[-_\s]/g, '').toLowerCase();
+const hasDotTraversal = (value) => value.split(/[\\/]/).some(segment => segment === '.' || segment === '..');
+const isForbiddenReferenceValue = (value, allowUriScheme = false, allowDigestLike = false, rejectDigestLikeValues = false) => hasControlCharacters(value) ||
+    PERCENT_ENCODED_BYTE_PATTERN.test(value) ||
+    (!allowUriScheme && URI_SCHEME_PATTERN.test(value)) ||
+    (rejectDigestLikeValues && !allowDigestLike && SHA256_PATTERN.test(value)) ||
+    value.startsWith('/') ||
+    value.startsWith('\\\\') ||
+    /^[A-Za-z]:[\\/]/.test(value) ||
+    hasDotTraversal(value);
+const isSafeAzureResourceId = (key, value) => {
+    if (key !== 'resourceId' || typeof value !== 'string' || hasControlCharacters(value) || value.includes('\\'))
+        return false;
+    const segments = value.split('/');
+    return (segments.length >= 3 &&
+        segments[0] === '' &&
+        segments[1].toLowerCase() === 'subscriptions' &&
+        segments
+            .slice(2)
+            .every(segment => segment.trim() === segment && segment.length > 0 && !/[?#%]/.test(segment) && segment !== '.' && segment !== '..'));
+};
+/** Marks a structurally validated schema field whose logical reference name is allowed. */
+export const allowedArtifactReferenceField = (object, key) => isRecord(object) ? [{ object, key }] : [];
+/** Marks a structurally validated identity field whose value is allowed by its owning schema. */
+export const allowedArtifactIdentityField = (object, key) => isRecord(object) ? [{ object, key, allowUriScheme: true }] : [];
+/** Marks an exact schema edge whose descendants may use object-indexed field allowances. */
+export const allowedArtifactTraversalField = (object, key) => isRecord(object) ? [{ object, key, allowChildArtifactFields: true }] : [];
+const indexAllowedArtifactFields = (allowedReferenceFields) => {
+    const index = new WeakMap();
+    for (const field of allowedReferenceFields) {
+        let objectFields = index.get(field.object);
+        if (!objectFields) {
+            objectFields = new Map();
+            index.set(field.object, objectFields);
+        }
+        const existing = objectFields.get(field.key);
+        objectFields.set(field.key, {
+            object: field.object,
+            key: field.key,
+            allowUriScheme: existing?.allowUriScheme || field.allowUriScheme,
+            allowUriSchemeInStringArray: existing?.allowUriSchemeInStringArray || field.allowUriSchemeInStringArray,
+            allowDigestLike: existing?.allowDigestLike || field.allowDigestLike,
+            allowControlField: existing?.allowControlField || field.allowControlField,
+            allowChildArtifactFields: existing?.allowChildArtifactFields || field.allowChildArtifactFields,
+        });
+    }
+    return index;
+};
+const containsForbiddenArtifactControlDataWithIndex = (value, allowedReferenceFields, options) => {
+    const pending = [{ kind: 'visit', value, allowIndexedFields: true }];
+    const activeContainers = new WeakSet();
+    const completedScanPolicies = new WeakMap();
+    let visitedNodeCount = 0;
+    const hasCompletedStricterScan = (container, scanPolicy) => completedScanPolicies.get(container)?.some(completedPolicy => (completedPolicy & scanPolicy) === completedPolicy) ?? false;
+    const completeScan = (container, scanPolicy) => {
+        const completedPolicies = completedScanPolicies.get(container) ?? [];
+        if (completedPolicies.some(completedPolicy => (completedPolicy & scanPolicy) === completedPolicy))
+            return;
+        completedScanPolicies.set(container, [...completedPolicies.filter(completedPolicy => (scanPolicy & completedPolicy) !== scanPolicy), scanPolicy]);
+    };
+    while (pending.length > 0) {
+        const candidate = pending.pop();
+        if (candidate.kind === 'leave') {
+            activeContainers.delete(candidate.container);
+            completeScan(candidate.container, candidate.scanPolicy);
+            continue;
+        }
+        if (typeof candidate.value === 'string') {
+            if (isForbiddenReferenceValue(candidate.value, false, false, options.rejectDigestLikeValues))
+                return true;
+            continue;
+        }
+        if (Array.isArray(candidate.value)) {
+            visitedNodeCount += 1;
+            if (visitedNodeCount > ARTIFACT_CONTROL_DATA_MAX_VISITED_NODES)
+                return true;
+            if (activeContainers.has(candidate.value))
+                return true;
+            const scanPolicy = (candidate.allowIndexedFields ? 1 : 0) |
+                (candidate.allowedStringArrayField ? 2 : 0) |
+                (candidate.allowedStringArrayField?.allowDigestLike ? 4 : 0);
+            if (hasCompletedStricterScan(candidate.value, scanPolicy))
+                continue;
+            activeContainers.add(candidate.value);
+            pending.push({ kind: 'leave', container: candidate.value, scanPolicy });
+            for (let index = candidate.value.length - 1; index >= 0; index -= 1) {
+                const child = candidate.value[index];
+                if (candidate.allowedStringArrayField && typeof child === 'string') {
+                    if (isForbiddenReferenceValue(child, true, candidate.allowedStringArrayField.allowDigestLike, options.rejectDigestLikeValues)) {
+                        return true;
+                    }
+                }
+                else {
+                    pending.push({ kind: 'visit', value: child, allowIndexedFields: candidate.allowIndexedFields });
+                }
+            }
+            continue;
+        }
+        if (!isRecord(candidate.value))
+            continue;
+        visitedNodeCount += 1;
+        if (visitedNodeCount > ARTIFACT_CONTROL_DATA_MAX_VISITED_NODES)
+            return true;
+        if (activeContainers.has(candidate.value))
+            return true;
+        const scanPolicy = candidate.allowIndexedFields ? 1 : 0;
+        if (hasCompletedStricterScan(candidate.value, scanPolicy))
+            continue;
+        activeContainers.add(candidate.value);
+        pending.push({ kind: 'leave', container: candidate.value, scanPolicy });
+        for (const [key, child] of Object.entries(candidate.value)) {
+            if (hasControlCharacters(key))
+                return true;
+            const normalizedKey = normalizeFieldName(key);
+            if (FORBIDDEN_PROTOTYPE_FIELDS.has(normalizedKey))
+                return true;
+            if (FORBIDDEN_SENSITIVE_FIELDS.has(normalizedKey))
+                return true;
+            const allowedField = candidate.allowIndexedFields ? allowedReferenceFields.get(candidate.value)?.get(key) : undefined;
+            if (options.forbiddenControlFields?.has(normalizedKey) && !allowedField?.allowControlField)
+                return true;
+            if (options.requireSafeAzureResourceIds && normalizedKey === 'resourceid') {
+                if (!isSafeAzureResourceId(key, child))
+                    return true;
+                continue;
+            }
+            if (allowedField && typeof child === 'string' && (allowedField.allowUriScheme || allowedField.allowDigestLike)) {
+                if (isForbiddenReferenceValue(child, allowedField.allowUriScheme, allowedField.allowDigestLike, options.rejectDigestLikeValues))
+                    return true;
+                continue;
+            }
+            if (allowedField?.allowUriSchemeInStringArray && Array.isArray(child)) {
+                pending.push({ kind: 'visit', value: child, allowedStringArrayField: allowedField });
+                continue;
+            }
+            if (PHYSICAL_REFERENCE_FIELDS.has(normalizedKey) && !allowedField)
+                return true;
+            if (isSafeAzureResourceId(key, child))
+                continue;
+            pending.push({
+                kind: 'visit',
+                value: child,
+                allowIndexedFields: !options.requireAllowedFieldTraversalContext || Boolean(candidate.allowIndexedFields && allowedField?.allowChildArtifactFields),
+            });
+        }
+    }
+    return false;
+};
+/** Rejects normalized sensitive fields and physical-reference control data with bounded traversal. */
+export const containsForbiddenArtifactControlData = (value, allowedReferenceFields = [], options = {}) => containsForbiddenArtifactControlDataWithIndex(value, indexAllowedArtifactFields(allowedReferenceFields), options);

package/dist/esm/common/artifactEvidence.js

@@ -0,0 +1,198 @@
+import { hasValidOptionalArtifactRevisionComponents, isStrictLogicalArtifactReference } from './artifactEvidenceValidation.js';
+const SUPPORT_VERDICTS = new Set(['supported', 'unsupported', 'unknown']);
+const APPLICABILITY_VERDICTS = new Set(['applicable', 'not-applicable', 'unknown']);
+const ATTEMPT_OUTCOMES = new Set([
+    'not-attempted',
+    'queued',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled',
+    'timed-out',
+    'dead-lettered',
+    'superseded',
+]);
+const COVERAGE_VERDICTS = new Set(['complete', 'partial', 'none', 'unknown']);
+const EMPTY_EVIDENCE_VERDICTS = new Set(['populated', 'complete-empty', 'not-observed', 'unknown']);
+const FRESHNESS_VERDICTS = new Set(['current', 'stale', 'expired', 'unknown']);
+const EVIDENCE_VERDICTS = new Set(['complete', 'partial', 'insufficient', 'conflicting']);
+const PROCESSING_LIFECYCLES = new Set(['queued', 'running', 'succeeded', 'failed', 'cancelled', 'timed-out', 'dead-lettered', 'superseded']);
+const PUBLICATION_VERDICTS = new Set(['completed', 'partial', 'suppressed', 'superseded', 'quarantined']);
+const PROVIDERS = new Set(['azure', 'aws']);
+const DATE_BASES = new Set(['utc', 'billing-calendar', 'company-local']);
+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().length > 0;
+const isNonNegativeInteger = (value) => Number.isInteger(value) && value >= 0;
+const isPositiveInteger = (value) => Number.isInteger(value) && value > 0;
+const isStringIn = (value, values) => typeof value === 'string' && values.has(value);
+const isCanonicalIsoTimestamp = (value) => {
+    if (!isNonEmptyString(value))
+        return false;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+};
+const isArtifactDecisionIssue = (value) => isRecord(value) &&
+    isNonEmptyString(value.code) &&
+    typeof value.blocking === 'boolean' &&
+    (value.dependency === undefined || isNonEmptyString(value.dependency));
+const isObservedRange = (value) => {
+    if (!isRecord(value) ||
+        !isCanonicalIsoTimestamp(value.fromInclusive) ||
+        !isCanonicalIsoTimestamp(value.throughExclusive) ||
+        Date.parse(value.throughExclusive) <= Date.parse(value.fromInclusive) ||
+        !isStringIn(value.dateBasis, DATE_BASES)) {
+        return false;
+    }
+    return value.timeZone === undefined || isNonEmptyString(value.timeZone);
+};
+const isArtifactDependencyDescriptor = (value) => {
+    if (!isRecord(value) ||
+        !isNonEmptyString(value.name) ||
+        typeof value.required !== 'boolean' ||
+        !isStringIn(value.support, SUPPORT_VERDICTS) ||
+        !isStringIn(value.applicability, APPLICABILITY_VERDICTS) ||
+        !isStringIn(value.attempt, ATTEMPT_OUTCOMES) ||
+        !isStringIn(value.coverage, COVERAGE_VERDICTS) ||
+        !isStringIn(value.emptyEvidence, EMPTY_EVIDENCE_VERDICTS) ||
+        !isStringIn(value.freshness, FRESHNESS_VERDICTS) ||
+        !isStringIn(value.evidence, EVIDENCE_VERDICTS) ||
+        !isStringIn(value.publication, PUBLICATION_VERDICTS)) {
+        return false;
+    }
+    if (value.generationId !== undefined && !isNonEmptyString(value.generationId))
+        return false;
+    if (value.digest !== undefined && (typeof value.digest !== 'string' || !SHA256_PATTERN.test(value.digest)))
+        return false;
+    if (!hasValidOptionalArtifactRevisionComponents(value))
+        return false;
+    if (value.observedRange !== undefined && !isObservedRange(value.observedRange))
+        return false;
+    if (value.completeThrough !== undefined && !isCanonicalIsoTimestamp(value.completeThrough))
+        return false;
+    if (value.reasonCode !== undefined && !isNonEmptyString(value.reasonCode))
+        return false;
+    if (value.acceptedRowCount !== undefined && !isNonNegativeInteger(value.acceptedRowCount))
+        return false;
+    if (value.emptyEvidence === 'complete-empty') {
+        if (value.attempt !== 'succeeded' ||
+            value.coverage !== 'complete' ||
+            value.acceptedRowCount !== 0 ||
+            !isStrictLogicalArtifactReference(value.emptyProofRef)) {
+            return false;
+        }
+    }
+    else if (value.emptyProofRef !== undefined) {
+        return false;
+    }
+    if (value.publication === 'completed') {
+        return (value.support === 'supported' &&
+            value.applicability === 'applicable' &&
+            value.attempt === 'succeeded' &&
+            value.coverage === 'complete' &&
+            (value.emptyEvidence === 'populated' || value.emptyEvidence === 'complete-empty') &&
+            value.evidence === 'complete');
+    }
+    return true;
+};
+const isArtifactClaimDependencyDecision = (value) => {
+    if (!isRecord(value) ||
+        !isNonEmptyString(value.claimId) ||
+        !Array.isArray(value.sectionPaths) ||
+        !value.sectionPaths.every(isNonEmptyString) ||
+        !Array.isArray(value.requiredDependencies) ||
+        !value.requiredDependencies.every(isNonEmptyString) ||
+        !isStringIn(value.evidence, EVIDENCE_VERDICTS) ||
+        !isStringIn(value.publication, PUBLICATION_VERDICTS) ||
+        !Array.isArray(value.issues) ||
+        !value.issues.every(isArtifactDecisionIssue)) {
+        return false;
+    }
+    return value.publication !== 'completed' || (value.evidence === 'complete' && !value.issues.some(issue => issue.blocking));
+};
+const hasUniqueValues = (values) => new Set(values).size === values.length;
+/** Dependency-free runtime rejection boundary for provider-neutral publication decisions. */
+export const isArtifactPublicationDecision = (value) => {
+    if (!isRecord(value) ||
+        !isStringIn(value.processing, PROCESSING_LIFECYCLES) ||
+        !isStringIn(value.evidence, EVIDENCE_VERDICTS) ||
+        !isStringIn(value.publication, PUBLICATION_VERDICTS) ||
+        !Array.isArray(value.dependencies) ||
+        !value.dependencies.every(isArtifactDependencyDescriptor) ||
+        !Array.isArray(value.claims) ||
+        !value.claims.every(isArtifactClaimDependencyDecision) ||
+        !Array.isArray(value.issues) ||
+        !value.issues.every(isArtifactDecisionIssue)) {
+        return false;
+    }
+    const dependencyNames = value.dependencies.map(dependency => dependency.name);
+    const claimIds = value.claims.map(claim => claim.claimId);
+    if (!hasUniqueValues(dependencyNames) || !hasUniqueValues(claimIds))
+        return false;
+    if (!value.claims.every(claim => hasUniqueValues(claim.requiredDependencies)))
+        return false;
+    if (value.publication !== 'completed')
+        return true;
+    const completedDependencies = new Set(value.dependencies.filter(dependency => dependency.publication === 'completed').map(dependency => dependency.name));
+    return (value.processing === 'succeeded' &&
+        (value.evidence === 'complete' || value.evidence === 'partial') &&
+        value.dependencies.every(dependency => !dependency.required || dependency.publication === 'completed') &&
+        value.claims.every(claim => claim.publication === 'completed' && claim.requiredDependencies.every(dependency => completedDependencies.has(dependency))) &&
+        !value.issues.some(issue => issue.blocking));
+};
+/** Checks the provider-neutral ownership shape used by observe- and enforce-mode artifacts. */
+export const isArtifactOwnershipBinding = (value) => isRecord(value) &&
+    isStringIn(value.provider, PROVIDERS) &&
+    isNonEmptyString(value.tenantId) &&
+    isNonEmptyString(value.companyId) &&
+    isNonEmptyString(value.cloudAccountId) &&
+    isNonEmptyString(value.accountId) &&
+    (value.ownershipEpochRevision === undefined || isPositiveInteger(value.ownershipEpochRevision));
+/** Checks that an ownership binding is valid for enforce-mode publication. */
+export const isEnforceableArtifactOwnershipBinding = (value) => isArtifactOwnershipBinding(value) && value.ownershipEpochRevision !== undefined;
+/**
+ * Compares ownership first, then source and policy revisions component-wise.
+ * Callers must validate both vectors before comparison; this function deliberately compares the supplied values without adding a second validation policy.
+ */
+export const compareArtifactRevisionVector = (left, right) => {
+    if (left.ownershipEpochRevision === undefined || right.ownershipEpochRevision === undefined)
+        return 'unenforceable';
+    if (left.ownershipEpochRevision > right.ownershipEpochRevision)
+        return 'newer-ownership';
+    if (left.ownershipEpochRevision < right.ownershipEpochRevision)
+        return 'older-ownership';
+    const sourceComparison = Math.sign(left.sourceRevision - right.sourceRevision);
+    const policyComparison = Math.sign(left.policyRevision - right.policyRevision);
+    if (sourceComparison === 0 && policyComparison === 0)
+        return 'equal';
+    if (sourceComparison >= 0 && policyComparison >= 0)
+        return 'newer';
+    if (sourceComparison <= 0 && policyComparison <= 0)
+        return 'older';
+    return 'incomparable';
+};
+/**
+ * Compares latest epoch-free authority revisions under a fixed policy revision.
+ * A policy mismatch is intentionally incomparable so a policy rollout cannot
+ * silently reuse source ordering without a separate contract decision.
+ */
+export const compareEpochFreeArtifactRevisionVector = (left, right) => {
+    if (left.ownershipEpochRevision !== undefined || right.ownershipEpochRevision !== undefined)
+        return 'incomparable';
+    if (!Number.isSafeInteger(left.sourceRevision) ||
+        left.sourceRevision < 1 ||
+        !Number.isSafeInteger(right.sourceRevision) ||
+        right.sourceRevision < 1 ||
+        !Number.isSafeInteger(left.policyRevision) ||
+        left.policyRevision < 1 ||
+        !Number.isSafeInteger(right.policyRevision) ||
+        right.policyRevision < 1 ||
+        left.policyRevision !== right.policyRevision) {
+        return 'incomparable';
+    }
+    if (left.sourceRevision > right.sourceRevision)
+        return 'newer';
+    if (left.sourceRevision < right.sourceRevision)
+        return 'older';
+    return 'equal';
+};

package/dist/esm/common/artifactEvidenceValidation.js

@@ -0,0 +1,24 @@
+const hasControlCharacters = (value) => Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+/** Validates a generation-relative logical artifact reference without accepting physical-path encodings. */
+export const isStrictLogicalArtifactReference = (value) => {
+    if (typeof value !== 'string' || value.trim() !== value || value.length === 0 || hasControlCharacters(value))
+        return false;
+    if (value.startsWith('/') || value.includes('\\') || value.includes('%') || value.includes('?') || value.includes('#'))
+        return false;
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(value) || /^[A-Za-z]:[\\/]/.test(value))
+        return false;
+    const segments = value.split('/');
+    return segments.length >= 2 && segments.every(segment => segment.length > 0 && segment !== '.' && segment !== '..');
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isPositiveSafeInteger = (value) => Number.isSafeInteger(value) && Number(value) > 0;
+/** Validates the positive source/policy revision vector shared by evidence producers and consumers. */
+export const isArtifactRevisionVector = (value) => isRecord(value) &&
+    isPositiveSafeInteger(value.sourceRevision) &&
+    isPositiveSafeInteger(value.policyRevision) &&
+    (value.ownershipEpochRevision === undefined || isPositiveSafeInteger(value.ownershipEpochRevision));
+/** Validates optional dependency revision components using the shared revision-vector rules. */
+export const hasValidOptionalArtifactRevisionComponents = (value) => isArtifactRevisionVector({
+    sourceRevision: value.sourceRevision === undefined ? 1 : value.sourceRevision,
+    policyRevision: value.policyRevision === undefined ? 1 : value.policyRevision,
+});

package/dist/esm/common/artifactGeneration.js

@@ -0,0 +1 @@
+export const ARTIFACT_GENERATION_SCHEMA_VERSION = 1;

package/dist/esm/common/capabilityPassport.js

@@ -0,0 +1,206 @@
+import { isArtifactOwnershipBinding, } from './artifactEvidence.js';
+export const CAPABILITY_PASSPORT_SCHEMA_VERSION = 1;
+export const CAPABILITY_REASON_CODES = [
+    'not-requested',
+    'permission-denied',
+    'not-found',
+    'throttled',
+    'timeout',
+    'pagination-incomplete',
+    'source-partial',
+    'source-empty',
+    'source-unsupported',
+    'retained-last-known-good',
+    'currency-unresolved',
+    'unknown',
+];
+const REASON_CODES = new Set(CAPABILITY_REASON_CODES);
+const AGREEMENT_TYPES = new Set(['EA', 'MCA', 'CSP', 'PAYG-MOSP', 'sponsored-trial', 'unknown']);
+const AGREEMENT_SOURCES = new Set(['observed', 'configured', 'unknown']);
+const AVAILABILITY_VALUES = new Set(['available', 'partial', 'missing', 'unavailable', 'unknown']);
+const EMPTY_EVIDENCE_VALUES = new Set(['populated', 'complete-empty', 'not-observed', 'unknown']);
+const PROVIDER_OUTCOMES = new Set(['accepted', 'authoritatively-unsupported', 'unknown']);
+const ATTEMPT_OUTCOMES = new Set(['succeeded', 'failed', 'partial']);
+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().length > 0;
+const isNonNegativeInteger = (value) => Number.isInteger(value) && value >= 0;
+const isPositiveInteger = (value) => Number.isInteger(value) && value > 0;
+const isCanonicalIsoTimestamp = (value) => {
+    if (!isNonEmptyString(value))
+        return false;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+};
+const isLogicalArtifactRef = (value) => {
+    if (!isNonEmptyString(value) || value.startsWith('/') || value.includes('://') || value.includes('?') || value.includes('#'))
+        return false;
+    if (value.includes('\\'))
+        return false;
+    const segments = value.split('/');
+    return segments.length >= 2 && segments.every(segment => segment.length > 0 && segment !== '.' && segment !== '..');
+};
+const isSubscriptionBoundResourceId = (value, subscriptionId) => {
+    if (!isNonEmptyString(value))
+        return false;
+    const segments = value.split('/');
+    return (segments.length >= 4 &&
+        segments[0] === '' &&
+        segments[1]?.toLowerCase() === 'subscriptions' &&
+        segments[2]?.toLowerCase() === subscriptionId.toLowerCase());
+};
+const isReasonCode = (value) => typeof value === 'string' && REASON_CODES.has(value);
+const isImmutableSourceGeneration = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (!isLogicalArtifactRef(value.artifactRef) ||
+        !isNonEmptyString(value.generationId) ||
+        typeof value.sha256 !== 'string' ||
+        !SHA256_PATTERN.test(value.sha256) ||
+        !isPositiveInteger(value.schemaVersion) ||
+        !isCanonicalIsoTimestamp(value.producedAt)) {
+        return false;
+    }
+    return value.completeThrough === undefined || isCanonicalIsoTimestamp(value.completeThrough);
+};
+const isScopeBinding = (value, ownership) => {
+    if (!isRecord(value) || value.provider !== ownership.provider || value.tenantId !== ownership.tenantId)
+        return false;
+    if (value.kind === 'tenant')
+        return true;
+    if (value.kind === 'billing-account')
+        return isNonEmptyString(value.billingAccountId);
+    if (value.kind === 'customer')
+        return isNonEmptyString(value.customerId);
+    if (value.kind === 'subscription')
+        return value.subscriptionId === ownership.subscriptionId;
+    return (value.kind === 'resource' &&
+        value.subscriptionId === ownership.subscriptionId &&
+        isSubscriptionBoundResourceId(value.normalizedResourceId, ownership.subscriptionId));
+};
+const isAttempt = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (value.status === 'not-attempted')
+        return isReasonCode(value.reasonCode);
+    if (value.status !== 'attempted' || !isCanonicalIsoTimestamp(value.startedAt) || !isCanonicalIsoTimestamp(value.completedAt))
+        return false;
+    if (Date.parse(value.completedAt) < Date.parse(value.startedAt) || typeof value.outcome !== 'string' || !ATTEMPT_OUTCOMES.has(value.outcome)) {
+        return false;
+    }
+    return Array.isArray(value.reasonCodes) && value.reasonCodes.every(isReasonCode);
+};
+const isFreshness = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (value.status === 'unknown')
+        return true;
+    if ((value.status !== 'current' && value.status !== 'stale') || !isCanonicalIsoTimestamp(value.observedAt))
+        return false;
+    if (value.completeThrough !== undefined && !isCanonicalIsoTimestamp(value.completeThrough))
+        return false;
+    return value.status !== 'stale' || isNonEmptyString(value.maximumAge);
+};
+const isObservation = (value, ownership) => {
+    if (!isRecord(value))
+        return false;
+    if (!isNonEmptyString(value.observationId) || !isNonEmptyString(value.capability) || !isScopeBinding(value.scope, ownership))
+        return false;
+    if (!isAttempt(value.attempt) || typeof value.providerSurfaceOutcome !== 'string' || !PROVIDER_OUTCOMES.has(value.providerSurfaceOutcome)) {
+        return false;
+    }
+    if (typeof value.availability !== 'string' || !AVAILABILITY_VALUES.has(value.availability))
+        return false;
+    if (typeof value.emptyEvidence !== 'string' || !EMPTY_EVIDENCE_VALUES.has(value.emptyEvidence) || !isFreshness(value.freshness))
+        return false;
+    if (value.sourceGeneration !== undefined && !isImmutableSourceGeneration(value.sourceGeneration))
+        return false;
+    if (value.coverageRef !== undefined && !isLogicalArtifactRef(value.coverageRef))
+        return false;
+    if (value.emptyEvidence === 'complete-empty') {
+        if (value.availability !== 'available' || value.attempt.status !== 'attempted' || value.attempt.outcome !== 'succeeded')
+            return false;
+    }
+    if (value.limits !== undefined) {
+        if (!isRecord(value.limits))
+            return false;
+        if (value.limits.expectedPages !== undefined && !isNonNegativeInteger(value.limits.expectedPages))
+            return false;
+        if (value.limits.receivedPages !== undefined && !isNonNegativeInteger(value.limits.receivedPages))
+            return false;
+        if (value.limits.throttled !== undefined && typeof value.limits.throttled !== 'boolean')
+            return false;
+        if (value.limits.retainedLastKnownGood !== undefined && typeof value.limits.retainedLastKnownGood !== 'boolean')
+            return false;
+    }
+    return true;
+};
+const isOwnership = (value) => isArtifactOwnershipBinding(value) && 'subscriptionId' in value && isNonEmptyString(value.subscriptionId);
+const isObservationSet = (value, ownership) => {
+    if (!isRecord(value) || !isNonNegativeInteger(value.totalCount))
+        return false;
+    if (value.mode === 'inline') {
+        if (!Array.isArray(value.items) || value.items.length !== value.totalCount || !value.items.every(item => isObservation(item, ownership))) {
+            return false;
+        }
+        const observationIds = value.items.map(item => item.observationId);
+        return new Set(observationIds).size === observationIds.length;
+    }
+    if (value.mode !== 'sharded' ||
+        !isNonNegativeInteger(value.shardCount) ||
+        !isLogicalArtifactRef(value.indexRef) ||
+        !Array.isArray(value.shards) ||
+        value.shards.length !== value.shardCount) {
+        return false;
+    }
+    let total = 0;
+    const refs = new Set();
+    for (const shard of value.shards) {
+        if (!isRecord(shard) ||
+            !isLogicalArtifactRef(shard.artifactRef) ||
+            typeof shard.sha256 !== 'string' ||
+            !SHA256_PATTERN.test(shard.sha256) ||
+            !isPositiveInteger(shard.itemCount) ||
+            refs.has(shard.artifactRef)) {
+            return false;
+        }
+        refs.add(shard.artifactRef);
+        total += shard.itemCount;
+    }
+    return total === value.totalCount;
+};
+/** Dependency-free runtime rejection boundary for Capability Passport schema v1. */
+export const isCapabilityPassport = (value) => {
+    if (!isRecord(value) || value.schemaVersion !== CAPABILITY_PASSPORT_SCHEMA_VERSION)
+        return false;
+    if (!isNonEmptyString(value.passportId) || !isNonEmptyString(value.runId) || !isCanonicalIsoTimestamp(value.generatedAt))
+        return false;
+    if (!isOwnership(value.ownership))
+        return false;
+    if (!isRecord(value.agreementObservation))
+        return false;
+    if (typeof value.agreementObservation.type !== 'string' ||
+        !AGREEMENT_TYPES.has(value.agreementObservation.type) ||
+        typeof value.agreementObservation.source !== 'string' ||
+        !AGREEMENT_SOURCES.has(value.agreementObservation.source) ||
+        (value.agreementObservation.sourceGeneration !== undefined && !isImmutableSourceGeneration(value.agreementObservation.sourceGeneration))) {
+        return false;
+    }
+    if (!isObservationSet(value.observations, value.ownership))
+        return false;
+    if (!isRecord(value.producerVersions) || Object.keys(value.producerVersions).length === 0)
+        return false;
+    if (!Object.entries(value.producerVersions).every(([name, version]) => isNonEmptyString(name) && isNonEmptyString(version)))
+        return false;
+    if (!Array.isArray(value.issues) ||
+        !value.issues.every(issue => isRecord(issue) && isReasonCode(issue.reasonCode) && (issue.observationId === undefined || isNonEmptyString(issue.observationId)))) {
+        return false;
+    }
+    if (value.observations.mode === 'inline') {
+        const observationIds = new Set(value.observations.items.map(item => item.observationId));
+        if (!value.issues.every(issue => issue.observationId === undefined || (isNonEmptyString(issue.observationId) && observationIds.has(issue.observationId)))) {
+            return false;
+        }
+    }
+    return true;
+};