@serve.zone/interfaces 32.50.0 → 32.51.0

package/changelog.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 2026-10-06 - 32.51.0
+
+### Features
+
+- A legacy service's runtime attestation is captured from an administrator's host observation, so
+  it no longer needs a fleet Coreflow session or Spark, which legacy hosts do not run.
+  `IRequest_Any_Cloudly_CaptureLegacyServiceRuntimeAttestation` now carries `hostObservation`
+  (`ILegacyServiceHostObservation`, `data/deploymentlegacyimport.ts`): the Swarm service name, spec
+  image and mode (`TLegacyHostSwarmServiceMode`, replicated with its desired replicas, or global),
+  and per replica the node hostname, Swarm task id, full container id, the engine's image store
+  (`TLegacyHostImageStore`), the container's image id, the image's `RepoDigests`, the container
+  state (`TLegacyHostContainerState`) and its health (`TLegacyHostContainerHealth`, `none` when no
+  healthcheck applies). `validateLegacyServiceHostObservation` judges its exact shape,
+  `selectLegacyServiceHostObservationRootDigest` names the one root every replica runs from the
+  service's own repository, and `judgeLegacyServiceHostObservation` judges it against that root as
+  Cloudly reads it: exactly the desired replicas of a replicated service, a spec image naming the
+  repository by the source tag or the root digest, every replica running and healthy or without a
+  healthcheck (`unhealthy` and `starting` are refused), and each container's image id the root
+  digest on the containerd image store or a platform image configuration digest of the root on the
+  classic store. The source tag need not still name the root.
+  `ILegacyServiceRuntimeAttestation.data.runtime` records `evidenceSource`
+  (`TLegacyServiceRuntimeEvidenceSource`, `administrator-host-observation`) and the
+  `hostObservation` it was built from; `validateLegacyServiceRuntimeAttestation` requires both and
+  that `requiredReplicaCount` and `tasks` are the observed desired replicas and Swarm tasks.
+  The capture request's `hostObservation` and the record's `evidenceSource`/`hostObservation` are
+  new required members, which stays a minor of the one common major 32 because the previous capture
+  had no success path on a fleet without a Coreflow session, no shipped store holds an attestation
+  record, and Cloudly is the only code consumer.
+
+### Maintenance
+
+- Release tooling: `@git.zone/tstest` 7.1.0 → 7.2.0. pnpm stays at 12.8.1 until 12.8.2 is seven days old (2026-10-07 01:15 UTC); `@types/node` stays at 26.6.3 until 26.6.4 is seven days old (2026-10-08 22:39 UTC).
+
 ## 2026-10-06 - 32.50.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/deploymentlegacyimport.d.ts

@@ -4,8 +4,10 @@ import type { TImmutableContainerPlatform, TOciManifestMediaType, TSha256Digest
  * 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
+ * its runtime is frozen, replicas running it. An administrator observes those replicas on the
+ * hosts that run them ({@link ILegacyServiceHostObservation}) while they still run, and Cloudly
+ * captures that observation once as a {@link ILegacyServiceRuntimeAttestation} after it verified
+ * the observed root against its own registry. 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.
@@ -44,18 +46,86 @@ export interface ILegacyServiceImageSource {
      */
     platforms: ILegacyImagePlatformManifest[];
 }
-/** One healthy replica of the legacy service, observed running the attested digest. */
+/**
+ * One replica of the legacy service, observed running the attested digest in its own stated
+ * health: healthy, or running with no healthcheck that could state one.
+ */
 export interface ILegacyServiceRuntimeTaskAttestation {
+    /** The replica's runtime identity: the Swarm task it was observed as. */
     deploymentId: string;
+    /** The hostname of the node the replica was observed on. */
     nodeName: string;
     observedDigest: TSha256Digest;
 }
+/**
+ * Where the runtime part of an attestation comes from. `administrator-host-observation`: an
+ * administrator read the legacy Swarm service and its containers on the hosts that run them, and
+ * Cloudly judged that observation against its own registry.
+ */
+export type TLegacyServiceRuntimeEvidenceSource = 'administrator-host-observation';
+/** A container's state as the Docker engine reports it (`State.Status`). */
+export type TLegacyHostContainerState = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
+/**
+ * A container's health as the Docker engine reports it (`State.Health.Status`). `none`: no
+ * healthcheck applies to the container — the image declares none and the service adds none — so
+ * the engine reports no health state at all.
+ */
+export type TLegacyHostContainerHealth = 'healthy' | 'unhealthy' | 'starting' | 'none';
+/**
+ * The image store of the Docker engine that runs a container. On the `containerd` store a
+ * container's image id is the digest of the root it was pulled as; on the `classic` store it is
+ * the image configuration digest of the platform manifest the engine pulled.
+ */
+export type TLegacyHostImageStore = 'containerd' | 'classic';
+/** A Swarm service's mode (`Spec.Mode`): a replicated service states its desired replicas. */
+export type TLegacyHostSwarmServiceMode = {
+    kind: 'replicated';
+    desiredReplicas: number;
+} | {
+    kind: 'global';
+};
+/** One replica of a legacy Swarm service, as an administrator read it on the node that runs it. */
+export interface ILegacyHostReplicaObservation {
+    /** The hostname of the node the task runs on. */
+    nodeHostname: string;
+    /** The Swarm task id (25 lowercase base-36 characters). */
+    swarmTaskId: string;
+    /** The full container id of the task (64 lowercase hex characters). */
+    containerId: string;
+    imageStore: TLegacyHostImageStore;
+    /** The container's image id (`Image`), a sha256 digest. */
+    containerImageId: TSha256Digest;
+    /** The `RepoDigests` of the container's image, exactly as the engine lists them. */
+    imageRepoDigests: string[];
+    state: TLegacyHostContainerState;
+    health: TLegacyHostContainerHealth;
+}
+/**
+ * An administrator's observation of the legacy Swarm service of one legacy service and of every
+ * container its tasks run, read on the hosts while the legacy runtime still runs.
+ *
+ * It states facts, not conclusions: Cloudly judges it against its own registry
+ * ({@link judgeLegacyServiceHostObservation}) before it attests anything.
+ */
+export interface ILegacyServiceHostObservation {
+    /** The Swarm service name. */
+    swarmServiceName: string;
+    /** The image reference of the Swarm service spec (`Spec.TaskTemplate.ContainerSpec.Image`). */
+    specImage: string;
+    mode: TLegacyHostSwarmServiceMode;
+    /** When the administrator read the hosts, in milliseconds since the epoch. */
+    observedAt: number;
+    /** Every running task's replica, sorted by `swarmTaskId`. */
+    replicas: ILegacyHostReplicaObservation[];
+}
 /**
  * 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.
+ * desired replica of a legacy service ran, in its own stated health, 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.
+ * stored attestation is by construction one whose runtime digest is its source root digest and
+ * whose runtime part is exactly the host observation it records.
  */
 export interface ILegacyServiceRuntimeAttestation {
     id: string;
@@ -64,11 +134,16 @@ export interface ILegacyServiceRuntimeAttestation {
         organizationId: string;
         source: ILegacyServiceImageSource;
         runtime: {
+            /** The desired replicas of the observed replicated Swarm service. */
             requiredReplicaCount: number;
+            /** Replicas observed running healthy, or running with no healthcheck (`health: 'none'`). */
             healthyReplicaCount: number;
             runtimeDigest: TSha256Digest;
-            /** Sorted by deploymentId, one per required replica. */
+            /** Sorted by deploymentId, one per required replica: the observed replicas. */
             tasks: ILegacyServiceRuntimeTaskAttestation[];
+            evidenceSource: TLegacyServiceRuntimeEvidenceSource;
+            /** The observation the runtime part was built from, as the administrator submitted it. */
+            hostObservation: ILegacyServiceHostObservation;
         };
         capturedByUserId: string;
         capturedAt: number;
@@ -89,4 +164,43 @@ export declare const isLegacyImagePlatformManifestMediaType: (valueArg: unknown)
 /** 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[];
+/**
+ * The shape of a host observation: exact keys at every level, Docker's own value sets, at most 64
+ * replicas, unique and sorted by Swarm task id, each container observed once. It judges nothing
+ * against a registry; {@link judgeLegacyServiceHostObservation} does.
+ */
+export declare const validateLegacyServiceHostObservation: (observationArg: unknown, labelArg?: string) => string[];
+/** True when a value is a well-formed host observation. */
+export declare const isLegacyServiceHostObservation: (valueArg: unknown) => valueArg is ILegacyServiceHostObservation;
+/**
+ * The one root digest every observed replica runs from the legacy service's own repository, which
+ * is the digest Cloudly then inspects in its registry. Refused when a replica's root from that
+ * repository is unknown, when the replicas run more than one root, or when nothing was observed.
+ */
+export declare const selectLegacyServiceHostObservationRootDigest: (argsArg: {
+    observation: ILegacyServiceHostObservation;
+    registryHost: string;
+    repository: string;
+}) => {
+    rootDigest?: TSha256Digest;
+    errors: string[];
+};
+/**
+ * Judges a well-formed host observation against the registry source Cloudly inspected for it.
+ * Every rule an attestation's runtime part must meet:
+ *
+ * - the Swarm service is replicated, with at least one desired replica, and exactly its desired
+ *   replicas were observed;
+ * - its spec image names the source repository by the source tag, by the root digest, or by both;
+ * - every replica is `running`, and `healthy` or without a healthcheck (`none`) — `unhealthy` and
+ *   `starting` are refused;
+ * - every replica runs the source root from the source repository: its image lists
+ *   `registryHost/repository@rootDigest`, and its image id is the root digest on the containerd
+ *   store or one of the root's platform image configuration digests on the classic store.
+ */
+export declare const judgeLegacyServiceHostObservation: (argsArg: {
+    observation: ILegacyServiceHostObservation;
+    source: ILegacyServiceImageSource;
+    label?: string;
+}) => string[];
 export declare const validateLegacyServiceRuntimeAttestation: (attestationArg: unknown) => string[];

package/dist_ts/data/deploymentlegacyimport.js

@@ -1,5 +1,5 @@
 import { normalizeSha256Digest } from './immutableimage.js';
-import { hasExactKeys, isPlainRecord } from '../private/dataproperties.js';
+import { hasExactKeys, isPlainRecord, readDataElements, readDataProperties, } 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}$/;
@@ -16,6 +16,31 @@ const legacyImageImportIndexMediaTypes = [
     'application/vnd.docker.distribution.manifest.list.v2+json',
 ];
 const legacyImagePlatforms = ['linux/amd64', 'linux/arm64'];
+const legacyHostContainerStates = [
+    'created',
+    'running',
+    'paused',
+    'restarting',
+    'removing',
+    'exited',
+    'dead',
+];
+const legacyHostContainerHealths = [
+    'healthy',
+    'unhealthy',
+    'starting',
+    'none',
+];
+/** The health states a replica may be attested in: healthy, or no healthcheck at all. */
+const attestableLegacyHostContainerHealths = ['healthy', 'none'];
+const legacyHostImageStores = ['containerd', 'classic'];
+const swarmTaskIdRegex = /^[a-z0-9]{25}$/;
+const containerIdRegex = /^[0-9a-f]{64}$/;
+const swarmServiceNameRegex = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
+const nodeHostnameRegex = /^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+const imageReferenceRegex = /^\S{1,512}$/;
+const repoDigestRegex = /^[^\s@]{1,440}@sha256:[0-9a-f]{64}$/;
+const maximumRepoDigestCount = 32;
 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'
@@ -44,6 +69,232 @@ export const validateLegacyImageImportReference = (referenceArg) => {
     }
     return errors;
 };
+const validateHostReplicaObservation = (replicaArg, labelArg) => {
+    const replica = readDataProperties(replicaArg);
+    if (replica === null)
+        return [`${labelArg} must be a plain data object`];
+    const errors = [];
+    if (!hasExactKeys(replica, [
+        'nodeHostname',
+        'swarmTaskId',
+        'containerId',
+        'imageStore',
+        'containerImageId',
+        'imageRepoDigests',
+        'state',
+        'health',
+    ])) {
+        errors.push(`${labelArg} must use its exact schema`);
+    }
+    if (typeof replica.nodeHostname !== 'string' || !nodeHostnameRegex.test(replica.nodeHostname)) {
+        errors.push(`${labelArg}.nodeHostname must be a host name`);
+    }
+    if (typeof replica.swarmTaskId !== 'string' || !swarmTaskIdRegex.test(replica.swarmTaskId)) {
+        errors.push(`${labelArg}.swarmTaskId must be a Swarm task id`);
+    }
+    if (typeof replica.containerId !== 'string' || !containerIdRegex.test(replica.containerId)) {
+        errors.push(`${labelArg}.containerId must be a full container id`);
+    }
+    if (!legacyHostImageStores.some((storeArg) => storeArg === replica.imageStore)) {
+        errors.push(`${labelArg}.imageStore must be containerd or classic`);
+    }
+    if (!isCanonicalDigest(replica.containerImageId)) {
+        errors.push(`${labelArg}.containerImageId must be a canonical sha256 digest`);
+    }
+    const repoDigests = readDataElements(replica.imageRepoDigests, maximumRepoDigestCount);
+    if (repoDigests === null
+        || repoDigests.some((entryArg) => typeof entryArg !== 'string' || !repoDigestRegex.test(entryArg))
+        || new Set(repoDigests).size !== repoDigests.length) {
+        errors.push(`${labelArg}.imageRepoDigests must be unique digested image references`);
+    }
+    if (!legacyHostContainerStates.some((stateArg) => stateArg === replica.state)) {
+        errors.push(`${labelArg}.state must be a Docker container state`);
+    }
+    if (!legacyHostContainerHealths.some((healthArg) => healthArg === replica.health)) {
+        errors.push(`${labelArg}.health must be healthy, unhealthy, starting or none`);
+    }
+    return errors;
+};
+const validateHostSwarmServiceMode = (modeArg, labelArg) => {
+    const mode = readDataProperties(modeArg);
+    if (mode === null)
+        return [`${labelArg} must be a plain data object`];
+    if (mode.kind === 'global') {
+        return hasExactKeys(mode, ['kind']) ? [] : [`${labelArg} must use its exact schema`];
+    }
+    if (mode.kind !== 'replicated')
+        return [`${labelArg}.kind must be replicated or global`];
+    const errors = [];
+    if (!hasExactKeys(mode, ['kind', 'desiredReplicas'])) {
+        errors.push(`${labelArg} must use its exact schema`);
+    }
+    if (typeof mode.desiredReplicas !== 'number'
+        || !Number.isSafeInteger(mode.desiredReplicas)
+        || mode.desiredReplicas < 0
+        || mode.desiredReplicas > maximumReplicaCount) {
+        errors.push(`${labelArg}.desiredReplicas must be a bounded replica count`);
+    }
+    return errors;
+};
+/**
+ * The shape of a host observation: exact keys at every level, Docker's own value sets, at most 64
+ * replicas, unique and sorted by Swarm task id, each container observed once. It judges nothing
+ * against a registry; {@link judgeLegacyServiceHostObservation} does.
+ */
+export const validateLegacyServiceHostObservation = (observationArg, labelArg = 'hostObservation') => {
+    const observation = readDataProperties(observationArg);
+    if (observation === null)
+        return [`${labelArg} must be a plain data object`];
+    const errors = [];
+    if (!hasExactKeys(observation, ['swarmServiceName', 'specImage', 'mode', 'observedAt', 'replicas'])) {
+        errors.push(`${labelArg} must use its exact schema`);
+    }
+    if (typeof observation.swarmServiceName !== 'string'
+        || !swarmServiceNameRegex.test(observation.swarmServiceName)) {
+        errors.push(`${labelArg}.swarmServiceName must be a Swarm service name`);
+    }
+    if (typeof observation.specImage !== 'string' || !imageReferenceRegex.test(observation.specImage)) {
+        errors.push(`${labelArg}.specImage must be a bounded image reference`);
+    }
+    errors.push(...validateHostSwarmServiceMode(observation.mode, `${labelArg}.mode`));
+    if (!isPositiveSafeInteger(observation.observedAt, Number.MAX_SAFE_INTEGER)) {
+        errors.push(`${labelArg}.observedAt must be a positive timestamp`);
+    }
+    const replicas = readDataElements(observation.replicas, maximumReplicaCount);
+    if (replicas === null) {
+        errors.push(`${labelArg}.replicas must be a list of at most ${maximumReplicaCount} replicas`);
+        return errors;
+    }
+    replicas.forEach((replicaArg, indexArg) => {
+        errors.push(...validateHostReplicaObservation(replicaArg, `${labelArg}.replicas[${indexArg}]`));
+    });
+    const readReplicaKey = (replicaArg, keyArg) => (readDataProperties(replicaArg)?.[keyArg]);
+    const taskIds = replicas.map((replicaArg) => readReplicaKey(replicaArg, 'swarmTaskId'));
+    const sortedTaskIds = taskIds
+        .filter((idArg) => typeof idArg === 'string')
+        .sort();
+    if (new Set(taskIds).size !== taskIds.length
+        || JSON.stringify(taskIds) !== JSON.stringify(sortedTaskIds)) {
+        errors.push(`${labelArg}.replicas must be unique and sorted by swarmTaskId`);
+    }
+    const containerIds = replicas.map((replicaArg) => readReplicaKey(replicaArg, 'containerId'));
+    if (new Set(containerIds).size !== containerIds.length) {
+        errors.push(`${labelArg}.replicas must observe each container once`);
+    }
+    return errors;
+};
+/** True when a value is a well-formed host observation. */
+export const isLegacyServiceHostObservation = (valueArg) => (validateLegacyServiceHostObservation(valueArg).length === 0);
+/**
+ * The root digest one replica was pulled as from `registryHost/repository`.
+ *
+ * On the containerd store that is the container's image id, which the image's `RepoDigests` must
+ * list for the repository. On the classic store it is the one digest `RepoDigests` lists for the
+ * repository; none, or more than one, leaves the root unknown.
+ */
+const selectReplicaRootDigest = (replicaArg, repositoryReferenceArg) => {
+    const prefix = `${repositoryReferenceArg}@`;
+    const repositoryDigests = replicaArg.imageRepoDigests
+        .filter((entryArg) => entryArg.startsWith(prefix))
+        .map((entryArg) => normalizeSha256Digest(entryArg.slice(prefix.length)))
+        .filter((digestArg) => digestArg !== undefined);
+    if (replicaArg.imageStore === 'containerd') {
+        return repositoryDigests.includes(replicaArg.containerImageId)
+            ? replicaArg.containerImageId
+            : undefined;
+    }
+    return repositoryDigests.length === 1 ? repositoryDigests[0] : undefined;
+};
+/**
+ * The one root digest every observed replica runs from the legacy service's own repository, which
+ * is the digest Cloudly then inspects in its registry. Refused when a replica's root from that
+ * repository is unknown, when the replicas run more than one root, or when nothing was observed.
+ */
+export const selectLegacyServiceHostObservationRootDigest = (argsArg) => {
+    const repositoryReference = `${argsArg.registryHost}/${argsArg.repository}`;
+    const errors = [];
+    const roots = new Set();
+    argsArg.observation.replicas.forEach((replicaArg, indexArg) => {
+        const root = selectReplicaRootDigest(replicaArg, repositoryReference);
+        if (root === undefined) {
+            errors.push(replicaArg.imageStore === 'containerd'
+                ? `hostObservation.replicas[${indexArg}] image is not listed as ${repositoryReference}@<its image id>`
+                : `hostObservation.replicas[${indexArg}] image lists not exactly one digest of ${repositoryReference}`);
+            return;
+        }
+        roots.add(root);
+    });
+    if (argsArg.observation.replicas.length === 0) {
+        errors.push('hostObservation must observe at least one replica');
+    }
+    if (roots.size > 1) {
+        errors.push('hostObservation replicas run more than one root digest');
+    }
+    const [rootDigest] = [...roots];
+    return errors.length === 0 && rootDigest !== undefined ? { rootDigest, errors } : { errors };
+};
+/**
+ * Judges a well-formed host observation against the registry source Cloudly inspected for it.
+ * Every rule an attestation's runtime part must meet:
+ *
+ * - the Swarm service is replicated, with at least one desired replica, and exactly its desired
+ *   replicas were observed;
+ * - its spec image names the source repository by the source tag, by the root digest, or by both;
+ * - every replica is `running`, and `healthy` or without a healthcheck (`none`) — `unhealthy` and
+ *   `starting` are refused;
+ * - every replica runs the source root from the source repository: its image lists
+ *   `registryHost/repository@rootDigest`, and its image id is the root digest on the containerd
+ *   store or one of the root's platform image configuration digests on the classic store.
+ */
+export const judgeLegacyServiceHostObservation = (argsArg) => {
+    const label = argsArg.label ?? 'hostObservation';
+    const { observation, source } = argsArg;
+    const errors = [];
+    if (observation.mode.kind !== 'replicated') {
+        errors.push(`${label}.mode must be replicated: a legacy service runs as a replicated Swarm service`);
+    }
+    else if (observation.mode.desiredReplicas < 1) {
+        errors.push(`${label}.mode must desire at least one replica`);
+    }
+    else if (observation.replicas.length !== observation.mode.desiredReplicas) {
+        errors.push(`${label} must observe exactly the ${observation.mode.desiredReplicas} desired replicas`);
+    }
+    const repositoryReference = `${source.registryHost}/${source.repository}`;
+    const specImages = [
+        `${repositoryReference}:${source.tag}`,
+        `${repositoryReference}@${source.rootDigest}`,
+        `${repositoryReference}:${source.tag}@${source.rootDigest}`,
+    ];
+    if (!specImages.includes(observation.specImage)) {
+        errors.push(`${label}.specImage must name ${repositoryReference} by its source tag or root digest`);
+    }
+    const imageConfigDigests = source.platforms.map((platformArg) => platformArg.imageConfigDigest);
+    observation.replicas.forEach((replicaArg, indexArg) => {
+        const replicaLabel = `${label}.replicas[${indexArg}]`;
+        if (replicaArg.state !== 'running') {
+            errors.push(`${replicaLabel}.state must be running`);
+        }
+        if (!attestableLegacyHostContainerHealths.includes(replicaArg.health)) {
+            errors.push(`${replicaLabel}.health must be healthy or none`);
+        }
+        if (!replicaArg.imageRepoDigests.includes(`${repositoryReference}@${source.rootDigest}`)) {
+            errors.push(`${replicaLabel} image must be ${repositoryReference}@${source.rootDigest}`);
+        }
+        if (replicaArg.imageStore === 'containerd') {
+            if (replicaArg.containerImageId !== source.rootDigest) {
+                errors.push(`${replicaLabel}.containerImageId must be the root digest on the containerd image store`);
+            }
+            return;
+        }
+        if (!imageConfigDigests.includes(replicaArg.containerImageId)) {
+            errors.push(`${replicaLabel}.containerImageId must be a platform image configuration digest of the root on the classic image store`);
+        }
+        if (selectReplicaRootDigest(replicaArg, repositoryReference) === undefined) {
+            errors.push(`${replicaLabel} image must list exactly one digest of ${repositoryReference} on the classic image store`);
+        }
+    });
+    return errors;
+};
 const validatePlatformManifest = (manifestArg, indexArg) => {
     const label = `source.platforms[${indexArg}]`;
     if (!isPlainRecord(manifestArg))
@@ -137,18 +388,51 @@ const validateImageSource = (sourceArg) => {
     }
     return errors;
 };
-const validateRuntime = (runtimeArg, rootDigestArg) => {
+const isLegacyServiceImageSource = (valueArg) => (validateImageSource(valueArg).length === 0);
+const validateRuntime = (runtimeArg, sourceArg) => {
     if (!isPlainRecord(runtimeArg))
         return ['runtime must be an object'];
+    const rootDigest = isPlainRecord(sourceArg) ? sourceArg.rootDigest : undefined;
     const errors = [];
     if (!hasExactKeys(runtimeArg, [
         'requiredReplicaCount',
         'healthyReplicaCount',
         'runtimeDigest',
         'tasks',
+        'evidenceSource',
+        'hostObservation',
     ])) {
         errors.push('runtime must use its exact schema');
     }
+    if (runtimeArg.evidenceSource !== 'administrator-host-observation') {
+        errors.push('runtime.evidenceSource must be administrator-host-observation');
+    }
+    const hostObservation = runtimeArg.hostObservation;
+    const observationErrors = validateLegacyServiceHostObservation(hostObservation, 'runtime.hostObservation');
+    errors.push(...observationErrors);
+    if (observationErrors.length === 0
+        && isLegacyServiceHostObservation(hostObservation)
+        && isLegacyServiceImageSource(sourceArg)) {
+        errors.push(...judgeLegacyServiceHostObservation({
+            observation: hostObservation,
+            source: sourceArg,
+            label: 'runtime.hostObservation',
+        }));
+        if (hostObservation.mode.kind === 'replicated'
+            && runtimeArg.requiredReplicaCount !== hostObservation.mode.desiredReplicas) {
+            errors.push('runtime.requiredReplicaCount must be the observed desired replicas');
+        }
+        const recordedTasks = readDataElements(runtimeArg.tasks, maximumReplicaCount) ?? [];
+        if (recordedTasks.length !== hostObservation.replicas.length
+            || hostObservation.replicas.some((replicaArg, indexArg) => {
+                const task = recordedTasks[indexArg];
+                return !isPlainRecord(task)
+                    || task.deploymentId !== replicaArg.swarmTaskId
+                    || task.nodeName !== replicaArg.nodeHostname;
+            })) {
+            errors.push('runtime.tasks must be the observed replicas: each Swarm task on its node');
+        }
+    }
     if (!isPositiveSafeInteger(runtimeArg.requiredReplicaCount, maximumReplicaCount)) {
         errors.push('runtime.requiredReplicaCount must be a positive bounded replica count');
     }
@@ -158,7 +442,7 @@ const validateRuntime = (runtimeArg, rootDigestArg) => {
     if (!isCanonicalDigest(runtimeArg.runtimeDigest)) {
         errors.push('runtime.runtimeDigest must be a canonical sha256 digest');
     }
-    else if (runtimeArg.runtimeDigest !== rootDigestArg) {
+    else if (runtimeArg.runtimeDigest !== rootDigest) {
         errors.push('runtime.runtimeDigest must be the attested source root digest');
     }
     if (!Array.isArray(runtimeArg.tasks) || runtimeArg.tasks.length !== runtimeArg.requiredReplicaCount) {
@@ -231,7 +515,7 @@ export const validateLegacyServiceRuntimeAttestation = (attestationArg) => {
         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));
+    errors.push(...validateRuntime(data.runtime, data.source));
     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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploymentlegacyimport.js","sourceRoot":"","sources":["../../ts/data/deploymentlegacyimport.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/service.d.ts

@@ -9,7 +9,7 @@ import type { IImageRelease } from '../data/immutableimage.js';
 import type { IDeploymentPreflightReport, IDeploymentPreflightRequestData } from '../data/deploymentpreflight.js';
 import type { IDeploymentReservationInput, IServiceDeploymentOperation, IServiceDeploymentStatus } from '../data/deploymentoperation.js';
 import type { TSha256Digest } from '../data/immutableimage.js';
-import type { ILegacyServiceRuntimeAttestation } from '../data/deploymentlegacyimport.js';
+import type { ILegacyServiceHostObservation, ILegacyServiceRuntimeAttestation } from '../data/deploymentlegacyimport.js';
 import type { IProtocolOffer } from '../protocol.js';
 import type { IRuntimeAssignmentLogAttemptPage, IRuntimeAssignmentLogPage } from '../data/runtimeassignmentlogs.js';
 import type { IServiceRuntimeAssignmentView, IServiceRuntimeSpec, IServiceRuntimeStatus, TServiceRuntimeSpecWritableData } from '../data/serviceruntime.js';
@@ -224,10 +224,13 @@ export interface IRequest_Any_Cloudly_CleanupServiceDeployment extends plugins.t
     };
 }
 /**
- * Captures durable evidence that a legacy `deployOnPush` service runs exactly the registry root its
- * tag names: every required replica observed healthy on that one digest, with the root's platform
- * manifests read from Cloudly's own registry. Administrators only, and only while the legacy
- * runtime still runs — incomplete evidence is refused, never stored.
+ * Captures durable evidence that a legacy `deployOnPush` service runs exactly one registry root of
+ * its own repository, from an administrator's observation of its Swarm service and containers on
+ * the hosts that run them (`hostObservation`). Cloudly judges the observation itself
+ * (`data.judgeLegacyServiceHostObservation`): every desired replica running, healthy or without a
+ * healthcheck, on one root that is whole in Cloudly's own registry, its platform manifests read
+ * from there. The source tag need not still name that root. Administrators only, and only while
+ * the legacy runtime still runs — incomplete evidence is refused, never stored.
  *
  * `expectedRuntimeDigest`, when stated, is an assertion the observed digest must equal. Capturing
  * again for an unchanged digest returns the attestation already stored.
@@ -238,6 +241,7 @@ export interface IRequest_Any_Cloudly_CaptureLegacyServiceRuntimeAttestation ext
         identity: IIdentityCredential;
         legacyServiceId: string;
         expectedRuntimeDigest?: TSha256Digest;
+        hostObservation: ILegacyServiceHostObservation;
     };
     response: {
         attestation: ILegacyServiceRuntimeAttestation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.50.0",
+  "version": "32.51.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -30,7 +30,7 @@
     "@git.zone/tsbuild": "^5.1.2",
     "@git.zone/tsdoc": "^3.0.2",
     "@git.zone/tsrun": "^3.0.2",
-    "@git.zone/tstest": "^7.1.0",
+    "@git.zone/tstest": "^7.2.0",
     "@types/node": "26.6.3"
   },
   "files": [

package/readme.md

@@ -3640,7 +3640,7 @@ The immutable deployment workflow is:
 
 A legacy `deployOnPush` service without deployable source moves to a greenfield successor by a legacy import, which replaces step 2:
 
-- While the legacy replicas still run — before its runtime is frozen — an administrator captures the evidence with `captureLegacyServiceRuntimeAttestation` (`requests.service.IRequest_Any_Cloudly_CaptureLegacyServiceRuntimeAttestation`). The stored `data.ILegacyServiceRuntimeAttestation` records every required replica healthy on one digest, the registry root the legacy tag names, and that root's platform manifests; `data.validateLegacyServiceRuntimeAttestation` states its rules. Incomplete evidence is refused, never stored, and there is no substitute once the runtime is stopped. `getLegacyServiceRuntimeAttestations` lists what Cloudly holds for a legacy service; both requests are for administrators only.
+- While the legacy replicas still run — before its runtime is frozen — an administrator reads the legacy Swarm service and every container of its tasks on the hosts that run them, and submits that as `hostObservation` (`data.ILegacyServiceHostObservation`: Swarm service name, spec image and mode with its desired replicas; per replica the node hostname, Swarm task id, container id, the engine's image store, the container's image id, the image's `RepoDigests`, the container state and its health, `none` when no healthcheck applies) to `captureLegacyServiceRuntimeAttestation` (`requests.service.IRequest_Any_Cloudly_CaptureLegacyServiceRuntimeAttestation`). `data.validateLegacyServiceHostObservation` judges its shape, `data.selectLegacyServiceHostObservationRootDigest` names the one root every replica runs from the service's own repository, and `data.judgeLegacyServiceHostObservation` judges it against that root as Cloudly reads it from its own registry: exactly the desired replicas of a replicated service, its spec image naming the repository by the source tag or the root digest, every replica `running` and `healthy` or `none`, each container's image id the root digest on the containerd image store or one of the root's platform image configuration digests on the classic store. The source tag need not still name the root. The stored `data.ILegacyServiceRuntimeAttestation` records that root, its platform manifests, the replicas, the evidence source `administrator-host-observation` and the observation itself; `data.validateLegacyServiceRuntimeAttestation` states its rules. Incomplete evidence is refused, never stored, and there is no substitute once the runtime is stopped. `getLegacyServiceRuntimeAttestations` lists what Cloudly holds for a legacy service; both requests are for administrators only.
 - The greenfield reservation, and every preflight of it, names `legacyImport` (`data.ILegacyImageImportReference`: legacy service, attestation, asserted source root digest) instead of `sourceRevision`, `sourceDirty` and release evidence. Refusals are the blockers `LEGACY_IMPORT_ATTESTATION_MISSING`, `LEGACY_IMPORT_SOURCE_MISMATCH` and `LEGACY_IMPORT_PLATFORM_MISMATCH`.
 - Instead of the registry push, the deployer calls `importServiceDeploymentLegacyImage`: Cloudly imports the attested image from its own registry into the reserved tag — an index root as it is, a single platform manifest under a one-descriptor index of the manifest's own family — and records release evidence of source `cloudly-legacy-import` naming the legacy source. Steps 3 to 5 follow unchanged; `selectTrustedImageReleaseEvidence` accepts that evidence only with `evidenceSource: 'cloudly-legacy-import'`.
 - The reservation and the import need the capability `deployment:import-legacy`, which only an organization-service-slot grant can carry.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '32.50.0',
+  version: '32.51.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/deploymentlegacyimport.ts

@@ -4,15 +4,22 @@ import type {
   TSha256Digest,
 } from './immutableimage.js';
 import { normalizeSha256Digest } from './immutableimage.js';
-import { hasExactKeys, isPlainRecord } from '../private/dataproperties.js';
+import {
+  hasExactKeys,
+  isPlainRecord,
+  readDataElements,
+  readDataProperties,
+} from '../private/dataproperties.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
+ * its runtime is frozen, replicas running it. An administrator observes those replicas on the
+ * hosts that run them ({@link ILegacyServiceHostObservation}) while they still run, and Cloudly
+ * captures that observation once as a {@link ILegacyServiceRuntimeAttestation} after it verified
+ * the observed root against its own registry. 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.
@@ -60,19 +67,98 @@ export interface ILegacyServiceImageSource {
   platforms: ILegacyImagePlatformManifest[];
 }
 
-/** One healthy replica of the legacy service, observed running the attested digest. */
+/**
+ * One replica of the legacy service, observed running the attested digest in its own stated
+ * health: healthy, or running with no healthcheck that could state one.
+ */
 export interface ILegacyServiceRuntimeTaskAttestation {
+  /** The replica's runtime identity: the Swarm task it was observed as. */
   deploymentId: string;
+  /** The hostname of the node the replica was observed on. */
   nodeName: string;
   observedDigest: TSha256Digest;
 }
 
+/**
+ * Where the runtime part of an attestation comes from. `administrator-host-observation`: an
+ * administrator read the legacy Swarm service and its containers on the hosts that run them, and
+ * Cloudly judged that observation against its own registry.
+ */
+export type TLegacyServiceRuntimeEvidenceSource = 'administrator-host-observation';
+
+/** A container's state as the Docker engine reports it (`State.Status`). */
+export type TLegacyHostContainerState =
+  | 'created'
+  | 'running'
+  | 'paused'
+  | 'restarting'
+  | 'removing'
+  | 'exited'
+  | 'dead';
+
+/**
+ * A container's health as the Docker engine reports it (`State.Health.Status`). `none`: no
+ * healthcheck applies to the container — the image declares none and the service adds none — so
+ * the engine reports no health state at all.
+ */
+export type TLegacyHostContainerHealth = 'healthy' | 'unhealthy' | 'starting' | 'none';
+
+/**
+ * The image store of the Docker engine that runs a container. On the `containerd` store a
+ * container's image id is the digest of the root it was pulled as; on the `classic` store it is
+ * the image configuration digest of the platform manifest the engine pulled.
+ */
+export type TLegacyHostImageStore = 'containerd' | 'classic';
+
+/** A Swarm service's mode (`Spec.Mode`): a replicated service states its desired replicas. */
+export type TLegacyHostSwarmServiceMode =
+  | { kind: 'replicated'; desiredReplicas: number }
+  | { kind: 'global' };
+
+/** One replica of a legacy Swarm service, as an administrator read it on the node that runs it. */
+export interface ILegacyHostReplicaObservation {
+  /** The hostname of the node the task runs on. */
+  nodeHostname: string;
+  /** The Swarm task id (25 lowercase base-36 characters). */
+  swarmTaskId: string;
+  /** The full container id of the task (64 lowercase hex characters). */
+  containerId: string;
+  imageStore: TLegacyHostImageStore;
+  /** The container's image id (`Image`), a sha256 digest. */
+  containerImageId: TSha256Digest;
+  /** The `RepoDigests` of the container's image, exactly as the engine lists them. */
+  imageRepoDigests: string[];
+  state: TLegacyHostContainerState;
+  health: TLegacyHostContainerHealth;
+}
+
+/**
+ * An administrator's observation of the legacy Swarm service of one legacy service and of every
+ * container its tasks run, read on the hosts while the legacy runtime still runs.
+ *
+ * It states facts, not conclusions: Cloudly judges it against its own registry
+ * ({@link judgeLegacyServiceHostObservation}) before it attests anything.
+ */
+export interface ILegacyServiceHostObservation {
+  /** The Swarm service name. */
+  swarmServiceName: string;
+  /** The image reference of the Swarm service spec (`Spec.TaskTemplate.ContainerSpec.Image`). */
+  specImage: string;
+  mode: TLegacyHostSwarmServiceMode;
+  /** When the administrator read the hosts, in milliseconds since the epoch. */
+  observedAt: number;
+  /** Every running task's replica, sorted by `swarmTaskId`. */
+  replicas: ILegacyHostReplicaObservation[];
+}
+
 /**
  * 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.
+ * desired replica of a legacy service ran, in its own stated health, 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.
+ * stored attestation is by construction one whose runtime digest is its source root digest and
+ * whose runtime part is exactly the host observation it records.
  */
 export interface ILegacyServiceRuntimeAttestation {
   id: string;
@@ -81,11 +167,16 @@ export interface ILegacyServiceRuntimeAttestation {
     organizationId: string;
     source: ILegacyServiceImageSource;
     runtime: {
+      /** The desired replicas of the observed replicated Swarm service. */
       requiredReplicaCount: number;
+      /** Replicas observed running healthy, or running with no healthcheck (`health: 'none'`). */
       healthyReplicaCount: number;
       runtimeDigest: TSha256Digest;
-      /** Sorted by deploymentId, one per required replica. */
+      /** Sorted by deploymentId, one per required replica: the observed replicas. */
       tasks: ILegacyServiceRuntimeTaskAttestation[];
+      evidenceSource: TLegacyServiceRuntimeEvidenceSource;
+      /** The observation the runtime part was built from, as the administrator submitted it. */
+      hostObservation: ILegacyServiceHostObservation;
     };
     capturedByUserId: string;
     capturedAt: number;
@@ -120,6 +211,31 @@ const legacyImageImportIndexMediaTypes: readonly TLegacyImageImportIndexMediaTyp
   'application/vnd.docker.distribution.manifest.list.v2+json',
 ];
 const legacyImagePlatforms: readonly TImmutableContainerPlatform[] = ['linux/amd64', 'linux/arm64'];
+const legacyHostContainerStates: readonly TLegacyHostContainerState[] = [
+  'created',
+  'running',
+  'paused',
+  'restarting',
+  'removing',
+  'exited',
+  'dead',
+];
+const legacyHostContainerHealths: readonly TLegacyHostContainerHealth[] = [
+  'healthy',
+  'unhealthy',
+  'starting',
+  'none',
+];
+/** The health states a replica may be attested in: healthy, or no healthcheck at all. */
+const attestableLegacyHostContainerHealths: readonly TLegacyHostContainerHealth[] = ['healthy', 'none'];
+const legacyHostImageStores: readonly TLegacyHostImageStore[] = ['containerd', 'classic'];
+const swarmTaskIdRegex = /^[a-z0-9]{25}$/;
+const containerIdRegex = /^[0-9a-f]{64}$/;
+const swarmServiceNameRegex = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
+const nodeHostnameRegex = /^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+const imageReferenceRegex = /^\S{1,512}$/;
+const repoDigestRegex = /^[^\s@]{1,440}@sha256:[0-9a-f]{64}$/;
+const maximumRepoDigestCount = 32;
 
 const isIdentifier = (valueArg: unknown): valueArg is string => (
   typeof valueArg === 'string' && identifierRegex.test(valueArg)
@@ -168,6 +284,256 @@ export const validateLegacyImageImportReference = (referenceArg: unknown): strin
   return errors;
 };
 
+const validateHostReplicaObservation = (
+  replicaArg: unknown,
+  labelArg: string,
+): string[] => {
+  const replica = readDataProperties(replicaArg);
+  if (replica === null) return [`${labelArg} must be a plain data object`];
+  const errors: string[] = [];
+  if (!hasExactKeys(replica, [
+    'nodeHostname',
+    'swarmTaskId',
+    'containerId',
+    'imageStore',
+    'containerImageId',
+    'imageRepoDigests',
+    'state',
+    'health',
+  ])) {
+    errors.push(`${labelArg} must use its exact schema`);
+  }
+  if (typeof replica.nodeHostname !== 'string' || !nodeHostnameRegex.test(replica.nodeHostname)) {
+    errors.push(`${labelArg}.nodeHostname must be a host name`);
+  }
+  if (typeof replica.swarmTaskId !== 'string' || !swarmTaskIdRegex.test(replica.swarmTaskId)) {
+    errors.push(`${labelArg}.swarmTaskId must be a Swarm task id`);
+  }
+  if (typeof replica.containerId !== 'string' || !containerIdRegex.test(replica.containerId)) {
+    errors.push(`${labelArg}.containerId must be a full container id`);
+  }
+  if (!legacyHostImageStores.some((storeArg) => storeArg === replica.imageStore)) {
+    errors.push(`${labelArg}.imageStore must be containerd or classic`);
+  }
+  if (!isCanonicalDigest(replica.containerImageId)) {
+    errors.push(`${labelArg}.containerImageId must be a canonical sha256 digest`);
+  }
+  const repoDigests = readDataElements(replica.imageRepoDigests, maximumRepoDigestCount);
+  if (repoDigests === null
+    || repoDigests.some((entryArg) => typeof entryArg !== 'string' || !repoDigestRegex.test(entryArg))
+    || new Set(repoDigests).size !== repoDigests.length) {
+    errors.push(`${labelArg}.imageRepoDigests must be unique digested image references`);
+  }
+  if (!legacyHostContainerStates.some((stateArg) => stateArg === replica.state)) {
+    errors.push(`${labelArg}.state must be a Docker container state`);
+  }
+  if (!legacyHostContainerHealths.some((healthArg) => healthArg === replica.health)) {
+    errors.push(`${labelArg}.health must be healthy, unhealthy, starting or none`);
+  }
+  return errors;
+};
+
+const validateHostSwarmServiceMode = (modeArg: unknown, labelArg: string): string[] => {
+  const mode = readDataProperties(modeArg);
+  if (mode === null) return [`${labelArg} must be a plain data object`];
+  if (mode.kind === 'global') {
+    return hasExactKeys(mode, ['kind']) ? [] : [`${labelArg} must use its exact schema`];
+  }
+  if (mode.kind !== 'replicated') return [`${labelArg}.kind must be replicated or global`];
+  const errors: string[] = [];
+  if (!hasExactKeys(mode, ['kind', 'desiredReplicas'])) {
+    errors.push(`${labelArg} must use its exact schema`);
+  }
+  if (typeof mode.desiredReplicas !== 'number'
+    || !Number.isSafeInteger(mode.desiredReplicas)
+    || mode.desiredReplicas < 0
+    || mode.desiredReplicas > maximumReplicaCount) {
+    errors.push(`${labelArg}.desiredReplicas must be a bounded replica count`);
+  }
+  return errors;
+};
+
+/**
+ * The shape of a host observation: exact keys at every level, Docker's own value sets, at most 64
+ * replicas, unique and sorted by Swarm task id, each container observed once. It judges nothing
+ * against a registry; {@link judgeLegacyServiceHostObservation} does.
+ */
+export const validateLegacyServiceHostObservation = (
+  observationArg: unknown,
+  labelArg = 'hostObservation',
+): string[] => {
+  const observation = readDataProperties(observationArg);
+  if (observation === null) return [`${labelArg} must be a plain data object`];
+  const errors: string[] = [];
+  if (!hasExactKeys(observation, ['swarmServiceName', 'specImage', 'mode', 'observedAt', 'replicas'])) {
+    errors.push(`${labelArg} must use its exact schema`);
+  }
+  if (typeof observation.swarmServiceName !== 'string'
+    || !swarmServiceNameRegex.test(observation.swarmServiceName)) {
+    errors.push(`${labelArg}.swarmServiceName must be a Swarm service name`);
+  }
+  if (typeof observation.specImage !== 'string' || !imageReferenceRegex.test(observation.specImage)) {
+    errors.push(`${labelArg}.specImage must be a bounded image reference`);
+  }
+  errors.push(...validateHostSwarmServiceMode(observation.mode, `${labelArg}.mode`));
+  if (!isPositiveSafeInteger(observation.observedAt, Number.MAX_SAFE_INTEGER)) {
+    errors.push(`${labelArg}.observedAt must be a positive timestamp`);
+  }
+  const replicas = readDataElements(observation.replicas, maximumReplicaCount);
+  if (replicas === null) {
+    errors.push(`${labelArg}.replicas must be a list of at most ${maximumReplicaCount} replicas`);
+    return errors;
+  }
+  replicas.forEach((replicaArg, indexArg) => {
+    errors.push(...validateHostReplicaObservation(replicaArg, `${labelArg}.replicas[${indexArg}]`));
+  });
+  const readReplicaKey = (replicaArg: unknown, keyArg: string): unknown => (
+    readDataProperties(replicaArg)?.[keyArg]
+  );
+  const taskIds = replicas.map((replicaArg) => readReplicaKey(replicaArg, 'swarmTaskId'));
+  const sortedTaskIds = taskIds
+    .filter((idArg): idArg is string => typeof idArg === 'string')
+    .sort();
+  if (new Set(taskIds).size !== taskIds.length
+    || JSON.stringify(taskIds) !== JSON.stringify(sortedTaskIds)) {
+    errors.push(`${labelArg}.replicas must be unique and sorted by swarmTaskId`);
+  }
+  const containerIds = replicas.map((replicaArg) => readReplicaKey(replicaArg, 'containerId'));
+  if (new Set(containerIds).size !== containerIds.length) {
+    errors.push(`${labelArg}.replicas must observe each container once`);
+  }
+  return errors;
+};
+
+/** True when a value is a well-formed host observation. */
+export const isLegacyServiceHostObservation = (
+  valueArg: unknown,
+): valueArg is ILegacyServiceHostObservation => (
+  validateLegacyServiceHostObservation(valueArg).length === 0
+);
+
+/**
+ * The root digest one replica was pulled as from `registryHost/repository`.
+ *
+ * On the containerd store that is the container's image id, which the image's `RepoDigests` must
+ * list for the repository. On the classic store it is the one digest `RepoDigests` lists for the
+ * repository; none, or more than one, leaves the root unknown.
+ */
+const selectReplicaRootDigest = (
+  replicaArg: ILegacyHostReplicaObservation,
+  repositoryReferenceArg: string,
+): TSha256Digest | undefined => {
+  const prefix = `${repositoryReferenceArg}@`;
+  const repositoryDigests = replicaArg.imageRepoDigests
+    .filter((entryArg) => entryArg.startsWith(prefix))
+    .map((entryArg) => normalizeSha256Digest(entryArg.slice(prefix.length)))
+    .filter((digestArg): digestArg is TSha256Digest => digestArg !== undefined);
+  if (replicaArg.imageStore === 'containerd') {
+    return repositoryDigests.includes(replicaArg.containerImageId)
+      ? replicaArg.containerImageId
+      : undefined;
+  }
+  return repositoryDigests.length === 1 ? repositoryDigests[0] : undefined;
+};
+
+/**
+ * The one root digest every observed replica runs from the legacy service's own repository, which
+ * is the digest Cloudly then inspects in its registry. Refused when a replica's root from that
+ * repository is unknown, when the replicas run more than one root, or when nothing was observed.
+ */
+export const selectLegacyServiceHostObservationRootDigest = (argsArg: {
+  observation: ILegacyServiceHostObservation;
+  registryHost: string;
+  repository: string;
+}): { rootDigest?: TSha256Digest; errors: string[] } => {
+  const repositoryReference = `${argsArg.registryHost}/${argsArg.repository}`;
+  const errors: string[] = [];
+  const roots = new Set<TSha256Digest>();
+  argsArg.observation.replicas.forEach((replicaArg, indexArg) => {
+    const root = selectReplicaRootDigest(replicaArg, repositoryReference);
+    if (root === undefined) {
+      errors.push(replicaArg.imageStore === 'containerd'
+        ? `hostObservation.replicas[${indexArg}] image is not listed as ${repositoryReference}@<its image id>`
+        : `hostObservation.replicas[${indexArg}] image lists not exactly one digest of ${repositoryReference}`);
+      return;
+    }
+    roots.add(root);
+  });
+  if (argsArg.observation.replicas.length === 0) {
+    errors.push('hostObservation must observe at least one replica');
+  }
+  if (roots.size > 1) {
+    errors.push('hostObservation replicas run more than one root digest');
+  }
+  const [rootDigest] = [...roots];
+  return errors.length === 0 && rootDigest !== undefined ? { rootDigest, errors } : { errors };
+};
+
+/**
+ * Judges a well-formed host observation against the registry source Cloudly inspected for it.
+ * Every rule an attestation's runtime part must meet:
+ *
+ * - the Swarm service is replicated, with at least one desired replica, and exactly its desired
+ *   replicas were observed;
+ * - its spec image names the source repository by the source tag, by the root digest, or by both;
+ * - every replica is `running`, and `healthy` or without a healthcheck (`none`) — `unhealthy` and
+ *   `starting` are refused;
+ * - every replica runs the source root from the source repository: its image lists
+ *   `registryHost/repository@rootDigest`, and its image id is the root digest on the containerd
+ *   store or one of the root's platform image configuration digests on the classic store.
+ */
+export const judgeLegacyServiceHostObservation = (argsArg: {
+  observation: ILegacyServiceHostObservation;
+  source: ILegacyServiceImageSource;
+  label?: string;
+}): string[] => {
+  const label = argsArg.label ?? 'hostObservation';
+  const { observation, source } = argsArg;
+  const errors: string[] = [];
+  if (observation.mode.kind !== 'replicated') {
+    errors.push(`${label}.mode must be replicated: a legacy service runs as a replicated Swarm service`);
+  } else if (observation.mode.desiredReplicas < 1) {
+    errors.push(`${label}.mode must desire at least one replica`);
+  } else if (observation.replicas.length !== observation.mode.desiredReplicas) {
+    errors.push(`${label} must observe exactly the ${observation.mode.desiredReplicas} desired replicas`);
+  }
+  const repositoryReference = `${source.registryHost}/${source.repository}`;
+  const specImages = [
+    `${repositoryReference}:${source.tag}`,
+    `${repositoryReference}@${source.rootDigest}`,
+    `${repositoryReference}:${source.tag}@${source.rootDigest}`,
+  ];
+  if (!specImages.includes(observation.specImage)) {
+    errors.push(`${label}.specImage must name ${repositoryReference} by its source tag or root digest`);
+  }
+  const imageConfigDigests = source.platforms.map((platformArg) => platformArg.imageConfigDigest);
+  observation.replicas.forEach((replicaArg, indexArg) => {
+    const replicaLabel = `${label}.replicas[${indexArg}]`;
+    if (replicaArg.state !== 'running') {
+      errors.push(`${replicaLabel}.state must be running`);
+    }
+    if (!attestableLegacyHostContainerHealths.includes(replicaArg.health)) {
+      errors.push(`${replicaLabel}.health must be healthy or none`);
+    }
+    if (!replicaArg.imageRepoDigests.includes(`${repositoryReference}@${source.rootDigest}`)) {
+      errors.push(`${replicaLabel} image must be ${repositoryReference}@${source.rootDigest}`);
+    }
+    if (replicaArg.imageStore === 'containerd') {
+      if (replicaArg.containerImageId !== source.rootDigest) {
+        errors.push(`${replicaLabel}.containerImageId must be the root digest on the containerd image store`);
+      }
+      return;
+    }
+    if (!imageConfigDigests.includes(replicaArg.containerImageId)) {
+      errors.push(`${replicaLabel}.containerImageId must be a platform image configuration digest of the root on the classic image store`);
+    }
+    if (selectReplicaRootDigest(replicaArg, repositoryReference) === undefined) {
+      errors.push(`${replicaLabel} image must list exactly one digest of ${repositoryReference} on the classic image store`);
+    }
+  });
+  return errors;
+};
+
 const validatePlatformManifest = (
   manifestArg: unknown,
   indexArg: number,
@@ -270,17 +636,54 @@ const validateImageSource = (sourceArg: unknown): string[] => {
   return errors;
 };
 
-const validateRuntime = (runtimeArg: unknown, rootDigestArg: unknown): string[] => {
+const isLegacyServiceImageSource = (valueArg: unknown): valueArg is ILegacyServiceImageSource => (
+  validateImageSource(valueArg).length === 0
+);
+
+const validateRuntime = (runtimeArg: unknown, sourceArg: unknown): string[] => {
   if (!isPlainRecord(runtimeArg)) return ['runtime must be an object'];
+  const rootDigest = isPlainRecord(sourceArg) ? sourceArg.rootDigest : undefined;
   const errors: string[] = [];
   if (!hasExactKeys(runtimeArg, [
     'requiredReplicaCount',
     'healthyReplicaCount',
     'runtimeDigest',
     'tasks',
+    'evidenceSource',
+    'hostObservation',
   ])) {
     errors.push('runtime must use its exact schema');
   }
+  if (runtimeArg.evidenceSource !== 'administrator-host-observation') {
+    errors.push('runtime.evidenceSource must be administrator-host-observation');
+  }
+  const hostObservation = runtimeArg.hostObservation;
+  const observationErrors = validateLegacyServiceHostObservation(
+    hostObservation, 'runtime.hostObservation');
+  errors.push(...observationErrors);
+  if (observationErrors.length === 0
+    && isLegacyServiceHostObservation(hostObservation)
+    && isLegacyServiceImageSource(sourceArg)) {
+    errors.push(...judgeLegacyServiceHostObservation({
+      observation: hostObservation,
+      source: sourceArg,
+      label: 'runtime.hostObservation',
+    }));
+    if (hostObservation.mode.kind === 'replicated'
+      && runtimeArg.requiredReplicaCount !== hostObservation.mode.desiredReplicas) {
+      errors.push('runtime.requiredReplicaCount must be the observed desired replicas');
+    }
+    const recordedTasks = readDataElements(runtimeArg.tasks, maximumReplicaCount) ?? [];
+    if (recordedTasks.length !== hostObservation.replicas.length
+      || hostObservation.replicas.some((replicaArg, indexArg) => {
+        const task = recordedTasks[indexArg];
+        return !isPlainRecord(task)
+          || task.deploymentId !== replicaArg.swarmTaskId
+          || task.nodeName !== replicaArg.nodeHostname;
+      })) {
+      errors.push('runtime.tasks must be the observed replicas: each Swarm task on its node');
+    }
+  }
   if (!isPositiveSafeInteger(runtimeArg.requiredReplicaCount, maximumReplicaCount)) {
     errors.push('runtime.requiredReplicaCount must be a positive bounded replica count');
   }
@@ -289,7 +692,7 @@ const validateRuntime = (runtimeArg: unknown, rootDigestArg: unknown): string[]
   }
   if (!isCanonicalDigest(runtimeArg.runtimeDigest)) {
     errors.push('runtime.runtimeDigest must be a canonical sha256 digest');
-  } else if (runtimeArg.runtimeDigest !== rootDigestArg) {
+  } else if (runtimeArg.runtimeDigest !== rootDigest) {
     errors.push('runtime.runtimeDigest must be the attested source root digest');
   }
   if (!Array.isArray(runtimeArg.tasks) || runtimeArg.tasks.length !== runtimeArg.requiredReplicaCount) {
@@ -363,9 +766,6 @@ export const validateLegacyServiceRuntimeAttestation = (attestationArg: unknown)
     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,
-  ));
+  errors.push(...validateRuntime(data.runtime, data.source));
   return errors;
 };

package/ts/requests/service.ts

@@ -17,7 +17,10 @@ import type {
   IServiceDeploymentStatus,
 } from '../data/deploymentoperation.js';
 import type { TSha256Digest } from '../data/immutableimage.js';
-import type { ILegacyServiceRuntimeAttestation } from '../data/deploymentlegacyimport.js';
+import type {
+  ILegacyServiceHostObservation,
+  ILegacyServiceRuntimeAttestation,
+} from '../data/deploymentlegacyimport.js';
 import type { IProtocolOffer } from '../protocol.js';
 import type {
   IRuntimeAssignmentLogAttemptPage,
@@ -330,10 +333,13 @@ extends plugins.typedrequestInterfaces.implementsTR<
 }
 
 /**
- * Captures durable evidence that a legacy `deployOnPush` service runs exactly the registry root its
- * tag names: every required replica observed healthy on that one digest, with the root's platform
- * manifests read from Cloudly's own registry. Administrators only, and only while the legacy
- * runtime still runs — incomplete evidence is refused, never stored.
+ * Captures durable evidence that a legacy `deployOnPush` service runs exactly one registry root of
+ * its own repository, from an administrator's observation of its Swarm service and containers on
+ * the hosts that run them (`hostObservation`). Cloudly judges the observation itself
+ * (`data.judgeLegacyServiceHostObservation`): every desired replica running, healthy or without a
+ * healthcheck, on one root that is whole in Cloudly's own registry, its platform manifests read
+ * from there. The source tag need not still name that root. Administrators only, and only while
+ * the legacy runtime still runs — incomplete evidence is refused, never stored.
  *
  * `expectedRuntimeDigest`, when stated, is an assertion the observed digest must equal. Capturing
  * again for an unchanged digest returns the attestation already stored.
@@ -348,6 +354,7 @@ extends plugins.typedrequestInterfaces.implementsTR<
     identity: IIdentityCredential;
     legacyServiceId: string;
     expectedRuntimeDigest?: TSha256Digest;
+    hostObservation: ILegacyServiceHostObservation;
   };
   response: {
     attestation: ILegacyServiceRuntimeAttestation;