@serve.zone/interfaces 32.35.0 → 32.36.1

package/changelog.md

@@ -1,5 +1,68 @@
 # Changelog
 
+## 2026-09-29 - 32.36.1
+
+### Fixes
+
+- `IArchivePruneResult.rewrittenPacks` is optional. Corestore 34.0.0 (containerarchive 0.10)
+  removes unreferenced packs whole and never rewrites one, so it no longer reports the field;
+  Corestore up to 33.x still does. Absent means no pack was rewritten.
+
+## 2026-09-29 - 32.36.0
+
+### Features
+
+- A node's controller can now see and reach its workloads. Four contract families ride on the
+  runtime session in `requests.runtimesession`:
+  - `reportRuntimeAssignmentLogs`: Pallet pushes batches of an attempt's captured output. Lines
+    come in `partial` pieces, and `lost` entries evidence `buffer-overflow`, `line-cut`,
+    `capture-restart` and `not-captured` loss. Batches are acknowledged by sequence, so the
+    controller persists logs as `IRuntimeConfig.logs` requires.
+  - `readRuntimeAssignmentStats`: one CPU, memory, network and writable-layer sample of a
+    running attempt.
+  - `openRuntimeAssignmentExec`, `resizeRuntimeAssignmentExec` and `closeRuntimeAssignmentExec`:
+    a command in a running container, with VirtualStream stdin and output, TTY or not. At most
+    four sessions per node, with a 15-minute idle limit.
+  - `readRuntimeLocalVolumeArchive` and `writeRuntimeLocalVolumeArchive`: a node-local volume as
+    a pax archive. A read refuses a volume a running container holds. A write fills an `import`
+    claim that waits in `import-required` and publishes it only after the whole verified archive.
+
+  Exec and volume archives are refused for any controller but a local one (`onebox`). Each family
+  has exact-schema snapshots and request and response binders (`data.runtimeAssignmentLogContract`,
+  `runtimeAssignmentStatsContract`, `runtimeAssignmentExecContract`,
+  `runtimeLocalVolumeArchiveContract`). Until now a controller had no way to read a Pallet
+  workload's output or resources, run a command in it, or back up and restore its volumes, so
+  Onebox could not move its services off Docker.
+- `TDeploymentPreflightWarningCode` gains `PLATFORM_BINDING_READINESS_DEFERRED`: the promote
+  preflight of a held greenfield service that was never promoted may accept an enabled Corestore
+  `database` or `objectstorage` binding that is not `ready` yet, because a held service receives no
+  credential material and its binding can only become ready once promotion releases the hold. The
+  warning records that acceptance; the route preflight still requires the binding `ready`.
+- A legacy `deployOnPush` service without deployable source can move to a greenfield successor that
+  runs the exact image it ran. `data.ILegacyServiceRuntimeAttestation` is an administrator-captured
+  record that every required replica ran healthy on one registry root, with that root's platform
+  manifests (`ILegacyServiceImageSource`, `ILegacyImagePlatformManifest`);
+  `validateLegacyServiceRuntimeAttestation` and `validateLegacyImageImportReference` state the rules.
+  A greenfield reservation and its preflight may name `legacyImport` (`ILegacyImageImportReference`)
+  in place of `sourceRevision`, `sourceDirty` and release evidence
+  (`ILegacyImportServiceDeploymentReservationInput`), and the operation records the same origin.
+  New preflight blockers: `LEGACY_IMPORT_ATTESTATION_MISSING`, `LEGACY_IMPORT_SOURCE_MISMATCH` and
+  `LEGACY_IMPORT_PLATFORM_MISMATCH`. Release evidence may now be Cloudly's import
+  (`IImageReleaseLegacyImportEvidence`, source `cloudly-legacy-import`) beside the registry push
+  (`IImageReleaseRegistryPushEvidence`); `selectTrustedImageReleaseEvidence` takes an optional
+  `evidenceSource`, which defaults to the registry push. The capability `deployment:import-legacy`
+  is valid on organization-service-slot grants only. New requests:
+  `captureLegacyServiceRuntimeAttestation` and `getLegacyServiceRuntimeAttestations` (administrators)
+  and `importServiceDeploymentLegacyImage`. Until now an immutable deployment needed a source
+  revision and a pushed build, so a legacy service whose source was lost could not leave its
+  legacy runtime.
+- Type widening for consumers: `IServiceDeploymentOperation.data.sourceRevision` and
+  `IDeploymentPreflightReport.source.revision` / `.dirty` are now `string | undefined` /
+  `boolean | undefined`, absent exactly when the origin is a legacy import.
+  `IServiceDeploymentOperation.data` is the new `IServiceDeploymentOperationData`, and
+  `IDeploymentPreflightRequestData` and `IImageReleaseTrustedEvidence` are now union type aliases,
+  so they can no longer be extended as interfaces.
+
 ## 2026-09-29 - 32.35.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/backup.d.ts

@@ -106,8 +106,14 @@ export interface IArchiveRetentionPolicy {
 }
 export interface IArchivePruneResult {
     removedSnapshots: number;
+    /** Packs holding no chunk of the committed index, removed whole. */
     removedPacks: number;
-    rewrittenPacks: number;
+    /**
+     * Packs a prune rewrote to drop unreferenced chunks. Only Corestore up to 33.x (containerarchive
+     * 0.3.2) reports it; containerarchive 0.10 and Corestore 34.0.0 remove unreferenced packs whole
+     * and never rewrite one, so they omit it. Absent means no pack was rewritten.
+     */
+    rewrittenPacks?: number;
     freedBytes: number;
     dryRun: boolean;
 }

package/dist_ts/data/deploymentlegacyimport.d.ts

@@ -0,0 +1,92 @@
+import type { TImmutableContainerPlatform, TOciManifestMediaType, TSha256Digest } from './immutableimage.js';
+/**
+ * Legacy image import: a greenfield deployment whose image is the one a legacy `deployOnPush`
+ * service already runs, instead of one built from a source revision.
+ *
+ * A legacy service without deployable source still has an image in Cloudly's registry and, until
+ * its runtime is frozen, healthy replicas running it. An administrator captures that fact once as
+ * a {@link ILegacyServiceRuntimeAttestation} while the replicas still run. A greenfield successor
+ * reservation names the attestation in `legacyImport` instead of a `sourceRevision`, and Cloudly
+ * then imports the attested image into the successor's own repository and release tag itself:
+ * the bytes never leave the registry and the release records that it was imported, not built.
+ *
+ * Deployment roots are indexes. An attested root that already is an index is imported as it is. A
+ * root that is one platform manifest is imported under an index whose only descriptor is that
+ * manifest, in the manifest's own family — a Docker manifest list around a Docker manifest, an OCI
+ * index around an OCI manifest — so the platform manifest stays byte-identical and its digest is
+ * still the one the legacy runtime ran. The attestation states everything that descriptor needs.
+ */
+/** The media types a legacy image's per-platform manifest can carry. */
+export type TLegacyImagePlatformManifestMediaType = 'application/vnd.oci.image.manifest.v1+json' | 'application/vnd.docker.distribution.manifest.v2+json';
+/** The index media type of the family a platform manifest belongs to. */
+export type TLegacyImageImportIndexMediaType = 'application/vnd.oci.image.index.v1+json' | 'application/vnd.docker.distribution.manifest.list.v2+json';
+/** One platform manifest of a legacy image, as Cloudly read it from its own registry. */
+export interface ILegacyImagePlatformManifest {
+    platform: TImmutableContainerPlatform;
+    manifestDigest: TSha256Digest;
+    manifestMediaType: TLegacyImagePlatformManifestMediaType;
+    /** Exact byte length of the platform manifest, which an index descriptor states. */
+    manifestSize: number;
+    imageConfigDigest: TSha256Digest;
+}
+/** The registry image a legacy service ran, under the mutable tag it was deployed from. */
+export interface ILegacyServiceImageSource {
+    registryHost: string;
+    repository: string;
+    /** The mutable tag the legacy service was deployed from, `latest` included. */
+    tag: string;
+    /** Digest of the root the tag named: a single platform manifest or an index. */
+    rootDigest: TSha256Digest;
+    rootMediaType: TOciManifestMediaType;
+    /**
+     * The runnable Linux platforms the root carries, sorted by platform. A single-manifest root
+     * carries exactly one, whose manifest is the root itself.
+     */
+    platforms: ILegacyImagePlatformManifest[];
+}
+/** One healthy replica of the legacy service, observed running the attested digest. */
+export interface ILegacyServiceRuntimeTaskAttestation {
+    deploymentId: string;
+    nodeName: string;
+    observedDigest: TSha256Digest;
+}
+/**
+ * Durable evidence, captured by an administrator while the legacy runtime still ran, that every
+ * required replica of a legacy service was healthy and ran exactly the registry root it names.
+ *
+ * Cloudly writes one and never changes it. A capture only succeeds on complete evidence, so a
+ * stored attestation is by construction one whose runtime digest is its source root digest.
+ */
+export interface ILegacyServiceRuntimeAttestation {
+    id: string;
+    data: {
+        legacyServiceId: string;
+        organizationId: string;
+        source: ILegacyServiceImageSource;
+        runtime: {
+            requiredReplicaCount: number;
+            healthyReplicaCount: number;
+            runtimeDigest: TSha256Digest;
+            /** Sorted by deploymentId, one per required replica. */
+            tasks: ILegacyServiceRuntimeTaskAttestation[];
+        };
+        capturedByUserId: string;
+        capturedAt: number;
+    };
+}
+/**
+ * What a legacy-import reservation names in place of a source revision: the legacy service, the
+ * attestation Cloudly holds for it, and the root digest the deployer asserts that attestation
+ * carries.
+ */
+export interface ILegacyImageImportReference {
+    legacyServiceId: string;
+    attestationId: string;
+    sourceRootDigest: TSha256Digest;
+}
+/** True when a media type names a single platform manifest rather than an index. */
+export declare const isLegacyImagePlatformManifestMediaType: (valueArg: unknown) => valueArg is TLegacyImagePlatformManifestMediaType;
+/** True when a media type names an index of either family. */
+export declare const isLegacyImageImportIndexMediaType: (valueArg: unknown) => valueArg is TLegacyImageImportIndexMediaType;
+export declare const validateLegacyImageImportReference: (referenceArg: unknown) => string[];
+export declare const validateLegacyServiceRuntimeAttestation: (attestationArg: unknown) => string[];

package/dist_ts/data/deploymentlegacyimport.js

@@ -0,0 +1,237 @@
+import { normalizeSha256Digest } from './immutableimage.js';
+import { hasExactKeys, isPlainRecord } from '../private/dataproperties.js';
+const identifierRegex = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/;
+/** An OCI tag, the mutable `latest` included: the source tag is whatever the legacy service ran. */
+const ociTagRegex = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$/;
+const registryHostRegex = /^[a-z0-9](?:[a-z0-9.-]{0,251}[a-z0-9])?(?::[0-9]{1,5})?$/;
+const repositoryRegex = /^[a-z0-9]+(?:(?:[._]|__|-+)[a-z0-9]+)*(?:\/[a-z0-9]+(?:(?:[._]|__|-+)[a-z0-9]+)*)*$/;
+const maximumManifestSize = 4 * 1024 * 1024;
+const maximumReplicaCount = 64;
+const legacyImagePlatformManifestMediaTypes = [
+    'application/vnd.oci.image.manifest.v1+json',
+    'application/vnd.docker.distribution.manifest.v2+json',
+];
+const legacyImageImportIndexMediaTypes = [
+    'application/vnd.oci.image.index.v1+json',
+    'application/vnd.docker.distribution.manifest.list.v2+json',
+];
+const legacyImagePlatforms = ['linux/amd64', 'linux/arm64'];
+const isIdentifier = (valueArg) => (typeof valueArg === 'string' && identifierRegex.test(valueArg));
+const isCanonicalDigest = (valueArg) => (typeof valueArg === 'string' && normalizeSha256Digest(valueArg) === valueArg);
+const isPositiveSafeInteger = (valueArg, maximumArg) => (typeof valueArg === 'number'
+    && Number.isSafeInteger(valueArg)
+    && valueArg >= 1
+    && valueArg <= maximumArg);
+/** True when a media type names a single platform manifest rather than an index. */
+export const isLegacyImagePlatformManifestMediaType = (valueArg) => (legacyImagePlatformManifestMediaTypes.some((mediaTypeArg) => mediaTypeArg === valueArg));
+/** True when a media type names an index of either family. */
+export const isLegacyImageImportIndexMediaType = (valueArg) => (legacyImageImportIndexMediaTypes.some((mediaTypeArg) => mediaTypeArg === valueArg));
+export const validateLegacyImageImportReference = (referenceArg) => {
+    if (!isPlainRecord(referenceArg))
+        return ['legacyImport must be an object'];
+    const errors = [];
+    if (!hasExactKeys(referenceArg, ['legacyServiceId', 'attestationId', 'sourceRootDigest'])) {
+        errors.push('legacyImport must use its exact schema');
+    }
+    if (!isIdentifier(referenceArg.legacyServiceId)) {
+        errors.push('legacyImport.legacyServiceId must be a bounded canonical identifier');
+    }
+    if (!isIdentifier(referenceArg.attestationId)) {
+        errors.push('legacyImport.attestationId must be a bounded canonical identifier');
+    }
+    if (!isCanonicalDigest(referenceArg.sourceRootDigest)) {
+        errors.push('legacyImport.sourceRootDigest must be a canonical sha256 digest');
+    }
+    return errors;
+};
+const validatePlatformManifest = (manifestArg, indexArg) => {
+    const label = `source.platforms[${indexArg}]`;
+    if (!isPlainRecord(manifestArg))
+        return [`${label} must be an object`];
+    const errors = [];
+    if (!hasExactKeys(manifestArg, [
+        'platform',
+        'manifestDigest',
+        'manifestMediaType',
+        'manifestSize',
+        'imageConfigDigest',
+    ])) {
+        errors.push(`${label} must use its exact schema`);
+    }
+    if (!legacyImagePlatforms.some((platformArg) => platformArg === manifestArg.platform)) {
+        errors.push(`${label}.platform must be linux/amd64 or linux/arm64`);
+    }
+    if (!isCanonicalDigest(manifestArg.manifestDigest)) {
+        errors.push(`${label}.manifestDigest must be a canonical sha256 digest`);
+    }
+    if (!isLegacyImagePlatformManifestMediaType(manifestArg.manifestMediaType)) {
+        errors.push(`${label}.manifestMediaType must name an OCI or Docker image manifest`);
+    }
+    if (!isPositiveSafeInteger(manifestArg.manifestSize, maximumManifestSize)) {
+        errors.push(`${label}.manifestSize must be a positive bounded byte length`);
+    }
+    if (!isCanonicalDigest(manifestArg.imageConfigDigest)) {
+        errors.push(`${label}.imageConfigDigest must be a canonical sha256 digest`);
+    }
+    return errors;
+};
+const validateImageSource = (sourceArg) => {
+    if (!isPlainRecord(sourceArg))
+        return ['source must be an object'];
+    const errors = [];
+    if (!hasExactKeys(sourceArg, [
+        'registryHost',
+        'repository',
+        'tag',
+        'rootDigest',
+        'rootMediaType',
+        'platforms',
+    ])) {
+        errors.push('source must use its exact schema');
+    }
+    if (typeof sourceArg.registryHost !== 'string' || !registryHostRegex.test(sourceArg.registryHost)) {
+        errors.push('source.registryHost must be a canonical registry host');
+    }
+    if (typeof sourceArg.repository !== 'string'
+        || sourceArg.repository.length > 255
+        || !repositoryRegex.test(sourceArg.repository)) {
+        errors.push('source.repository must be a canonical OCI repository name');
+    }
+    if (typeof sourceArg.tag !== 'string' || !ociTagRegex.test(sourceArg.tag)) {
+        errors.push('source.tag must be an OCI tag');
+    }
+    if (!isCanonicalDigest(sourceArg.rootDigest)) {
+        errors.push('source.rootDigest must be a canonical sha256 digest');
+    }
+    const rootIsManifest = isLegacyImagePlatformManifestMediaType(sourceArg.rootMediaType);
+    const rootIsIndex = isLegacyImageImportIndexMediaType(sourceArg.rootMediaType);
+    if (!rootIsManifest && !rootIsIndex) {
+        errors.push('source.rootMediaType must name an OCI or Docker manifest or index');
+    }
+    if (!Array.isArray(sourceArg.platforms)
+        || sourceArg.platforms.length < 1
+        || sourceArg.platforms.length > legacyImagePlatforms.length) {
+        errors.push('source.platforms must carry one or two runnable Linux platforms');
+        return errors;
+    }
+    const platforms = sourceArg.platforms;
+    platforms.forEach((manifestArg, indexArg) => {
+        errors.push(...validatePlatformManifest(manifestArg, indexArg));
+    });
+    const platformNames = platforms.map((manifestArg) => (isPlainRecord(manifestArg) ? manifestArg.platform : undefined));
+    const sortedPlatformNames = legacyImagePlatforms.filter((platformArg) => (platformNames.includes(platformArg)));
+    if (JSON.stringify(platformNames) !== JSON.stringify(sortedPlatformNames)) {
+        errors.push('source.platforms must be unique and sorted by platform');
+    }
+    if (rootIsManifest) {
+        const onlyPlatform = platforms[0];
+        if (platforms.length !== 1
+            || !isPlainRecord(onlyPlatform)
+            || onlyPlatform.manifestDigest !== sourceArg.rootDigest
+            || onlyPlatform.manifestMediaType !== sourceArg.rootMediaType) {
+            errors.push('a single-manifest source root must be its own one platform manifest');
+        }
+    }
+    if (rootIsIndex && platforms.some((manifestArg) => (isPlainRecord(manifestArg) && manifestArg.manifestDigest === sourceArg.rootDigest))) {
+        errors.push('an index source root cannot also be one of its platform manifests');
+    }
+    return errors;
+};
+const validateRuntime = (runtimeArg, rootDigestArg) => {
+    if (!isPlainRecord(runtimeArg))
+        return ['runtime must be an object'];
+    const errors = [];
+    if (!hasExactKeys(runtimeArg, [
+        'requiredReplicaCount',
+        'healthyReplicaCount',
+        'runtimeDigest',
+        'tasks',
+    ])) {
+        errors.push('runtime must use its exact schema');
+    }
+    if (!isPositiveSafeInteger(runtimeArg.requiredReplicaCount, maximumReplicaCount)) {
+        errors.push('runtime.requiredReplicaCount must be a positive bounded replica count');
+    }
+    if (runtimeArg.healthyReplicaCount !== runtimeArg.requiredReplicaCount) {
+        errors.push('runtime.healthyReplicaCount must equal the required replica count');
+    }
+    if (!isCanonicalDigest(runtimeArg.runtimeDigest)) {
+        errors.push('runtime.runtimeDigest must be a canonical sha256 digest');
+    }
+    else if (runtimeArg.runtimeDigest !== rootDigestArg) {
+        errors.push('runtime.runtimeDigest must be the attested source root digest');
+    }
+    if (!Array.isArray(runtimeArg.tasks) || runtimeArg.tasks.length !== runtimeArg.requiredReplicaCount) {
+        errors.push('runtime.tasks must hold exactly one task per required replica');
+        return errors;
+    }
+    const tasks = runtimeArg.tasks;
+    tasks.forEach((taskArg, indexArg) => {
+        const label = `runtime.tasks[${indexArg}]`;
+        if (!isPlainRecord(taskArg)) {
+            errors.push(`${label} must be an object`);
+            return;
+        }
+        if (!hasExactKeys(taskArg, ['deploymentId', 'nodeName', 'observedDigest'])) {
+            errors.push(`${label} must use its exact schema`);
+        }
+        if (!isIdentifier(taskArg.deploymentId)) {
+            errors.push(`${label}.deploymentId must be a bounded canonical identifier`);
+        }
+        if (typeof taskArg.nodeName !== 'string' || !taskArg.nodeName || taskArg.nodeName.length > 253) {
+            errors.push(`${label}.nodeName must be a bounded non-empty name`);
+        }
+        if (taskArg.observedDigest !== runtimeArg.runtimeDigest) {
+            errors.push(`${label}.observedDigest must be the attested runtime digest`);
+        }
+    });
+    const deploymentIds = tasks.map((taskArg) => (isPlainRecord(taskArg) ? taskArg.deploymentId : undefined));
+    const sortedDeploymentIds = deploymentIds
+        .filter((idArg) => typeof idArg === 'string')
+        .sort();
+    if (new Set(deploymentIds).size !== deploymentIds.length
+        || JSON.stringify(deploymentIds) !== JSON.stringify(sortedDeploymentIds)) {
+        errors.push('runtime.tasks must be unique and sorted by deploymentId');
+    }
+    return errors;
+};
+export const validateLegacyServiceRuntimeAttestation = (attestationArg) => {
+    if (!isPlainRecord(attestationArg))
+        return ['attestation must be an object'];
+    const errors = [];
+    if (!hasExactKeys(attestationArg, ['id', 'data'])) {
+        errors.push('attestation must use its exact schema');
+    }
+    if (!isIdentifier(attestationArg.id)) {
+        errors.push('id must be a bounded canonical identifier');
+    }
+    const data = attestationArg.data;
+    if (!isPlainRecord(data))
+        return [...errors, 'data must be an object'];
+    if (!hasExactKeys(data, [
+        'legacyServiceId',
+        'organizationId',
+        'source',
+        'runtime',
+        'capturedByUserId',
+        'capturedAt',
+    ])) {
+        errors.push('data must use its exact schema');
+    }
+    if (!isIdentifier(data.legacyServiceId)) {
+        errors.push('legacyServiceId must be a bounded canonical identifier');
+    }
+    if (!isIdentifier(data.organizationId)) {
+        errors.push('organizationId must be a bounded canonical identifier');
+    }
+    if (!isIdentifier(data.capturedByUserId)) {
+        errors.push('capturedByUserId must be a bounded canonical identifier');
+    }
+    if (!isPositiveSafeInteger(data.capturedAt, Number.MAX_SAFE_INTEGER)) {
+        errors.push('capturedAt must be a positive timestamp');
+    }
+    errors.push(...validateImageSource(data.source));
+    errors.push(...validateRuntime(data.runtime, isPlainRecord(data.source) ? data.source.rootDigest : undefined));
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploymentlegacyimport.js","sourceRoot":"","sources":["../../ts/data/deploymentlegacyimport.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAmG3E,MAAM,eAAe,GAAG,qCAAqC,CAAC;AAC9D,oGAAoG;AACpG,MAAM,WAAW,GAAG,qCAAqC,CAAC;AAC1D,MAAM,iBAAiB,GAAG,0DAA0D,CAAC;AACrF,MAAM,eAAe,GAAG,qFAAqF,CAAC;AAC9G,MAAM,mBAAmB,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAC5C,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B,MAAM,qCAAqC,GAAqD;IAC9F,4CAA4C;IAC5C,sDAAsD;CACvD,CAAC;AACF,MAAM,gCAAgC,GAAgD;IACpF,yCAAyC;IACzC,2DAA2D;CAC5D,CAAC;AACF,MAAM,oBAAoB,GAA2C,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAEpG,MAAM,YAAY,GAAG,CAAC,QAAiB,EAAsB,EAAE,CAAC,CAC9D,OAAO,QAAQ,KAAK,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAC/D,CAAC;AAEF,MAAM,iBAAiB,GAAG,CAAC,QAAiB,EAA6B,EAAE,CAAC,CAC1E,OAAO,QAAQ,KAAK,QAAQ,IAAI,qBAAqB,CAAC,QAAQ,CAAC,KAAK,QAAQ,CAC7E,CAAC;AAEF,MAAM,qBAAqB,GAAG,CAAC,QAAiB,EAAE,UAAkB,EAAsB,EAAE,CAAC,CAC3F,OAAO,QAAQ,KAAK,QAAQ;OACzB,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;OAC9B,QAAQ,IAAI,CAAC;OACb,QAAQ,IAAI,UAAU,CAC1B,CAAC;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,sCAAsC,GAAG,CACpD,QAAiB,EACkC,EAAE,CAAC,CACtD,qCAAqC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,KAAK,QAAQ,CAAC,CACxF,CAAC;AAEF,8DAA8D;AAC9D,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAC/C,QAAiB,EAC6B,EAAE,CAAC,CACjD,gCAAgC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,KAAK,QAAQ,CAAC,CACnF,CAAC;AAEF,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC,YAAqB,EAAY,EAAE;IACpF,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC;QAAE,OAAO,CAAC,gCAAgC,CAAC,CAAC;IAC5E,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,iBAAiB,EAAE,eAAe,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC;QAC1F,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,eAAe,CAAC,EAAE,CAAC;QAChD,MAAM,CAAC,IAAI,CAAC,qEAAqE,CAAC,CAAC;IACrF,CAAC;IACD,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE,CAAC;QAC9C,MAAM,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;IACjF,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,wBAAwB,GAAG,CAC/B,WAAoB,EACpB,QAAgB,EACN,EAAE;IACZ,MAAM,KAAK,GAAG,oBAAoB,QAAQ,GAAG,CAAC;IAC9C,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC;QAAE,OAAO,CAAC,GAAG,KAAK,oBAAoB,CAAC,CAAC;IACvE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE;QAC7B,UAAU;QACV,gBAAgB;QAChB,mBAAmB;QACnB,cAAc;QACd,mBAAmB;KACpB,CAAC,EAAE,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,4BAA4B,CAAC,CAAC;IACpD,CAAC;IACD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,KAAK,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtF,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,8CAA8C,CAAC,CAAC;IACtE,CAAC;IACD,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC;QACnD,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,mDAAmD,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,CAAC,sCAAsC,CAAC,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC;QAC3E,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,8DAA8D,CAAC,CAAC;IACtF,CAAC;IACD,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,YAAY,EAAE,mBAAmB,CAAC,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,sDAAsD,CAAC,CAAC;IAC9E,CAAC;IACD,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,sDAAsD,CAAC,CAAC;IAC9E,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,SAAkB,EAAY,EAAE;IAC3D,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,OAAO,CAAC,0BAA0B,CAAC,CAAC;IACnE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE;QAC3B,cAAc;QACd,YAAY;QACZ,KAAK;QACL,YAAY;QACZ,eAAe;QACf,WAAW;KACZ,CAAC,EAAE,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;IAClD,CAAC;IACD,IAAI,OAAO,SAAS,CAAC,YAAY,KAAK,QAAQ,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC;QAClG,MAAM,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,OAAO,SAAS,CAAC,UAAU,KAAK,QAAQ;WACvC,SAAS,CAAC,UAAU,CAAC,MAAM,GAAG,GAAG;WACjC,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;QACjD,MAAM,CAAC,IAAI,CAAC,2DAA2D,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,OAAO,SAAS,CAAC,GAAG,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;IAC/C,CAAC;IACD,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,cAAc,GAAG,sCAAsC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IACvF,MAAM,WAAW,GAAG,iCAAiC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IAC/E,IAAI,CAAC,cAAc,IAAI,CAAC,WAAW,EAAE,CAAC;QACpC,MAAM,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC;WAClC,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;WAC9B,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,oBAAoB,CAAC,MAAM,EAAE,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;QAC/E,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,MAAM,SAAS,GAAG,SAAS,CAAC,SAAsB,CAAC;IACnD,SAAS,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE;QAC1C,MAAM,CAAC,IAAI,CAAC,GAAG,wBAAwB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IACH,MAAM,aAAa,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CACnD,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAC9D,CAAC,CAAC;IACH,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CACvE,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,CACpC,CAAC,CAAC;IACH,IAAI,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;IACxE,CAAC;IACD,IAAI,cAAc,EAAE,CAAC;QACnB,MAAM,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAClC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;eACrB,CAAC,aAAa,CAAC,YAAY,CAAC;eAC5B,YAAY,CAAC,cAAc,KAAK,SAAS,CAAC,UAAU;eACpD,YAAY,CAAC,iBAAiB,KAAK,SAAS,CAAC,aAAa,EAAE,CAAC;YAChE,MAAM,CAAC,IAAI,CAAC,qEAAqE,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IACD,IAAI,WAAW,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CACjD,aAAa,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,cAAc,KAAK,SAAS,CAAC,UAAU,CAClF,CAAC,EAAE,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;IACnF,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,UAAmB,EAAE,aAAsB,EAAY,EAAE;IAChF,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC;QAAE,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACrE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE;QAC5B,sBAAsB;QACtB,qBAAqB;QACrB,eAAe;QACf,OAAO;KACR,CAAC,EAAE,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;IACnD,CAAC;IACD,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,CAAC;QACjF,MAAM,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;IACvF,CAAC;IACD,IAAI,UAAU,CAAC,mBAAmB,KAAK,UAAU,CAAC,oBAAoB,EAAE,CAAC;QACvE,MAAM,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;QACjD,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IACzE,CAAC;SAAM,IAAI,UAAU,CAAC,aAAa,KAAK,aAAa,EAAE,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;IAC/E,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,KAAK,UAAU,CAAC,oBAAoB,EAAE,CAAC;QACpG,MAAM,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;QAC7E,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAkB,CAAC;IAC5C,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE;QAClC,MAAM,KAAK,GAAG,iBAAiB,QAAQ,GAAG,CAAC;QAC3C,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,oBAAoB,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC;YAC3E,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,4BAA4B,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,sDAAsD,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,QAAQ,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;YAC/F,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,4CAA4C,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,OAAO,CAAC,cAAc,KAAK,UAAU,CAAC,aAAa,EAAE,CAAC;YACxD,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,qDAAqD,CAAC,CAAC;QAC7E,CAAC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,aAAa,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAC3C,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAC1D,CAAC,CAAC;IACH,MAAM,mBAAmB,GAAG,aAAa;SACtC,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;SAC7D,IAAI,EAAE,CAAC;IACV,IAAI,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,KAAK,aAAa,CAAC,MAAM;WACnD,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC3E,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uCAAuC,GAAG,CAAC,cAAuB,EAAY,EAAE;IAC3F,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;QAAE,OAAO,CAAC,+BAA+B,CAAC,CAAC;IAC7E,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;QAClD,MAAM,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;IACvD,CAAC;IACD,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC;QACrC,MAAM,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;IAC3D,CAAC;IACD,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;IACjC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,GAAG,MAAM,EAAE,wBAAwB,CAAC,CAAC;IACvE,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE;QACtB,iBAAiB;QACjB,gBAAgB;QAChB,QAAQ;QACR,SAAS;QACT,kBAAkB;QAClB,YAAY;KACb,CAAC,EAAE,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAC;IAChD,CAAC;IACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;IACxE,CAAC;IACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;QACvC,MAAM,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACzC,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IACzE,CAAC;IACD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACrE,MAAM,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;IACzD,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,GAAG,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACjD,MAAM,CAAC,IAAI,CAAC,GAAG,eAAe,CAC5B,IAAI,CAAC,OAAO,EACZ,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAChE,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/dist_ts/data/deploymentoperation.d.ts

@@ -1,6 +1,7 @@
 import type { IDeploymentPreflightProposedConfiguration, IDeploymentPreflightRuntimeTask } from './deploymentpreflight.js';
 import type { IGatewayRouteDnsResult } from './gateway.js';
 import type { IImageRolloutStatus, IImmutableImageDeploymentPlan, TSha256Digest } from './immutableimage.js';
+import type { ILegacyImageImportReference } from './deploymentlegacyimport.js';
 import type { IRegistryTarget } from './registry.js';
 import type { TServiceTargetPortRef } from './serviceports.js';
 export type TDeploymentOperationMode = 'existing-service' | 'greenfield';
@@ -9,24 +10,42 @@ interface IDeploymentReservationInputBase {
     organizationId: string;
     serviceId: string;
     idempotencyKey: string;
-    sourceRevision: string;
     version: string;
     intentDigest: TSha256Digest;
     proposedConfiguration: IDeploymentPreflightProposedConfiguration;
     releaseTag: string;
     routes: IDeploymentRouteRequest[];
 }
-export interface IExistingServiceDeploymentReservationInput extends IDeploymentReservationInputBase {
+/** A deployment whose image its deployer builds and pushes from one source revision. */
+interface ISourceDeploymentOrigin {
+    sourceRevision: string;
+    legacyImport?: never;
+}
+/**
+ * A greenfield deployment whose image Cloudly imports from an attested legacy service instead:
+ * there is no source revision, so none is stated.
+ */
+interface ILegacyImportDeploymentOrigin {
+    legacyImport: ILegacyImageImportReference;
+    sourceRevision?: never;
+}
+export interface IExistingServiceDeploymentReservationInput extends IDeploymentReservationInputBase, ISourceDeploymentOrigin {
     mode: 'existing-service';
     expectedRolloutGeneration: number;
     expectedCurrentRolloutId?: string;
 }
-export interface IGreenfieldServiceDeploymentReservationInput extends IDeploymentReservationInputBase {
+export interface IGreenfieldServiceDeploymentReservationInput extends IDeploymentReservationInputBase, ISourceDeploymentOrigin {
     mode: 'greenfield';
     expectedRolloutGeneration?: never;
     expectedCurrentRolloutId?: never;
 }
-export type IDeploymentReservationInput = IExistingServiceDeploymentReservationInput | IGreenfieldServiceDeploymentReservationInput;
+/** A greenfield successor slot whose image is a legacy service's attested image. */
+export interface ILegacyImportServiceDeploymentReservationInput extends IDeploymentReservationInputBase, ILegacyImportDeploymentOrigin {
+    mode: 'greenfield';
+    expectedRolloutGeneration?: never;
+    expectedCurrentRolloutId?: never;
+}
+export type IDeploymentReservationInput = IExistingServiceDeploymentReservationInput | IGreenfieldServiceDeploymentReservationInput | ILegacyImportServiceDeploymentReservationInput;
 export type TDeploymentOperationState = 'reserving' | 'reserved' | 'provisioning' | 'awaiting-image' | 'image-recorded' | 'promoting-image' | 'rolling-out' | 'ready-for-route' | 'promoting-route' | 'verifying-route' | 'succeeded' | 'rolling-back' | 'rolled-back' | 'failed' | 'cleaning' | 'cleaned';
 export interface IDeploymentRouteRequest {
     hostname: string;
@@ -107,40 +126,46 @@ export interface IDeploymentOperationFailure {
 export interface IServiceDeploymentOperation {
     id: string;
     revision: number;
-    data: {
-        mode: TDeploymentOperationMode;
-        organizationId: string;
-        serviceId: string;
-        actorUserId: string;
-        idempotencyKey: string;
-        requestDigest: TSha256Digest;
-        sourceRevision: string;
-        version: string;
-        intentDigest: TSha256Digest;
-        configurationDigest: TSha256Digest;
-        proposedConfiguration: IDeploymentPreflightProposedConfiguration;
-        namespace: string;
-        registryTarget: IRegistryTarget;
-        releaseTag: string;
-        routes: IDeploymentRouteRequest[];
-        claimKeys: string[];
-        state: TDeploymentOperationState;
-        releaseId?: string;
-        registryRootDigest?: TSha256Digest;
-        rolloutId?: string;
-        rolloutGeneration?: number;
-        routeGeneration?: number;
-        routeVerification?: IDeploymentRouteVerificationEvidence[];
-        /**
-         * Most recent failure record. Set when the operation fails and retained
-         * as audit history through 'cleaning' and 'cleaned'; cleared only by a
-         * forward transition such as a successful retry. A populated failure does
-         * therefore NOT imply state === 'failed'.
-         */
-        failure?: IDeploymentOperationFailure;
-        createdAt: number;
-        updatedAt: number;
-    };
+    data: IServiceDeploymentOperationData;
+}
+/**
+ * An operation's durable state. It states where its image comes from exactly as its reservation
+ * did: a `sourceRevision` for an image its deployer builds, or a `legacyImport` (greenfield only)
+ * for a legacy service's attested image Cloudly imports.
+ */
+export type IServiceDeploymentOperationData = IServiceDeploymentOperationStateData & (ISourceDeploymentOrigin | ILegacyImportDeploymentOrigin);
+interface IServiceDeploymentOperationStateData {
+    mode: TDeploymentOperationMode;
+    organizationId: string;
+    serviceId: string;
+    actorUserId: string;
+    idempotencyKey: string;
+    requestDigest: TSha256Digest;
+    version: string;
+    intentDigest: TSha256Digest;
+    configurationDigest: TSha256Digest;
+    proposedConfiguration: IDeploymentPreflightProposedConfiguration;
+    namespace: string;
+    registryTarget: IRegistryTarget;
+    releaseTag: string;
+    routes: IDeploymentRouteRequest[];
+    claimKeys: string[];
+    state: TDeploymentOperationState;
+    releaseId?: string;
+    registryRootDigest?: TSha256Digest;
+    rolloutId?: string;
+    rolloutGeneration?: number;
+    routeGeneration?: number;
+    routeVerification?: IDeploymentRouteVerificationEvidence[];
+    /**
+     * Most recent failure record. Set when the operation fails and retained
+     * as audit history through 'cleaning' and 'cleaned'; cleared only by a
+     * forward transition such as a successful retry. A populated failure does
+     * therefore NOT imply state === 'failed'.
+     */
+    failure?: IDeploymentOperationFailure;
+    createdAt: number;
+    updatedAt: number;
 }
 export interface IServiceDeploymentStatus {
     operation: IServiceDeploymentOperation;