@serve.zone/interfaces 11.2.0 → 11.4.0

package/changelog.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 2026-07-19 - 11.4.0
+
+### Features
+
+- define least-privilege greenfield deployment preflight contracts (deployment)
+  - Add server-persisted, service-scoped machine capabilities without broad cluster authority.
+  - Define sanitized GO/NO-GO inventory for OCI indexes, runtime digests, Corestore bindings, and namespace collisions.
+  - Bind release evidence and future durable operations to source, version, image, configuration, and namespace digests.
+
+### Maintenance
+
+- replace the broken pnpm 11.13.0 executable pin with pnpm 11.15.0.
+
+## 2026-07-18 - 11.3.0
+
+### Features
+
+- define fail-closed immutable image deployment and runtime evidence contracts (deployment)
+  - Separate observed registry releases, accepted digest rollouts, and exact-digest rollback plans.
+  - Require task-derived Docker runtime evidence and complete healthy replica reports before rollout success.
+  - Add idempotent promotion, compare-and-swap rollback, capability, ordering, and mismatch contracts.
+
 ## 2026-07-15 - 11.2.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '11.2.0',
+    version: '11.4.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/deployment.d.ts

@@ -1,3 +1,4 @@
+import type { IRuntimeImageEvidence } from './immutableimage.js';
 /**
  * a deployment happens when a service is deployed
  * tracks the status of a deployment
@@ -28,6 +29,11 @@ export interface IDeployment {
     slot?: number;
     /** Docker desired state for this task/deployment. */
     desiredState?: string;
+    /** Immutable rollout generation represented by this task, when applicable. */
+    rolloutId?: string;
+    rolloutGeneration?: number;
+    /** Evidence derived from Docker runtime state rather than service intent metadata. */
+    runtimeImageEvidence?: IRuntimeImageEvidence;
     /**
      * Image used for this deployment
      */

package/dist_ts/data/deploymentpreflight.d.ts

@@ -0,0 +1,142 @@
+import type { TOciManifestMediaType, TSha256Digest } from './immutableimage.js';
+import type { TServiceDeploymentCapability } from './user.js';
+export type TDeploymentPreflightDecision = 'GO' | 'NO-GO';
+export type TDeploymentPreflightBlockerCode = 'INVALID_REQUEST' | 'AUTHORIZATION_MISSING' | 'SOURCE_REVISION_INVALID' | 'VERSION_NOT_RESERVED' | 'VERSION_COLLISION' | 'NAMESPACE_NOT_RESERVED' | 'NAMESPACE_COLLISION' | 'NAMESPACE_NOT_PROVEN_BLANK' | 'CONFIGURATION_DIGEST_INVALID' | 'CURRENT_REFERENCE_MUTABLE' | 'CURRENT_RUNTIME_DIGEST_MISSING' | 'OCI_INDEX_DIGEST_REQUIRED' | 'OCI_INDEX_NOT_FOUND' | 'OCI_INDEX_MEDIA_TYPE_REQUIRED' | 'OCI_PLATFORM_MISSING' | 'OCI_PLATFORM_MANIFEST_MISSING' | 'IMMUTABLE_RELEASE_TAG_REQUIRED' | 'IMMUTABLE_RELEASE_TAG_NOT_RESERVED' | 'RELEASE_EVIDENCE_MISSING' | 'RELEASE_EVIDENCE_INVALID' | 'RELEASE_NOT_AUTHORIZED' | 'GREENFIELD_EXECUTION_UNAVAILABLE' | 'ROUTE_PROMOTION_FENCE_UNAVAILABLE' | 'POST_DEPLOYMENT_VERIFICATION_UNAVAILABLE' | 'WOULD_REPLACE_EXISTING_STATE' | 'CORESTORE_INVENTORY_UNAVAILABLE' | 'RUNTIME_ATTESTATION_MISMATCH';
+export interface IDeploymentPreflightBlocker {
+    code: TDeploymentPreflightBlockerCode;
+    message: string;
+}
+export interface IDeploymentPreflightAuthorizationCheck {
+    capability: TServiceDeploymentCapability;
+    granted: boolean;
+}
+export interface IOciPlatformDescriptorSummary {
+    os: string;
+    architecture: string;
+    digest?: TSha256Digest;
+    mediaType?: string;
+    runnable: boolean;
+    manifestPresent: boolean;
+}
+export interface IDeploymentPreflightRuntimeTask {
+    deploymentId: string;
+    nodeName?: string;
+    status: string;
+    healthStatus?: string;
+    imageReference?: string;
+    reportedDigest?: TSha256Digest;
+    verificationStatus?: 'not-required' | 'pending' | 'verified' | 'missing' | 'mismatched';
+}
+export interface IDeploymentPreflightPlatformBinding {
+    capability: 'database' | 'objectstorage';
+    desiredState: 'enabled' | 'disabled';
+    status: 'requested' | 'provisioning' | 'ready' | 'degraded' | 'failed' | 'disabled';
+}
+export interface IDeploymentPreflightCorestoreResource {
+    capability: 'database' | 'objectstorage';
+    provider: string;
+    resourceName: string;
+}
+export interface IDeploymentReleaseEvidenceReference {
+    kind: 'provenance' | 'sbom' | 'signature' | 'vulnerability-policy' | 'release-authorization';
+    statementDigest: TSha256Digest;
+    subjectDigest: TSha256Digest;
+    verifier: string;
+    verifiedAt: number;
+}
+/** Evidence is descriptive input until a trusted Cloudly verifier validates it. */
+export interface IDeploymentReleaseEvidence {
+    sourceRevision: string;
+    version: string;
+    configurationDigest: TSha256Digest;
+    ociIndexDigest: TSha256Digest;
+    releaseAuthorized: boolean;
+    attestations: IDeploymentReleaseEvidenceReference[];
+}
+export interface IDeploymentPreflightRequestData {
+    requestId: string;
+    serviceId: string;
+    sourceRevision: string;
+    version: string;
+    configurationDigest: string;
+    proposedNamespace: string;
+    ociIndexDigest?: string;
+    releaseTag?: string;
+    releaseEvidence?: IDeploymentReleaseEvidence;
+    greenfield: true;
+}
+export interface IDeploymentPreflightReport {
+    schemaVersion: 1;
+    decision: TDeploymentPreflightDecision;
+    mutationPerformed: false;
+    generatedAt: number;
+    service: {
+        serviceId: string;
+        serviceName: string;
+        workspaceIdentity: string;
+        registryRepository: string;
+        deployOnPush: boolean;
+    };
+    source: {
+        revision: string;
+        version: string;
+        configurationDigest?: TSha256Digest;
+    };
+    currentImage: {
+        tag?: string;
+        digest?: TSha256Digest;
+        imageReference?: string;
+        mutableReference: boolean;
+        mediaType?: TOciManifestMediaType;
+        platforms: IOciPlatformDescriptorSummary[];
+    };
+    requestedImage: {
+        digest?: TSha256Digest;
+        releaseTag?: string;
+        tagReserved: boolean;
+        mediaType?: TOciManifestMediaType;
+        platforms: IOciPlatformDescriptorSummary[];
+    };
+    runtimeTasks: IDeploymentPreflightRuntimeTask[];
+    platformBindings: IDeploymentPreflightPlatformBinding[];
+    corestoreResources: IDeploymentPreflightCorestoreResource[];
+    proposed: {
+        namespace: string;
+        namespaceReserved: boolean;
+        namespaceBlank: boolean;
+        versionReserved: boolean;
+        wouldReplaceExistingState: boolean;
+    };
+    authorizationChecks: IDeploymentPreflightAuthorizationCheck[];
+    compatibilityBlockers: IDeploymentPreflightBlocker[];
+}
+export interface IGreenfieldDeploymentFence {
+    sourceServiceId: string;
+    sourceRevision: string;
+    version: string;
+    ociIndexDigest: TSha256Digest;
+    configurationDigest: TSha256Digest;
+    targetNamespace: string;
+}
+export interface IGreenfieldDeploymentOperation {
+    id: string;
+    data: {
+        idempotencyKey: string;
+        requestDigest: TSha256Digest;
+        fence: IGreenfieldDeploymentFence;
+        candidateServiceId?: string;
+        state: 'reserved' | 'provisioning' | 'deploying' | 'verifying' | 'ready-for-promotion' | 'promoting' | 'promoted' | 'rolling-back' | 'rolled-back' | 'failed';
+        routeGeneration?: number;
+        createdAt: number;
+        updatedAt: number;
+        failureCode?: string;
+    };
+}
+export declare const validateDeploymentPreflightRequest: (requestArg: unknown) => IDeploymentPreflightBlocker[];
+export declare const validateDeploymentReleaseEvidence: (argsArg: {
+    evidence: unknown;
+    sourceRevision: string;
+    version: string;
+    configurationDigest: TSha256Digest;
+    ociIndexDigest: TSha256Digest;
+}) => IDeploymentPreflightBlocker[];

package/dist_ts/data/deploymentpreflight.js

@@ -0,0 +1,93 @@
+import { normalizeSha256Digest } from './immutableimage.js';
+const fullGitRevisionRegex = /^[a-f0-9]{40}$/;
+const namespaceRegex = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const requiredEvidenceKinds = new Set([
+    'provenance',
+    'sbom',
+    'signature',
+    'vulnerability-policy',
+    'release-authorization',
+]);
+const isRecord = (valueArg) => Boolean(valueArg) && typeof valueArg === 'object' && !Array.isArray(valueArg);
+export const validateDeploymentPreflightRequest = (requestArg) => {
+    const blockers = [];
+    if (!isRecord(requestArg)) {
+        return [{ code: 'INVALID_REQUEST', message: 'Deployment preflight request must be an object.' }];
+    }
+    if (typeof requestArg.requestId !== 'string' || !requestArg.requestId.trim() || requestArg.requestId.length > 200) {
+        blockers.push({ code: 'INVALID_REQUEST', message: 'A bounded request identifier is required.' });
+    }
+    if (typeof requestArg.serviceId !== 'string' || !requestArg.serviceId.trim() || requestArg.serviceId.length > 200) {
+        blockers.push({ code: 'INVALID_REQUEST', message: 'A bounded service identifier is required.' });
+    }
+    if (typeof requestArg.sourceRevision !== 'string' || !fullGitRevisionRegex.test(requestArg.sourceRevision)) {
+        blockers.push({ code: 'SOURCE_REVISION_INVALID', message: 'Source revision must be a full lower-case Git commit SHA.' });
+    }
+    if (typeof requestArg.version !== 'string' || !requestArg.version.trim() || requestArg.version.length > 100) {
+        blockers.push({ code: 'VERSION_NOT_RESERVED', message: 'A bounded release version is required.' });
+    }
+    if (typeof requestArg.proposedNamespace !== 'string' || !namespaceRegex.test(requestArg.proposedNamespace)) {
+        blockers.push({ code: 'NAMESPACE_NOT_RESERVED', message: 'The proposed namespace is missing or malformed.' });
+    }
+    if (typeof requestArg.configurationDigest !== 'string' || !normalizeSha256Digest(requestArg.configurationDigest)) {
+        blockers.push({ code: 'CONFIGURATION_DIGEST_INVALID', message: 'Configuration digest must be a canonical sha256 digest.' });
+    }
+    if (requestArg.ociIndexDigest !== undefined
+        && (typeof requestArg.ociIndexDigest !== 'string' || !normalizeSha256Digest(requestArg.ociIndexDigest))) {
+        blockers.push({ code: 'OCI_INDEX_DIGEST_REQUIRED', message: 'OCI index digest must be a canonical sha256 digest.' });
+    }
+    if (requestArg.greenfield !== true) {
+        blockers.push({ code: 'WOULD_REPLACE_EXISTING_STATE', message: 'Only greenfield deployment preflight is supported.' });
+    }
+    return blockers;
+};
+export const validateDeploymentReleaseEvidence = (argsArg) => {
+    const blockers = [];
+    if (!isRecord(argsArg.evidence)) {
+        return [{ code: 'RELEASE_EVIDENCE_INVALID', message: 'Release evidence must be an object.' }];
+    }
+    const evidence = argsArg.evidence;
+    if (evidence.releaseAuthorized !== true) {
+        blockers.push({ code: 'RELEASE_NOT_AUTHORIZED', message: 'Release authorization evidence is explicitly false.' });
+    }
+    if (evidence.sourceRevision !== argsArg.sourceRevision
+        || evidence.version !== argsArg.version
+        || evidence.configurationDigest !== argsArg.configurationDigest
+        || evidence.ociIndexDigest !== argsArg.ociIndexDigest) {
+        blockers.push({ code: 'RELEASE_EVIDENCE_INVALID', message: 'Release evidence is not bound to the requested deployment fence.' });
+    }
+    const seenKinds = new Set();
+    const attestations = Array.isArray(evidence.attestations) ? evidence.attestations : [];
+    if (!Array.isArray(evidence.attestations)) {
+        blockers.push({ code: 'RELEASE_EVIDENCE_INVALID', message: 'Release attestations must be an array.' });
+    }
+    for (const attestation of attestations) {
+        if (!isRecord(attestation)) {
+            blockers.push({ code: 'RELEASE_EVIDENCE_INVALID', message: 'Release attestation must be an object.' });
+            continue;
+        }
+        const kind = attestation.kind;
+        if (typeof kind !== 'string' || !requiredEvidenceKinds.has(kind)) {
+            blockers.push({ code: 'RELEASE_EVIDENCE_INVALID', message: 'Release attestation kind is invalid.' });
+            continue;
+        }
+        seenKinds.add(kind);
+        if (attestation.subjectDigest !== argsArg.ociIndexDigest
+            || typeof attestation.statementDigest !== 'string'
+            || !normalizeSha256Digest(attestation.statementDigest)
+            || typeof attestation.verifier !== 'string'
+            || !attestation.verifier.trim()
+            || typeof attestation.verifiedAt !== 'number'
+            || !Number.isSafeInteger(attestation.verifiedAt)
+            || attestation.verifiedAt < 1) {
+            blockers.push({ code: 'RELEASE_EVIDENCE_INVALID', message: `Invalid ${kind} evidence.` });
+        }
+    }
+    for (const requiredKind of requiredEvidenceKinds) {
+        if (!seenKinds.has(requiredKind)) {
+            blockers.push({ code: 'RELEASE_EVIDENCE_MISSING', message: `Missing ${requiredKind} evidence.` });
+        }
+    }
+    return blockers;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/data/image.d.ts

@@ -1,4 +1,4 @@
-import type { IRegistryPushEvent } from './registry.js';
+import type { IImmutableRegistryPushEvent, IRegistryPushEvent } from './registry.js';
 export interface IImage {
     id: string;
     data: {
@@ -13,6 +13,8 @@ export interface IImage {
         versions: Array<{
             versionString: string;
             digest?: string;
+            releaseId?: string;
+            manifestMediaType?: string;
             registryRepository?: string;
             registryTag?: string;
             source?: 'upload' | 'registry';
@@ -20,6 +22,6 @@ export interface IImage {
             size: number;
             createdAt: number;
         }>;
-        lastPushEvent?: IRegistryPushEvent;
+        lastPushEvent?: IRegistryPushEvent | IImmutableRegistryPushEvent;
     };
 }

package/dist_ts/data/immutableimage.d.ts

@@ -0,0 +1,145 @@
+/** Canonical lower-case OCI sha256 digest. */
+export type TSha256Digest = `sha256:${string}`;
+export type TImageDeploymentPolicy = 'legacy-tag' | 'immutable-digest';
+export type TOciManifestMediaType = 'application/vnd.oci.image.index.v1+json' | 'application/vnd.oci.image.manifest.v1+json' | 'application/vnd.docker.distribution.manifest.list.v2+json' | 'application/vnd.docker.distribution.manifest.v2+json';
+export type TImmutableImageRolloutMode = 'promotion' | 'automatic' | 'rollback';
+export type TImmutableImageMismatchReason = 'immutable-plan-missing' | 'requested-digest-missing' | 'requested-digest-malformed' | 'registry-digest-inconsistent' | 'runtime-capability-missing' | 'pull-failed' | 'pulled-digest-missing' | 'pulled-digest-mismatch' | 'service-image-not-digest-pinned' | 'service-image-digest-mismatch' | 'task-image-not-digest-pinned' | 'task-image-digest-mismatch' | 'container-inspection-unavailable' | 'container-image-id-missing' | 'container-repodigest-missing' | 'container-repodigest-mismatch' | 'runtime-attestation-missing' | 'required-replica-missing' | 'replica-unhealthy' | 'replica-failed' | 'stale-rollout-report' | 'rollback-target-not-accepted';
+export type TRuntimeImageVerificationStatus = 'not-required' | 'pending' | 'verified' | 'missing' | 'mismatched';
+export type TImmutableImageRolloutStatus = 'pending' | 'deploying' | 'verifying' | 'succeeded' | 'failed' | 'mismatched' | 'rolling-back' | 'rolled-back';
+export interface ICoreflowRuntimeCapabilities {
+    immutableImageDeploymentVersion: 1;
+}
+/**
+ * A registry manifest observed by Cloudly. Observation alone does not make the
+ * release deployable: acceptedAt is set only by an explicit promotion or a
+ * configured automatic promotion.
+ */
+export interface IImageRelease {
+    id: string;
+    data: {
+        serviceId: string;
+        imageId: string;
+        registryHost: string;
+        repository: string;
+        /** Digest of the registry root descriptor, preserving an index/list when submitted. */
+        registryRootDigest: TSha256Digest;
+        digestPinnedImageReference: string;
+        manifestMediaType: TOciManifestMediaType;
+        observedTags: string[];
+        firstObservedAt: number;
+        lastObservedAt: number;
+        observationCount: number;
+        acceptedAt?: number;
+        lastPromotedAt?: number;
+        promotionCount?: number;
+    };
+}
+export interface IImmutableImageTargetScope {
+    targetClusterIds: string[];
+    targetNodeNames: string[];
+    replicasPerNode: number;
+    requiredReplicaCount: number;
+}
+/** Immutable desired state issued by Cloudly and consumed by Coreflow. */
+export interface IImmutableImageDeploymentPlan {
+    policy: 'immutable-digest';
+    rolloutId: string;
+    rolloutGeneration: number;
+    releaseId: string;
+    registryHost: string;
+    repository: string;
+    requestedDigest: TSha256Digest;
+    digestPinnedImageReference: string;
+    manifestMediaType: TOciManifestMediaType;
+    createdAt: number;
+    mode: TImmutableImageRolloutMode;
+    rollbackOfRolloutId?: string;
+    targetScope: IImmutableImageTargetScope;
+}
+/** Runtime evidence collected from Docker service, task, container and image state. */
+interface IRuntimeImageEvidenceBase {
+    rolloutId?: string;
+    rolloutGeneration?: number;
+    expectedDigest?: TSha256Digest;
+    serviceImageReference?: string;
+    taskImageReference?: string;
+    taskReportedDigest?: TSha256Digest;
+    containerImageId?: string;
+    containerConfigImageReference?: string;
+    resolvedDigest?: TSha256Digest;
+    platformManifestDigest?: TSha256Digest;
+    repoDigests?: string[];
+    evidenceSource?: 'task-spec' | 'local-container-inspect';
+    observedAt: number;
+}
+export interface IVerifiedRuntimeImageEvidence extends IRuntimeImageEvidenceBase {
+    verificationStatus: 'verified';
+    rolloutId: string;
+    rolloutGeneration: number;
+    expectedDigest: TSha256Digest;
+    serviceImageReference: string;
+    taskImageReference: string;
+    taskReportedDigest: TSha256Digest;
+    containerImageId: string;
+    containerConfigImageReference: string;
+    resolvedDigest: TSha256Digest;
+    repoDigests: string[];
+    evidenceSource: 'local-container-inspect';
+    mismatchReason?: never;
+}
+export interface IUnverifiedRuntimeImageEvidence extends IRuntimeImageEvidenceBase {
+    verificationStatus: 'missing' | 'mismatched';
+    mismatchReason: TImmutableImageMismatchReason;
+}
+export interface IPendingRuntimeImageEvidence extends IRuntimeImageEvidenceBase {
+    verificationStatus: 'pending' | 'not-required';
+    mismatchReason?: never;
+}
+export type IRuntimeImageEvidence = IVerifiedRuntimeImageEvidence | IUnverifiedRuntimeImageEvidence | IPendingRuntimeImageEvidence;
+/** Mandatory security envelope when reporting an immutable rollout. */
+export interface IImmutableRolloutReportEnvelope {
+    rolloutId: string;
+    rolloutGeneration: number;
+    reporterSessionId: string;
+    reportSequence: number;
+    reporterCapabilities: ICoreflowRuntimeCapabilities;
+    reporterNodeIds: string[];
+    reporterNodeNames: string[];
+}
+export interface IImageRolloutReporterStatus {
+    reporterId: string;
+    reporterSessionId: string;
+    clusterId: string;
+    reporterNodeNames: string[];
+    rolloutId: string;
+    rolloutGeneration: number;
+    reportSequence: number;
+    reportedAt: number;
+    requiredReplicaCount: number;
+    observedReplicaCount: number;
+    healthyReplicaCount: number;
+    verifiedReplicaCount: number;
+    failedReplicaCount: number;
+    mismatchReason?: TImmutableImageMismatchReason;
+}
+export interface IImageRolloutStatus {
+    rolloutId: string;
+    rolloutGeneration: number;
+    expectedDigest: TSha256Digest;
+    status: TImmutableImageRolloutStatus;
+    requiredReplicaCount: number;
+    observedReplicaCount: number;
+    healthyReplicaCount: number;
+    verifiedReplicaCount: number;
+    failedReplicaCount: number;
+    mismatchReason?: TImmutableImageMismatchReason;
+    updatedAt: number;
+    reporters: IImageRolloutReporterStatus[];
+}
+export declare const normalizeSha256Digest: (digest: string) => TSha256Digest | undefined;
+export declare const isSha256Digest: (digest: string) => digest is TSha256Digest;
+export declare const buildDigestPinnedImageReference: (registryHost: string, repository: string, digest: TSha256Digest) => string;
+export declare const getDigestFromPinnedImageReference: (imageReference: string) => TSha256Digest | undefined;
+export declare const validateImmutableImageDeploymentPlan: (planArg: IImmutableImageDeploymentPlan) => string[];
+export declare const validateImageRolloutStatus: (statusArg: IImageRolloutStatus) => string[];
+export {};

package/dist_ts/data/immutableimage.js

@@ -0,0 +1,146 @@
+const sha256DigestRegex = /^sha256:[a-f0-9]{64}$/;
+export const normalizeSha256Digest = (digest) => {
+    const normalizedDigest = digest.trim().toLowerCase();
+    return sha256DigestRegex.test(normalizedDigest)
+        ? normalizedDigest
+        : undefined;
+};
+export const isSha256Digest = (digest) => sha256DigestRegex.test(digest);
+const registryHostRegex = /^(?:localhost|[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?)(?::[1-9][0-9]{0,4})?$/;
+const repositoryRegex = /^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/;
+export const buildDigestPinnedImageReference = (registryHost, repository, digest) => {
+    if (!registryHostRegex.test(registryHost) || !repositoryRegex.test(repository)) {
+        throw new Error('registry host and repository must be canonical OCI names');
+    }
+    if (!isSha256Digest(digest)) {
+        throw new Error('digest must be a canonical sha256 digest');
+    }
+    return `${registryHost}/${repository}@${digest}`;
+};
+export const getDigestFromPinnedImageReference = (imageReference) => {
+    const separatorIndex = imageReference.lastIndexOf('@');
+    if (separatorIndex < 0) {
+        return undefined;
+    }
+    return normalizeSha256Digest(imageReference.slice(separatorIndex + 1));
+};
+export const validateImmutableImageDeploymentPlan = (planArg) => {
+    const errors = [];
+    if (!Number.isSafeInteger(planArg.rolloutGeneration) || planArg.rolloutGeneration < 1) {
+        errors.push('rolloutGeneration must be a positive safe integer');
+    }
+    if (!Number.isSafeInteger(planArg.createdAt) || planArg.createdAt < 1) {
+        errors.push('createdAt must be a positive safe integer');
+    }
+    let expectedReference;
+    try {
+        expectedReference = buildDigestPinnedImageReference(planArg.registryHost, planArg.repository, planArg.requestedDigest);
+    }
+    catch (error) {
+        errors.push(error.message);
+    }
+    if (expectedReference && planArg.digestPinnedImageReference !== expectedReference) {
+        errors.push('digestPinnedImageReference does not match registry, repository and digest');
+    }
+    const scope = planArg.targetScope;
+    if (!Number.isSafeInteger(scope.replicasPerNode) || scope.replicasPerNode < 1) {
+        errors.push('replicasPerNode must be a positive safe integer');
+    }
+    if (scope.targetClusterIds.length < 1 || scope.targetNodeNames.length < 1) {
+        errors.push('immutable rollout target scope must contain clusters and nodes');
+    }
+    if (new Set(scope.targetClusterIds).size !== scope.targetClusterIds.length
+        || new Set(scope.targetNodeNames).size !== scope.targetNodeNames.length) {
+        errors.push('immutable rollout target scope must not contain duplicates');
+    }
+    if (scope.requiredReplicaCount !== scope.targetNodeNames.length * scope.replicasPerNode) {
+        errors.push('requiredReplicaCount does not match target nodes and replicasPerNode');
+    }
+    if (planArg.mode === 'rollback' && !planArg.rollbackOfRolloutId) {
+        errors.push('rollback rollout must identify the rollout it replaces');
+    }
+    if (planArg.mode !== 'rollback' && planArg.rollbackOfRolloutId) {
+        errors.push('only rollback rollouts may set rollbackOfRolloutId');
+    }
+    return errors;
+};
+export const validateImageRolloutStatus = (statusArg) => {
+    const errors = [];
+    const counts = [
+        statusArg.requiredReplicaCount,
+        statusArg.observedReplicaCount,
+        statusArg.healthyReplicaCount,
+        statusArg.verifiedReplicaCount,
+        statusArg.failedReplicaCount,
+    ];
+    if (counts.some((countArg) => !Number.isSafeInteger(countArg) || countArg < 0)) {
+        errors.push('rollout replica counts must be non-negative safe integers');
+    }
+    const reporterIds = statusArg.reporters.map((reporterArg) => reporterArg.reporterId);
+    const reporterSessionIds = statusArg.reporters.map((reporterArg) => reporterArg.reporterSessionId);
+    const reporterNodeNames = statusArg.reporters.flatMap((reporterArg) => reporterArg.reporterNodeNames);
+    if (new Set(reporterIds).size !== reporterIds.length
+        || new Set(reporterSessionIds).size !== reporterSessionIds.length) {
+        errors.push('rollout status must contain one latest report per reporter and session');
+    }
+    for (const reporter of statusArg.reporters) {
+        const reporterCounts = [
+            reporter.requiredReplicaCount,
+            reporter.observedReplicaCount,
+            reporter.healthyReplicaCount,
+            reporter.verifiedReplicaCount,
+            reporter.failedReplicaCount,
+        ];
+        if (reporterCounts.some((countArg) => !Number.isSafeInteger(countArg) || countArg < 0)) {
+            errors.push('reporter replica counts must be non-negative safe integers');
+        }
+        if (reporter.rolloutId !== statusArg.rolloutId
+            || reporter.rolloutGeneration !== statusArg.rolloutGeneration) {
+            errors.push('reporter rollout identity does not match aggregate rollout identity');
+        }
+        if (reporter.observedReplicaCount > reporter.requiredReplicaCount
+            || reporter.healthyReplicaCount > reporter.observedReplicaCount
+            || reporter.verifiedReplicaCount > reporter.observedReplicaCount) {
+            errors.push('reporter replica counts are contradictory');
+        }
+    }
+    if (statusArg.status === 'succeeded' || statusArg.status === 'rolled-back') {
+        if (statusArg.requiredReplicaCount < 1
+            || statusArg.observedReplicaCount !== statusArg.requiredReplicaCount
+            || statusArg.healthyReplicaCount !== statusArg.requiredReplicaCount
+            || statusArg.verifiedReplicaCount !== statusArg.requiredReplicaCount
+            || statusArg.failedReplicaCount !== 0) {
+            errors.push('successful rollout status requires every replica to be observed, healthy and verified');
+        }
+        if (statusArg.mismatchReason || statusArg.reporters.length < 1) {
+            errors.push('successful rollout status requires reporters without mismatch reasons');
+        }
+        if (new Set(reporterNodeNames).size !== reporterNodeNames.length) {
+            errors.push('successful rollout status must not count a node in multiple reporters');
+        }
+        if (statusArg.reporters.some((reporterArg) => (reporterArg.requiredReplicaCount < 1
+            || reporterArg.observedReplicaCount !== reporterArg.requiredReplicaCount
+            || reporterArg.healthyReplicaCount !== reporterArg.requiredReplicaCount
+            || reporterArg.verifiedReplicaCount !== reporterArg.requiredReplicaCount
+            || reporterArg.failedReplicaCount !== 0
+            || Boolean(reporterArg.mismatchReason)))) {
+            errors.push('successful rollout requires every reporter replica to be healthy and verified');
+        }
+        const reporterTotals = statusArg.reporters.reduce((totalsArg, reporterArg) => ({
+            required: totalsArg.required + reporterArg.requiredReplicaCount,
+            observed: totalsArg.observed + reporterArg.observedReplicaCount,
+            healthy: totalsArg.healthy + reporterArg.healthyReplicaCount,
+            verified: totalsArg.verified + reporterArg.verifiedReplicaCount,
+            failed: totalsArg.failed + reporterArg.failedReplicaCount,
+        }), { required: 0, observed: 0, healthy: 0, verified: 0, failed: 0 });
+        if (reporterTotals.required !== statusArg.requiredReplicaCount
+            || reporterTotals.observed !== statusArg.observedReplicaCount
+            || reporterTotals.healthy !== statusArg.healthyReplicaCount
+            || reporterTotals.verified !== statusArg.verifiedReplicaCount
+            || reporterTotals.failed !== statusArg.failedReplicaCount) {
+            errors.push('successful rollout aggregate must exactly match successful reporter evidence');
+        }
+    }
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"immutableimage.js","sourceRoot":"","sources":["../../ts/data/immutableimage.ts"],"names":[],"mappings":"AAuMA,MAAM,iBAAiB,GAAG,uBAAuB,CAAC;AAElD,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,MAAc,EAA6B,EAAE;IACjF,MAAM,gBAAgB,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACrD,OAAO,iBAAiB,CAAC,IAAI,CAAC,gBAAgB,CAAC;QAC7C,CAAC,CAAE,gBAAkC;QACrC,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAc,EAA2B,EAAE,CACxE,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAEjC,MAAM,iBAAiB,GAAG,uEAAuE,CAAC;AAClG,MAAM,eAAe,GAAG,mEAAmE,CAAC;AAE5F,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAC7C,YAAoB,EACpB,UAAkB,EAClB,MAAqB,EACb,EAAE;IACV,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAC/E,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IAC9E,CAAC;IACD,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC9D,CAAC;IACD,OAAO,GAAG,YAAY,IAAI,UAAU,IAAI,MAAM,EAAE,CAAC;AACnD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAC/C,cAAsB,EACK,EAAE;IAC7B,MAAM,cAAc,GAAG,cAAc,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACvD,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,qBAAqB,CAAC,cAAc,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC;AACzE,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAClD,OAAsC,EAC5B,EAAE;IACZ,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,OAAO,CAAC,iBAAiB,GAAG,CAAC,EAAE,CAAC;QACtF,MAAM,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;IACnE,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,SAAS,GAAG,CAAC,EAAE,CAAC;QACtE,MAAM,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;IAC3D,CAAC;IACD,IAAI,iBAAqC,CAAC;IAC1C,IAAI,CAAC;QACH,iBAAiB,GAAG,+BAA+B,CACjD,OAAO,CAAC,YAAY,EACpB,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,eAAe,CACxB,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,IAAI,CAAE,KAAe,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,KAAK,iBAAiB,EAAE,CAAC;QAClF,MAAM,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;IAC3F,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC;IAClC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,KAAK,CAAC,eAAe,GAAG,CAAC,EAAE,CAAC;QAC9E,MAAM,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;IACjE,CAAC;IACD,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;IAChF,CAAC;IACD,IAAI,IAAI,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,gBAAgB,CAAC,MAAM;WACrE,IAAI,GAAG,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,KAAK,CAAC,oBAAoB,KAAK,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,KAAK,CAAC,eAAe,EAAE,CAAC;QACxF,MAAM,CAAC,IAAI,CAAC,sEAAsE,CAAC,CAAC;IACtF,CAAC;IACD,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC;QAChE,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;IACxE,CAAC;IACD,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;QAC/D,MAAM,CAAC,IAAI,CAAC,oDAAoD,CAAC,CAAC;IACpE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,SAA8B,EAAY,EAAE;IACrF,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,MAAM,GAAG;QACb,SAAS,CAAC,oBAAoB;QAC9B,SAAS,CAAC,oBAAoB;QAC9B,SAAS,CAAC,mBAAmB;QAC7B,SAAS,CAAC,oBAAoB;QAC9B,SAAS,CAAC,kBAAkB;KAC7B,CAAC;IACF,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC;QAC/E,MAAM,CAAC,IAAI,CAAC,2DAA2D,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,WAAW,GAAG,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IACrF,MAAM,kBAAkB,GAAG,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;IACnG,MAAM,iBAAiB,GAAG,SAAS,CAAC,SAAS,CAAC,OAAO,CACnD,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAC/C,CAAC;IACF,IAAI,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,MAAM;WAC/C,IAAI,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,KAAK,kBAAkB,CAAC,MAAM,EAAE,CAAC;QACpE,MAAM,CAAC,IAAI,CAAC,wEAAwE,CAAC,CAAC;IACxF,CAAC;IACD,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;QAC3C,MAAM,cAAc,GAAG;YACrB,QAAQ,CAAC,oBAAoB;YAC7B,QAAQ,CAAC,oBAAoB;YAC7B,QAAQ,CAAC,mBAAmB;YAC5B,QAAQ,CAAC,oBAAoB;YAC7B,QAAQ,CAAC,kBAAkB;SAC5B,CAAC;QACF,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC;YACvF,MAAM,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;QAC5E,CAAC;QACD,IAAI,QAAQ,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS;eACzC,QAAQ,CAAC,iBAAiB,KAAK,SAAS,CAAC,iBAAiB,EAAE,CAAC;YAChE,MAAM,CAAC,IAAI,CAAC,qEAAqE,CAAC,CAAC;QACrF,CAAC;QACD,IACE,QAAQ,CAAC,oBAAoB,GAAG,QAAQ,CAAC,oBAAoB;eAC1D,QAAQ,CAAC,mBAAmB,GAAG,QAAQ,CAAC,oBAAoB;eAC5D,QAAQ,CAAC,oBAAoB,GAAG,QAAQ,CAAC,oBAAoB,EAChE,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IACD,IAAI,SAAS,CAAC,MAAM,KAAK,WAAW,IAAI,SAAS,CAAC,MAAM,KAAK,aAAa,EAAE,CAAC;QAC3E,IACE,SAAS,CAAC,oBAAoB,GAAG,CAAC;eAC/B,SAAS,CAAC,oBAAoB,KAAK,SAAS,CAAC,oBAAoB;eACjE,SAAS,CAAC,mBAAmB,KAAK,SAAS,CAAC,oBAAoB;eAChE,SAAS,CAAC,oBAAoB,KAAK,SAAS,CAAC,oBAAoB;eACjE,SAAS,CAAC,kBAAkB,KAAK,CAAC,EACrC,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,uFAAuF,CAAC,CAAC;QACvG,CAAC;QACD,IAAI,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/D,MAAM,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;QACvF,CAAC;QACD,IAAI,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC,IAAI,KAAK,iBAAiB,CAAC,MAAM,EAAE,CAAC;YACjE,MAAM,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;QACvF,CAAC;QACD,IAAI,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAC5C,WAAW,CAAC,oBAAoB,GAAG,CAAC;eACjC,WAAW,CAAC,oBAAoB,KAAK,WAAW,CAAC,oBAAoB;eACrE,WAAW,CAAC,mBAAmB,KAAK,WAAW,CAAC,oBAAoB;eACpE,WAAW,CAAC,oBAAoB,KAAK,WAAW,CAAC,oBAAoB;eACrE,WAAW,CAAC,kBAAkB,KAAK,CAAC;eACpC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CACvC,CAAC,EAAE,CAAC;YACH,MAAM,CAAC,IAAI,CAAC,+EAA+E,CAAC,CAAC;QAC/F,CAAC;QACD,MAAM,cAAc,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;YAC7E,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,oBAAoB;YAC/D,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,oBAAoB;YAC/D,OAAO,EAAE,SAAS,CAAC,OAAO,GAAG,WAAW,CAAC,mBAAmB;YAC5D,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,oBAAoB;YAC/D,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,WAAW,CAAC,kBAAkB;SAC1D,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACtE,IACE,cAAc,CAAC,QAAQ,KAAK,SAAS,CAAC,oBAAoB;eACvD,cAAc,CAAC,QAAQ,KAAK,SAAS,CAAC,oBAAoB;eAC1D,cAAc,CAAC,OAAO,KAAK,SAAS,CAAC,mBAAmB;eACxD,cAAc,CAAC,QAAQ,KAAK,SAAS,CAAC,oBAAoB;eAC1D,cAAc,CAAC,MAAM,KAAK,SAAS,CAAC,kBAAkB,EACzD,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,8EAA8E,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/dist_ts/data/index.d.ts

@@ -2,6 +2,7 @@ export * from './cloudlyconfig.js';
 export * from './cluster.js';
 export * from './config.js';
 export * from './deployment.js';
+export * from './deploymentpreflight.js';
 export * from './migration.js';
 export * from './dns.js';
 export * from './docker.js';
@@ -11,6 +12,7 @@ export * from './externalregistry.js';
 export * from './gateway.js';
 export * from './hostedapp.js';
 export * from './image.js';
+export * from './immutableimage.js';
 export * from './isolatedrestore.js';
 export * from './isolatedrestore.golden.js';
 export * from './mail.js';