@serve.zone/interfaces 32.38.0 → 32.40.0

package/changelog.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 2026-10-02 - 32.40.0
+
+### Features
+
+- A failed runtime assignment observation may now state why the run failed. The optional
+  `IRuntimeAssignmentObservation.cause` (`TRuntimeAssignmentFailureCause`) is a closed, value-free
+  union: `image-pull-refused` with the node's `reason` (`runtimeImagePullRefusalReasons`) and the
+  runtime's gRPC status code (1..16), `exited` with the exit status (0..255, or null),
+  `runtime-absent` and `network-epoch-ended`. It is admitted only with phase `failed`, an image-pull
+  refusal names no runtime identity, and the snapshot still rejects every unknown field. A causeless
+  observation keeps its canonical bytes and digest. `IServiceRuntimeAssignmentView.observation`
+  carries the cause for administrators. Consumers on 32.39.0 or older reject an observation
+  that states a cause, so a node states one only once its controller reads 32.40.0.
+
+## 2026-10-02 - 32.39.0
+
+### Maintenance
+
+- Update release tooling to tsbuild 5.1.0 and tsdoc 3.0.1 (Node.js types stay 26.6.2 and pnpm 12.6.0 until their seven-day release age).
+
+### Features
+
+- A node's managed VPN membership now outlives its network projection.
+  `continuesRuntimeManagedVpnMembership(previous, next)` states what a membership is: one
+  projection lineage under one protected authority and one handoff lease (its node scope and
+  router incarnation), at a later generation (the same generation only as the identical projection). Workload, readiness, egress, router
+  selection and DNS window changes keep it; a protection bump, a fresh handoff or a new controller
+  epoch ends it. `bindGetRuntimeManagedVpnCredentialSuccessor` binds the credential for a successor
+  projection: the same session, transport, hub, authority and key pair as the held credential,
+  with only `projection` and `expiresAt` moved and the expiry inside the successor's effective DNS
+  window, which must cover the caller's time. A controller keeps a member and its key pair across a
+  projection change with it, so the node's hub session survives a workload change.
+
 ## 2026-09-30 - 32.38.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/networkcredential.d.ts

@@ -7,7 +7,12 @@ export interface IGetRuntimeManagedVpnCredentialRequest {
 }
 /** Secret response over the current authenticated physical peer only. Never
  * persist, hash, log, or include it in a signed network projection. The native
- * Noise owner validates and uses the keys; these shapes confer no TUN readiness. */
+ * Noise owner validates and uses the keys; these shapes confer no TUN readiness.
+ *
+ * One response names one exact projection, but its key pair belongs to the node's managed VPN
+ * membership, which outlives a projection: a credential for a successor projection of the same
+ * membership (`continuesRuntimeManagedVpnMembership`) carries the same transport, hub, authority and
+ * keys, bound by `bindGetRuntimeManagedVpnCredentialSuccessor`. */
 export interface IGetRuntimeManagedVpnCredentialResponse extends IGetRuntimeManagedVpnCredentialRequest {
     transport: TRuntimeNetworkVpnTransport;
     /** The cluster hub endpoint this node dials, named by the id its signed projection selected. */
@@ -32,6 +37,24 @@ export declare const snapshotGetRuntimeManagedVpnCredentialResponse: (value: unk
 /** Content binding only. The caller must resolve the exact current projection
  * and authenticate/fence the current physical peer before and after native work. */
 export declare const bindGetRuntimeManagedVpnCredentialRequest: (value: unknown, projectionValue: unknown, trustedSessionValue: unknown) => Promise<IGetRuntimeManagedVpnCredentialRequest>;
+/**
+ * Whether `next` continues the managed VPN membership `previous` belongs to: the same projection
+ * lineage (`id`), the same protected authority, and the same handoff lease, which names the node
+ * scope and carries the node's router incarnation. Both must hold a handoff, because a node without
+ * one is no member. `next` is `previous` itself or a later generation; an earlier one, or another
+ * projection under the same generation, continues nothing.
+ *
+ * Everything else a projection states may move under one membership: its workload endpoints, their
+ * readiness, observations and egress, its private networks, its router selection and its DNS window.
+ * Those are what the member's network carries, never who the member is. A protection bump, a fresh
+ * handoff (router reincarnation) or a new controller epoch ends the membership. Whether the hub a
+ * credential names is still selected is the credential's question
+ * (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
+ *
+ * Validates both complete projections and rejects either that does not validate; a valid pair that
+ * is not one membership answers `false`. It samples no clock and fences no session.
+ */
+export declare const continuesRuntimeManagedVpnMembership: (previousValue: unknown, nextValue: unknown) => Promise<boolean>;
 /** Bind the secret response to the original request and the exact selected router
  * endpoint of the credential's transport, inside the projection's effective DNS window. renewalValue is the
  * bare lease renewal the caller already verified and admitted for this exact
@@ -39,3 +62,22 @@ export declare const bindGetRuntimeManagedVpnCredentialRequest: (value: unknown,
  * this helper does not sample a clock, authenticate a transport, admit policy or
  * prove a running managed connection. */
 export declare const bindGetRuntimeManagedVpnCredentialResponse: (value: unknown, requestValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown, renewalValue?: unknown | null) => Promise<IGetRuntimeManagedVpnCredentialResponse>;
+/**
+ * Bind the credential a node holds under its successor projection: `value` names `projectionValue`
+ * and is bound exactly as `bindGetRuntimeManagedVpnCredentialResponse` binds the answer to
+ * `{ session: trustedSession, projection }`, inside that projection's effective DNS window
+ * (`renewalValue`, as there). It must also continue `previousValue`, the credential issued for
+ * `previousProjectionValue` over the same session: the two projections are one membership
+ * (`continuesRuntimeManagedVpnMembership`) and the transport, hub, authority, server key and client
+ * key pair are unchanged. Only `projection` and `expiresAt` move. The current effective window
+ * alone bounds the successor, so a membership whose current window does not cover the
+ * caller-qualified `nowValue` binds no successor; the held credential's own expiry is not
+ * consulted, because a renewal or a successor may have moved the window past it.
+ *
+ * The issuer binds the successor it states for a member, so the node's session and key pair survive
+ * a workload, readiness or policy change; the node binds a fresh answer with it to tell a successor,
+ * which keeps its live session, from a new membership, which replaces it. A previous credential for
+ * the same projection binds too, which is how a renewal moves the expiry. Content binding only, as
+ * for the response binder.
+ */
+export declare const bindGetRuntimeManagedVpnCredentialSuccessor: (value: unknown, previousValue: unknown, previousProjectionValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown, renewalValue?: unknown | null) => Promise<IGetRuntimeManagedVpnCredentialResponse>;

package/dist_ts/data/networkcredential.js

@@ -1,6 +1,6 @@
 import { runtimeNetworkAddressPlanContract } from './networkaddressplan.js';
 import { snapshotRuntimeSessionBinding } from './runtimesession.js';
-import { validateRuntimeNetworkProjection } from './networkprojection.js';
+import { snapshotRuntimeNetworkProjection, validateRuntimeNetworkProjection } from './networkprojection.js';
 import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
 import { captureNetwork, failNetwork, networkAuthorityId, networkCounter, networkEffectiveDnsWindow, networkEqual, networkId, networkIpv4, networkNoiseKey, networkRecord, networkReference, networkReferenceOf, networkSafe, networkSameScope, requireNetwork } from '../private/networkcontract.js';
 export const snapshotGetRuntimeManagedVpnCredentialRequest = (value) => networkSafe(() => {
@@ -41,6 +41,62 @@ export const bindGetRuntimeManagedVpnCredentialRequest = async (value, projectio
         return failNetwork();
     }
 };
+/**
+ * The membership rule of `continuesRuntimeManagedVpnMembership`, over projections already validated.
+ * A valid projection's handoff lease names the projection's own node scope, so one handoff
+ * reference is one node scope and the scope needs no comparison of its own.
+ */
+const continuesMembership = (previous, next) => previous.handoff !== null && next.handoff !== null && previous.id === next.id
+    && networkEqual(networkReferenceOf(previous.protectedAuthority), networkReferenceOf(next.protectedAuthority))
+    && networkEqual(networkReferenceOf(previous.handoff), networkReferenceOf(next.handoff))
+    && (next.generation > previous.generation || networkEqual(networkReferenceOf(previous), networkReferenceOf(next)));
+/** What a membership's credential keeps across its projections: everything but the projection and the expiry. */
+const credentialIdentity = (value) => ({
+    transport: value.transport, hub: value.hub, authorityId: value.authorityId, serverPublicKey: value.serverPublicKey,
+    clientPublicKey: value.clientPublicKey, clientPrivateKey: value.clientPrivateKey,
+});
+/**
+ * Whether `next` continues the managed VPN membership `previous` belongs to: the same projection
+ * lineage (`id`), the same protected authority, and the same handoff lease, which names the node
+ * scope and carries the node's router incarnation. Both must hold a handoff, because a node without
+ * one is no member. `next` is `previous` itself or a later generation; an earlier one, or another
+ * projection under the same generation, continues nothing.
+ *
+ * Everything else a projection states may move under one membership: its workload endpoints, their
+ * readiness, observations and egress, its private networks, its router selection and its DNS window.
+ * Those are what the member's network carries, never who the member is. A protection bump, a fresh
+ * handoff (router reincarnation) or a new controller epoch ends the membership. Whether the hub a
+ * credential names is still selected is the credential's question
+ * (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
+ *
+ * Validates both complete projections and rejects either that does not validate; a valid pair that
+ * is not one membership answers `false`. It samples no clock and fences no session.
+ */
+export const continuesRuntimeManagedVpnMembership = async (previousValue, nextValue) => {
+    let previous, next;
+    try {
+        const previousInput = snapshotRuntimeNetworkProjection(previousValue), nextInput = snapshotRuntimeNetworkProjection(nextValue);
+        previous = await validateRuntimeNetworkProjection(previousInput);
+        next = await validateRuntimeNetworkProjection(nextInput);
+    }
+    catch {
+        return failNetwork();
+    }
+    return continuesMembership(previous, next);
+};
+/** The response binding over inputs already captured and validated. */
+const bindResponse = (response, request, projection, renewal, trusted, now) => {
+    const window = networkEffectiveDnsWindow(projection, renewal);
+    bindRequest(request, projection, trusted);
+    requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
+    requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
+    const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
+    const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
+    requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
+        && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
+    requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
+    return response;
+};
 /** Bind the secret response to the original request and the exact selected router
  * endpoint of the credential's transport, inside the projection's effective DNS window. renewalValue is the
  * bare lease renewal the caller already verified and admitted for this exact
@@ -55,19 +111,49 @@ export const bindGetRuntimeManagedVpnCredentialResponse = async (value, requestV
         const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
         const projection = await validateRuntimeNetworkProjection(projectionValue);
         const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
-        const window = networkEffectiveDnsWindow(projection, renewal);
-        bindRequest(request, projection, trusted);
-        requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
-        requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
-        const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
-        const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
-        requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
-            && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
-        requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
-        return response;
+        return bindResponse(response, request, projection, renewal, trusted, now);
+    }
+    catch {
+        return failNetwork();
+    }
+};
+/**
+ * Bind the credential a node holds under its successor projection: `value` names `projectionValue`
+ * and is bound exactly as `bindGetRuntimeManagedVpnCredentialResponse` binds the answer to
+ * `{ session: trustedSession, projection }`, inside that projection's effective DNS window
+ * (`renewalValue`, as there). It must also continue `previousValue`, the credential issued for
+ * `previousProjectionValue` over the same session: the two projections are one membership
+ * (`continuesRuntimeManagedVpnMembership`) and the transport, hub, authority, server key and client
+ * key pair are unchanged. Only `projection` and `expiresAt` move. The current effective window
+ * alone bounds the successor, so a membership whose current window does not cover the
+ * caller-qualified `nowValue` binds no successor; the held credential's own expiry is not
+ * consulted, because a renewal or a successor may have moved the window past it.
+ *
+ * The issuer binds the successor it states for a member, so the node's session and key pair survive
+ * a workload, readiness or policy change; the node binds a fresh answer with it to tell a successor,
+ * which keeps its live session, from a new membership, which replaces it. A previous credential for
+ * the same projection binds too, which is how a renewal moves the expiry. Content binding only, as
+ * for the response binder.
+ */
+export const bindGetRuntimeManagedVpnCredentialSuccessor = async (value, previousValue, previousProjectionValue, projectionValue, trustedSessionValue, nowValue, renewalValue = null) => {
+    try {
+        const response = snapshotGetRuntimeManagedVpnCredentialResponse(value);
+        const previous = snapshotGetRuntimeManagedVpnCredentialResponse(previousValue);
+        const previousInput = snapshotRuntimeNetworkProjection(previousProjectionValue);
+        const projectionInput = snapshotRuntimeNetworkProjection(projectionValue);
+        const trusted = snapshotRuntimeSessionBinding(trustedSessionValue), now = networkCounter(nowValue);
+        const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
+        const previousProjection = await validateRuntimeNetworkProjection(previousInput);
+        const projection = await validateRuntimeNetworkProjection(projectionInput);
+        const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
+        requireNetwork(continuesMembership(previousProjection, projection));
+        requireNetwork(networkEqual(previous.session, trusted)
+            && networkEqual(previous.projection, networkReferenceOf(previousProjection)));
+        requireNetwork(networkEqual(credentialIdentity(previous), credentialIdentity(response)));
+        return bindResponse(response, { session: trusted, projection: networkReferenceOf(projection) }, projection, renewal, trusted, now);
     }
     catch {
         return failNetwork();
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcredential.js","sourceRoot":"","sources":["../../ts/data/networkcredential.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/runtimeassignment.d.ts

@@ -102,6 +102,41 @@ export type TRuntimeAssignmentDecision = {
     status: 'reject';
     reason: 'invalid' | 'scope-mismatch' | 'conflict' | 'stale' | 'predecessor-mismatch' | 'attempt-mismatch' | 'disposition-regression';
 };
+/**
+ * Why the runtime refused an image pull, as the node classifies the runtime's status: `other` is a
+ * status none of the named reasons matched.
+ */
+export declare const runtimeImagePullRefusalReasons: readonly ["unauthorized", "not-found", "tls", "transport", "deadline", "unavailable", "other"];
+export type TRuntimeImagePullRefusalReason = typeof runtimeImagePullRefusalReasons[number];
+/**
+ * Why a run failed, as its node can name it. Value-free: it carries a cause word and at most a
+ * bounded status number, never a runtime message, a registry, a reference or a path.
+ *
+ * - `image-pull-refused`: the runtime refused the pull before any sandbox or container of the run
+ *   existed, so the observation carries no runtime identity. `grpcCode` is the runtime's gRPC
+ *   status code (1..16) and `reason` the node's classification of it.
+ * - `exited`: the run's container ended on its own. `exitCode` is its exit status (0..255), or null
+ *   when the runtime stated none or one outside that range.
+ * - `runtime-absent`: the runtime holds no sandbox or container of a run that should be running.
+ * - `network-epoch-ended`: the run's network attachment belongs to a network epoch that has ended,
+ *   so the node stopped it rather than leave it running without its network.
+ *
+ * The cause explains the failure; it changes nothing about it. Every failed run is replaced the same
+ * way, whichever cause it states.
+ */
+export type TRuntimeAssignmentFailureCause = {
+    kind: 'image-pull-refused';
+    reason: TRuntimeImagePullRefusalReason;
+    grpcCode: number;
+} | {
+    kind: 'exited';
+    exitCode: number | null;
+} | {
+    kind: 'runtime-absent';
+} | {
+    kind: 'network-epoch-ended';
+};
+export declare const runtimeAssignmentFailureCauseKinds: readonly ["image-pull-refused", "exited", "runtime-absent", "network-epoch-ended"];
 /** Value-free execution evidence. Receipt/acceptance alone never means ready. */
 export interface IRuntimeAssignmentObservation {
     assignment: IRuntimeAssignmentReference;
@@ -117,6 +152,11 @@ export interface IRuntimeAssignmentObservation {
         containerId: string;
         imageDigest: TSha256Digest;
     } | null;
+    /**
+     * Why the run failed, stated only with phase `failed` and only when the node can name it. Absent,
+     * a failed observation keeps the canonical bytes and digest it had before causes existed.
+     */
+    cause?: TRuntimeAssignmentFailureCause;
     digest: TSha256Digest;
 }
 export declare const runtimeAssignmentContract: Readonly<{

package/dist_ts/data/runtimeassignment.js

@@ -53,6 +53,14 @@ export const buildRuntimeAssignmentImageReference = (workloadArg) => {
 };
 /** True when a value is exactly a canonical authority list drawn from the authority vocabulary. */
 export const isResolvedWorkloadAuthorities = (valueArg) => isCanonicalTokenList(valueArg, runtimeWorkloadAuthorities);
+/**
+ * Why the runtime refused an image pull, as the node classifies the runtime's status: `other` is a
+ * status none of the named reasons matched.
+ */
+export const runtimeImagePullRefusalReasons = ['unauthorized', 'not-found', 'tls', 'transport', 'deadline',
+    'unavailable', 'other'];
+export const runtimeAssignmentFailureCauseKinds = ['image-pull-refused', 'exited', 'runtime-absent',
+    'network-epoch-ended'];
 export const runtimeAssignmentContract = Object.freeze({
     assignmentDigestDomain: 'serve.zone/runtime-assignment',
     observationDigestDomain: 'serve.zone/runtime-assignment-observation',
@@ -277,9 +285,29 @@ export const evaluateRuntimeAssignment = async (incomingArg, acceptedArg, truste
     }
     return { status: 'accept', assignment: incomingArg };
 };
+const isBoundedInteger = (valueArg, minimumArg, maximumArg) => typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg >= minimumArg && valueArg <= maximumArg;
+/** Whether a stated failure cause has exactly the shape of its kind. */
+const isFailureCause = (valueArg) => {
+    if (!isExactRecord(valueArg, ['kind'], ['reason', 'grpcCode', 'exitCode']))
+        return false;
+    switch (valueArg.kind) {
+        case 'image-pull-refused':
+            return isExactRecord(valueArg, ['kind', 'reason', 'grpcCode'])
+                && runtimeImagePullRefusalReasons.some((reasonArg) => reasonArg === valueArg.reason)
+                && isBoundedInteger(valueArg.grpcCode, 1, 16);
+        case 'exited':
+            return isExactRecord(valueArg, ['kind', 'exitCode'])
+                && (valueArg.exitCode === null || isBoundedInteger(valueArg.exitCode, 0, 255));
+        case 'runtime-absent':
+        case 'network-epoch-ended':
+            return isExactRecord(valueArg, ['kind']);
+        default:
+            return false;
+    }
+};
 const assertObservation = (valueArg) => {
     if (!isExactRecord(valueArg, ['assignment', 'reporterSessionId',
-        'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'])
+        'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'], ['cause'])
         || !isAssignmentReference(valueArg.assignment)
         || !isIdentifier(valueArg.reporterSessionId) || !isPositiveInteger(valueArg.sequence)
         || !isPositiveInteger(valueArg.observedAt) || !isDigest(valueArg.digest)
@@ -297,6 +325,10 @@ const assertObservation = (valueArg) => {
         || (valueArg.phase === 'removed' && valueArg.runtime !== null)) {
         fail('runtime observation readiness and identity contradict its phase');
     }
+    if (Object.hasOwn(valueArg, 'cause') && (valueArg.phase !== 'failed' || !isFailureCause(valueArg.cause)
+        || (valueArg.cause.kind === 'image-pull-refused' && valueArg.runtime !== null))) {
+        fail('runtime observation failure cause must be exact and belong to a failed run');
+    }
     canonical(valueArg);
     return valueArg;
 };
@@ -370,4 +402,4 @@ export const evaluateRuntimeAssignmentObservation = async (incomingArg, accepted
         return { status: 'reject', reason: 'invalid' };
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignment.js","sourceRoot":"","sources":["../../ts/data/runtimeassignment.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignment.js","sourceRoot":"","sources":["../../ts/data/runtimeassignment.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/serviceruntime.d.ts

@@ -172,8 +172,11 @@ export interface IServiceRuntimeAssignmentView {
     /** The current revision; its generation is the one the disposition belongs to. */
     assignment: IRuntimeAssignmentReference;
     disposition: TRuntimeAssignmentDisposition;
-    /** The latest accepted observation of this attempt, which may cite an earlier revision. */
-    observation: Pick<IRuntimeAssignmentObservation, 'phase' | 'ready' | 'observedAt' | 'sequence'> | null;
+    /**
+     * The latest accepted observation of this attempt, which may cite an earlier revision. A failed
+     * one carries the node's failure cause when the node stated one.
+     */
+    observation: Pick<IRuntimeAssignmentObservation, 'phase' | 'ready' | 'observedAt' | 'sequence' | 'cause'> | null;
     /** Joined stop and remove receipts of this attempt. */
     terminalReceiptCount: 0 | 1 | 2;
     delivery: TServiceRuntimeAssignmentDelivery;

package/dist_ts/data/serviceruntime.js

@@ -102,4 +102,4 @@ export const snapshotServiceRuntimeStatus = (value) => producerSafe(() => {
     requireNetwork(item.state === 'refused' && isOneOf(serviceRuntimeRefusals, item.reason));
     return { ...base, state: item.state, reason: item.reason };
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZXJ1bnRpbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL3NlcnZpY2VydW50aW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxjQUFjLEVBQUUsZ0JBQWdCLEVBQUUsY0FBYyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsYUFBYSxFQUFFLGFBQWEsRUFBRSxhQUFhLEVBQzVILGNBQWMsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNoRyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsa0JBQWtCLEVBQUUsdUJBQXVCLEVBQUUsa0JBQWtCLEVBQ2hILG9CQUFvQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUF5RDVELE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDbEQsc0JBQXNCLEVBQUUsRUFBRTtJQUMxQiwrRkFBK0Y7SUFDL0YsZUFBZSxFQUFFLEVBQUU7SUFDbkIsb0hBQW9IO0lBQ3BILGtCQUFrQixFQUFFLCtCQUErQixDQUFDLHdCQUF3QjtJQUM1RSx3QkFBd0IsRUFBRSwrQkFBK0IsQ0FBQyx3QkFBd0I7SUFDbEYsMEZBQTBGO0lBQzFGLG1CQUFtQixFQUFFLEdBQUc7SUFDeEIsZ0dBQWdHO0lBQ2hHLHlCQUF5QixFQUFFLEdBQUc7Q0FDdEIsQ0FBQyxDQUFDO0FBRVosTUFBTSw0QkFBNEIsR0FBRztJQUNuQyxzQkFBc0IsRUFBRSxVQUFVLEVBQUUsaUJBQWlCLEVBQUUsd0JBQXdCLEVBQUUsa0JBQWtCO0lBQ25HLHlCQUF5QixFQUFFLGlDQUFpQztDQUNwRCxDQUFDO0FBQ1gsTUFBTSxzQkFBc0IsR0FBRztJQUM3Qix5QkFBeUIsRUFBRSxzQkFBc0IsRUFBRSxvQkFBb0IsRUFBRSxzQkFBc0I7SUFDL0YscUJBQXFCLEVBQUUscUJBQXFCLEVBQUUsMkJBQTJCLEVBQUUsZ0JBQWdCO0lBQzNGLDZCQUE2QixFQUFFLHVCQUF1QixFQUFFLGtCQUFrQixFQUFFLGVBQWU7SUFDM0YsNEJBQTRCLEVBQUUsd0JBQXdCLEVBQUUseUJBQXlCO0lBQ2pGLCtCQUErQixFQUFFLGlDQUFpQztJQUNsRSwyQkFBMkIsRUFBRSw0QkFBNEIsRUFBRSwyQkFBMkI7SUFDdEYsOEJBQThCLEVBQUUsK0JBQStCLEVBQUUsMEJBQTBCO0lBQzNGLGdDQUFnQyxFQUFFLCtCQUErQixFQUFFLG9DQUFvQztJQUN2RyxtQ0FBbUMsRUFBRSwyQkFBMkIsRUFBRSw4QkFBOEI7SUFDaEcseUJBQXlCLEVBQUUseUNBQXlDO0NBQzVELENBQUM7QUE4R1gsMkdBQTJHO0FBQzNHLE1BQU0sU0FBUyxHQUFHLENBQUMsS0FBYyxFQUFFLE9BQWUsRUFBRSxJQUErQixFQUFZLEVBQUUsQ0FDL0YsYUFBYSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7QUFFN0QsTUFBTSxXQUFXLEdBQUcsQ0FBQyxLQUFjLEVBQTRCLEVBQUU7SUFDL0QsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztJQUN0QyxJQUFJLElBQUksS0FBSyxZQUFZLEVBQUUsQ0FBQztRQUMxQixhQUFhLENBQUMsS0FBSyxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUMvQixPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDbEIsQ0FBQztJQUNELGNBQWMsQ0FBQyxJQUFJLEtBQUssT0FBTyxDQUFDLENBQUM7SUFDakMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDLGFBQWEsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxNQUFNLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsc0JBQXNCLENBQUMsa0JBQWtCLEVBQUUsYUFBYSxDQUFDLENBQUM7SUFDdkksY0FBYyxDQUFDLE9BQU8sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDbkMsT0FBTyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUMzQixDQUFDLENBQUM7QUFFRixNQUFNLE9BQU8sR0FBRyxDQUFDLEtBQWMsRUFBbUMsRUFBRTtJQUNsRSxJQUFJLEtBQUssS0FBSyxJQUFJO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDaEMsTUFBTSxJQUFJLEdBQUcsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ3JELGNBQWMsQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksdUJBQXVCLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDMUYsT0FBTyxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDaEQsQ0FBQyxDQUFDO0FBRUYsTUFBTSxTQUFTLEdBQUcsQ0FBQyxLQUFjLEVBQTBCLEVBQUU7SUFDM0QsTUFBTSxJQUFJLEdBQUcsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDLFdBQVcsRUFBRSxhQUFhLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ2hILGNBQWMsQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksb0JBQW9CLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQztXQUN0RixrQkFBa0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksT0FBTyxJQUFJLENBQUMsY0FBYyxLQUFLLFNBQVMsQ0FBQyxDQUFDO0lBQ2hGLDRHQUE0RztJQUM1RyxzQkFBc0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksRUFBRSxZQUFZLENBQUMsQ0FBQztJQUNqRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsb0JBQW9CLEVBQUUsV0FBVyxFQUFFLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQztJQUMxRSxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXO1FBQy9ELFNBQVMsRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBNEI7UUFDbEYsSUFBSSxFQUFFLEVBQUUsZ0JBQWdCLEVBQUUsb0JBQW9CLEVBQUUsV0FBVyxFQUFFLEVBQUUsY0FBYyxFQUFFLElBQUksQ0FBQyxjQUFjLEVBQUUsS0FBSyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztBQUNySSxDQUFDLENBQUM7QUFFRixNQUFNLFNBQVMsR0FBRyxDQUFDLEtBQWMsRUFBMEIsRUFBRTtJQUMzRCxNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3RDLElBQUksSUFBSSxLQUFLLFVBQVUsRUFBRSxDQUFDO1FBQ3hCLGFBQWEsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQy9CLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNsQixDQUFDO0lBQ0QsY0FBYyxDQUFDLElBQUksS0FBSyxVQUFVLENBQUMsQ0FBQztJQUNwQyxNQUFNLElBQUksR0FBRyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUMsTUFBTSxFQUFFLGNBQWMsRUFBRSxxQkFBcUIsQ0FBQyxDQUFDLENBQUM7SUFDbkYsY0FBYyxDQUFDLE9BQU8sSUFBSSxDQUFDLFlBQVksS0FBSyxTQUFTLENBQUMsQ0FBQztJQUN2RCxPQUFPLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxJQUFJLENBQUMsWUFBWTtRQUM1QyxtQkFBbUIsRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLG1CQUFtQixFQUFFLHNCQUFzQixDQUFDLHdCQUF3QixFQUFFLFNBQVMsQ0FBQyxFQUFFLENBQUM7QUFDM0gsQ0FBQyxDQUFDO0FBRUY7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsQ0FBQyxLQUFjLEVBQXVCLEVBQUUsQ0FBQyxZQUFZLENBQUMsR0FBRyxFQUFFO0lBQ25HLE1BQU0sSUFBSSxHQUFHLGFBQWEsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsV0FBVyxFQUFFLFdBQVc7UUFDakcsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztJQUNoRSxjQUFjLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDLEVBQUUsc0JBQXNCLENBQUMsc0JBQXNCLENBQUM7V0FDbEcsT0FBTyxJQUFJLENBQUMsSUFBSSxLQUFLLFNBQVMsQ0FBQyxDQUFDO0lBQ3JDLE9BQU8sRUFBRSxFQUFFLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxjQUFjLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsRUFBRSxTQUFTLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUM7UUFDbkgsU0FBUyxFQUFFLFdBQVcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsZUFBZSxFQUFFLElBQUksQ0FBQyxlQUFlLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1FBQzlGLE9BQU8sRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLFFBQVEsRUFBRSxjQUFjLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7QUFDbEgsQ0FBQyxDQUFDLENBQUM7QUFFSCx3RkFBd0Y7QUFDeEYsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQUcsQ0FBQyxLQUFjLEVBQXlCLEVBQUUsQ0FBQyxZQUFZLENBQUMsR0FBRyxFQUFFO0lBQ3ZHLE1BQU0sSUFBSSxHQUFHLGFBQWEsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsY0FBYyxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUMxRyxNQUFNLElBQUksR0FBOEIsRUFBRSxFQUFFLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxZQUFZLEVBQUUsY0FBYyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUM7UUFDL0csU0FBUyxFQUFFLGNBQWMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQztJQUM5QyxJQUFJLElBQUksQ0FBQyxLQUFLLEtBQUssV0FBVyxJQUFJLElBQUksQ0FBQyxLQUFLLEtBQUssWUFBWSxFQUFFLENBQUM7UUFDOUQsY0FBYyxDQUFDLElBQUksQ0FBQyxNQUFNLEtBQUssSUFBSSxDQUFDLENBQUM7UUFDckMsT0FBTyxFQUFFLEdBQUcsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUN0RCxDQUFDO0lBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQzdCLGNBQWMsQ0FBQyxPQUFPLENBQUMsNEJBQTRCLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFDbkUsT0FBTyxFQUFFLEdBQUcsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDN0QsQ0FBQztJQUNELGNBQWMsQ0FBQyxJQUFJLENBQUMsS0FBSyxLQUFLLFNBQVMsSUFBSSxPQUFPLENBQUMsc0JBQXNCLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFDekYsT0FBTyxFQUFFLEdBQUcsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7QUFDN0QsQ0FBQyxDQUFDLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.38.0",
+  "version": "32.40.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -27,8 +27,8 @@
     "@tsclass/tsclass": "^9.5.1"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^5.0.0",
-    "@git.zone/tsdoc": "^2.2.2",
+    "@git.zone/tsbuild": "^5.1.0",
+    "@git.zone/tsdoc": "^3.0.1",
     "@git.zone/tsrun": "^3.0.2",
     "@git.zone/tstest": "6.3.2",
     "@types/node": "26.6.2"

package/readme.md

@@ -728,6 +728,32 @@ Expiry must be after the caller-qualified time and no later than the referenced
 projection's effective DNS window (see [DNS Lease Renewals](#dns-lease-renewals));
 acceptance before that window starts rejects.
 
+A credential names one projection, but its key pair belongs to the node's managed VPN
+membership, which outlives it. Every workload add, removal, readiness change or policy change
+signs a new projection generation; none of them changes who the member is.
+`continuesRuntimeManagedVpnMembership(previous, next)` is that rule: `next` continues the
+membership when it is the same projection lineage (`id`) under the same protected authority and
+the same handoff lease (which names the node scope and carries the router incarnation), and is
+`previous` itself or a later generation. A protection bump, a fresh handoff (router
+reincarnation) or a new controller epoch is a new membership; an earlier generation or another
+projection of the same generation continues nothing. It validates both projections and rejects
+one that does not validate.
+
+`bindGetRuntimeManagedVpnCredentialSuccessor(response, previous, previousProjection, projection,
+trustedSession, now, renewal = null)` binds the credential for the successor. `response` is bound
+exactly as the response binder binds an answer to `{ session: trustedSession, projection }`, so
+the hub must still be selected and the expiry stays inside the successor's effective DNS window.
+It must also continue `previous`, the credential issued for `previousProjection` over the same
+session: the two projections are one membership and the transport, hub, authority, server key and
+client key pair are unchanged. Only `projection` and `expiresAt` move. The current effective
+window is the one limit: a membership whose current window does not cover `now` binds no
+successor, while the held credential's own expiry is not consulted, because a renewal or a
+successor may already have moved the window past it. The issuer binds the successor it states
+for a member with it, so the node keeps its key pair and its hub session across a projection
+change; a node binds a fresh answer with it to tell a successor, which keeps the live session,
+from a new membership, which replaces it. A previous credential for the same projection binds as
+its own successor, which is how a DNS lease renewal moves the expiry.
+
 These helpers perform content validation. Callers authenticate and fence the
 current physical peer and projection before and after native work, qualify time
 independently, and retain ownership through revocation and shutdown. The native
@@ -1034,6 +1060,29 @@ the receiving service. Readiness requires matching running image evidence and
 can describe drift (such as a removed runtime while intent remains `run`), and
 does not authorize storage relocation or prove fencing.
 
+A `failed` observation may state why the run failed in its optional `cause`
+(`TRuntimeAssignmentFailureCause`), a closed, value-free union keyed by `kind`
+(`runtimeAssignmentFailureCauseKinds`):
+
+- `image-pull-refused` with `reason` (`runtimeImagePullRefusalReasons`: `unauthorized`,
+  `not-found`, `tls`, `transport`, `deadline`, `unavailable`, `other`) and the runtime's
+  gRPC status `grpcCode` (1..16). Nothing of the run existed, so `runtime` is null;
+- `exited` with the container's `exitCode` (0..255), or null when the runtime stated none
+  or one outside that range;
+- `runtime-absent`: the runtime holds nothing of a run that should be running;
+- `network-epoch-ended`: the node stopped a run whose network attachment belongs to an
+  ended network epoch.
+
+The snapshot refuses a cause on any other phase, an unknown kind, a missing or extra
+field and an out-of-range number, so no runtime message, registry or path can travel in
+it. The cause is sealed content: a causeless observation keeps exactly the bytes and
+digest it had before causes existed, and the same sequence stated with another cause is
+a conflict. A cause explains a failure and changes nothing about it: a controller
+replaces every failed run the same way. `IServiceRuntimeAssignmentView.observation`
+carries the cause, so an administrator reads why an attempt failed. A consumer on
+interfaces 32.39.0 or older rejects an observation that states a cause, so a node states
+one only to a controller that reads this contract.
+
 ### Resolved Runtime Configuration
 
 `data.IRuntimeConfig` seals the public environment, working directory, resource

package/ts/00_commitinfo_data.ts

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

package/ts/data/networkcredential.ts

@@ -1,8 +1,10 @@
 import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
 import { runtimeNetworkAddressPlanContract, type TRuntimeNetworkVpnTransport } from './networkaddressplan.js';
 import { snapshotRuntimeSessionBinding, type IRuntimeSessionBinding } from './runtimesession.js';
-import { validateRuntimeNetworkProjection, type IRuntimeNetworkProjection } from './networkprojection.js';
-import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
+import { snapshotRuntimeNetworkProjection, validateRuntimeNetworkProjection,
+  type IRuntimeNetworkProjection } from './networkprojection.js';
+import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal,
+  type IRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
 import { captureNetwork, failNetwork, networkAuthorityId, networkCounter, networkEffectiveDnsWindow, networkEqual,
   networkId, networkIpv4, networkNoiseKey, networkRecord, networkReference, networkReferenceOf, networkSafe,
   networkSameScope, requireNetwork } from '../private/networkcontract.js';
@@ -14,7 +16,12 @@ export interface IGetRuntimeManagedVpnCredentialRequest {
 
 /** Secret response over the current authenticated physical peer only. Never
  * persist, hash, log, or include it in a signed network projection. The native
- * Noise owner validates and uses the keys; these shapes confer no TUN readiness. */
+ * Noise owner validates and uses the keys; these shapes confer no TUN readiness.
+ *
+ * One response names one exact projection, but its key pair belongs to the node's managed VPN
+ * membership, which outlives a projection: a credential for a successor projection of the same
+ * membership (`continuesRuntimeManagedVpnMembership`) carries the same transport, hub, authority and
+ * keys, bound by `bindGetRuntimeManagedVpnCredentialSuccessor`. */
 export interface IGetRuntimeManagedVpnCredentialResponse extends IGetRuntimeManagedVpnCredentialRequest {
   transport: TRuntimeNetworkVpnTransport;
   /** The cluster hub endpoint this node dials, named by the id its signed projection selected. */
@@ -72,6 +79,66 @@ export const bindGetRuntimeManagedVpnCredentialRequest = async (value: unknown,
   } catch { return failNetwork(); }
 };
 
+/**
+ * The membership rule of `continuesRuntimeManagedVpnMembership`, over projections already validated.
+ * A valid projection's handoff lease names the projection's own node scope, so one handoff
+ * reference is one node scope and the scope needs no comparison of its own.
+ */
+const continuesMembership = (previous: IRuntimeNetworkProjection, next: IRuntimeNetworkProjection): boolean =>
+  previous.handoff !== null && next.handoff !== null && previous.id === next.id
+  && networkEqual(networkReferenceOf(previous.protectedAuthority), networkReferenceOf(next.protectedAuthority))
+  && networkEqual(networkReferenceOf(previous.handoff), networkReferenceOf(next.handoff))
+  && (next.generation > previous.generation || networkEqual(networkReferenceOf(previous), networkReferenceOf(next)));
+
+/** What a membership's credential keeps across its projections: everything but the projection and the expiry. */
+const credentialIdentity = (value: IGetRuntimeManagedVpnCredentialResponse) => ({
+  transport: value.transport, hub: value.hub, authorityId: value.authorityId, serverPublicKey: value.serverPublicKey,
+  clientPublicKey: value.clientPublicKey, clientPrivateKey: value.clientPrivateKey,
+});
+
+/**
+ * Whether `next` continues the managed VPN membership `previous` belongs to: the same projection
+ * lineage (`id`), the same protected authority, and the same handoff lease, which names the node
+ * scope and carries the node's router incarnation. Both must hold a handoff, because a node without
+ * one is no member. `next` is `previous` itself or a later generation; an earlier one, or another
+ * projection under the same generation, continues nothing.
+ *
+ * Everything else a projection states may move under one membership: its workload endpoints, their
+ * readiness, observations and egress, its private networks, its router selection and its DNS window.
+ * Those are what the member's network carries, never who the member is. A protection bump, a fresh
+ * handoff (router reincarnation) or a new controller epoch ends the membership. Whether the hub a
+ * credential names is still selected is the credential's question
+ * (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
+ *
+ * Validates both complete projections and rejects either that does not validate; a valid pair that
+ * is not one membership answers `false`. It samples no clock and fences no session.
+ */
+export const continuesRuntimeManagedVpnMembership = async (previousValue: unknown, nextValue: unknown): Promise<boolean> => {
+  let previous: IRuntimeNetworkProjection, next: IRuntimeNetworkProjection;
+  try {
+    const previousInput = snapshotRuntimeNetworkProjection(previousValue), nextInput = snapshotRuntimeNetworkProjection(nextValue);
+    previous = await validateRuntimeNetworkProjection(previousInput);
+    next = await validateRuntimeNetworkProjection(nextInput);
+  } catch { return failNetwork(); }
+  return continuesMembership(previous, next);
+};
+
+/** The response binding over inputs already captured and validated. */
+const bindResponse = (response: IGetRuntimeManagedVpnCredentialResponse, request: IGetRuntimeManagedVpnCredentialRequest,
+  projection: IRuntimeNetworkProjection, renewal: IRuntimeNetworkDnsLeaseRenewal | null, trusted: IRuntimeSessionBinding,
+  now: number): IGetRuntimeManagedVpnCredentialResponse => {
+  const window = networkEffectiveDnsWindow(projection, renewal);
+  bindRequest(request, projection, trusted);
+  requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
+  requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
+  const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
+  const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
+  requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
+    && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
+  requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
+  return response;
+};
+
 /** Bind the secret response to the original request and the exact selected router
  * endpoint of the credential's transport, inside the projection's effective DNS window. renewalValue is the
  * bare lease renewal the caller already verified and admitted for this exact
@@ -88,15 +155,45 @@ export const bindGetRuntimeManagedVpnCredentialResponse = async (value: unknown,
     const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
     const projection = await validateRuntimeNetworkProjection(projectionValue);
     const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
-    const window = networkEffectiveDnsWindow(projection, renewal);
-    bindRequest(request, projection, trusted);
-    requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
-    requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
-    const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
-    const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
-    requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
-      && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
-    requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
-    return response;
+    return bindResponse(response, request, projection, renewal, trusted, now);
+  } catch { return failNetwork(); }
+};
+
+/**
+ * Bind the credential a node holds under its successor projection: `value` names `projectionValue`
+ * and is bound exactly as `bindGetRuntimeManagedVpnCredentialResponse` binds the answer to
+ * `{ session: trustedSession, projection }`, inside that projection's effective DNS window
+ * (`renewalValue`, as there). It must also continue `previousValue`, the credential issued for
+ * `previousProjectionValue` over the same session: the two projections are one membership
+ * (`continuesRuntimeManagedVpnMembership`) and the transport, hub, authority, server key and client
+ * key pair are unchanged. Only `projection` and `expiresAt` move. The current effective window
+ * alone bounds the successor, so a membership whose current window does not cover the
+ * caller-qualified `nowValue` binds no successor; the held credential's own expiry is not
+ * consulted, because a renewal or a successor may have moved the window past it.
+ *
+ * The issuer binds the successor it states for a member, so the node's session and key pair survive
+ * a workload, readiness or policy change; the node binds a fresh answer with it to tell a successor,
+ * which keeps its live session, from a new membership, which replaces it. A previous credential for
+ * the same projection binds too, which is how a renewal moves the expiry. Content binding only, as
+ * for the response binder.
+ */
+export const bindGetRuntimeManagedVpnCredentialSuccessor = async (value: unknown, previousValue: unknown,
+  previousProjectionValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown,
+  renewalValue: unknown | null = null): Promise<IGetRuntimeManagedVpnCredentialResponse> => {
+  try {
+    const response = snapshotGetRuntimeManagedVpnCredentialResponse(value);
+    const previous = snapshotGetRuntimeManagedVpnCredentialResponse(previousValue);
+    const previousInput = snapshotRuntimeNetworkProjection(previousProjectionValue);
+    const projectionInput = snapshotRuntimeNetworkProjection(projectionValue);
+    const trusted = snapshotRuntimeSessionBinding(trustedSessionValue), now = networkCounter(nowValue);
+    const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
+    const previousProjection = await validateRuntimeNetworkProjection(previousInput);
+    const projection = await validateRuntimeNetworkProjection(projectionInput);
+    const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
+    requireNetwork(continuesMembership(previousProjection, projection));
+    requireNetwork(networkEqual(previous.session, trusted)
+      && networkEqual(previous.projection, networkReferenceOf(previousProjection)));
+    requireNetwork(networkEqual(credentialIdentity(previous), credentialIdentity(response)));
+    return bindResponse(response, { session: trusted, projection: networkReferenceOf(projection) }, projection, renewal, trusted, now);
   } catch { return failNetwork(); }
 };

package/ts/data/runtimeassignment.ts

@@ -156,6 +156,38 @@ export type TRuntimeAssignmentDecision =
   | { status: 'reject'; reason: 'invalid' | 'scope-mismatch' | 'conflict' | 'stale'
       | 'predecessor-mismatch' | 'attempt-mismatch' | 'disposition-regression' };
 
+/**
+ * Why the runtime refused an image pull, as the node classifies the runtime's status: `other` is a
+ * status none of the named reasons matched.
+ */
+export const runtimeImagePullRefusalReasons = ['unauthorized', 'not-found', 'tls', 'transport', 'deadline',
+  'unavailable', 'other'] as const;
+export type TRuntimeImagePullRefusalReason = typeof runtimeImagePullRefusalReasons[number];
+
+/**
+ * Why a run failed, as its node can name it. Value-free: it carries a cause word and at most a
+ * bounded status number, never a runtime message, a registry, a reference or a path.
+ *
+ * - `image-pull-refused`: the runtime refused the pull before any sandbox or container of the run
+ *   existed, so the observation carries no runtime identity. `grpcCode` is the runtime's gRPC
+ *   status code (1..16) and `reason` the node's classification of it.
+ * - `exited`: the run's container ended on its own. `exitCode` is its exit status (0..255), or null
+ *   when the runtime stated none or one outside that range.
+ * - `runtime-absent`: the runtime holds no sandbox or container of a run that should be running.
+ * - `network-epoch-ended`: the run's network attachment belongs to a network epoch that has ended,
+ *   so the node stopped it rather than leave it running without its network.
+ *
+ * The cause explains the failure; it changes nothing about it. Every failed run is replaced the same
+ * way, whichever cause it states.
+ */
+export type TRuntimeAssignmentFailureCause =
+  | { kind: 'image-pull-refused'; reason: TRuntimeImagePullRefusalReason; grpcCode: number }
+  | { kind: 'exited'; exitCode: number | null }
+  | { kind: 'runtime-absent' }
+  | { kind: 'network-epoch-ended' };
+export const runtimeAssignmentFailureCauseKinds = ['image-pull-refused', 'exited', 'runtime-absent',
+  'network-epoch-ended'] as const satisfies readonly TRuntimeAssignmentFailureCause['kind'][];
+
 /** Value-free execution evidence. Receipt/acceptance alone never means ready. */
 export interface IRuntimeAssignmentObservation {
   assignment: IRuntimeAssignmentReference;
@@ -171,6 +203,11 @@ export interface IRuntimeAssignmentObservation {
     containerId: string;
     imageDigest: TSha256Digest;
   } | null;
+  /**
+   * Why the run failed, stated only with phase `failed` and only when the node can name it. Absent,
+   * a failed observation keeps the canonical bytes and digest it had before causes existed.
+   */
+  cause?: TRuntimeAssignmentFailureCause;
   digest: TSha256Digest;
 }
 
@@ -429,9 +466,31 @@ export const evaluateRuntimeAssignment = async (
   return { status: 'accept', assignment: incomingArg };
 };
 
+const isBoundedInteger = (valueArg: unknown, minimumArg: number, maximumArg: number): valueArg is number =>
+  typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg >= minimumArg && valueArg <= maximumArg;
+
+/** Whether a stated failure cause has exactly the shape of its kind. */
+const isFailureCause = (valueArg: unknown): valueArg is TRuntimeAssignmentFailureCause => {
+  if (!isExactRecord(valueArg, ['kind'], ['reason', 'grpcCode', 'exitCode'])) return false;
+  switch (valueArg.kind) {
+    case 'image-pull-refused':
+      return isExactRecord(valueArg, ['kind', 'reason', 'grpcCode'])
+        && runtimeImagePullRefusalReasons.some((reasonArg) => reasonArg === valueArg.reason)
+        && isBoundedInteger(valueArg.grpcCode, 1, 16);
+    case 'exited':
+      return isExactRecord(valueArg, ['kind', 'exitCode'])
+        && (valueArg.exitCode === null || isBoundedInteger(valueArg.exitCode, 0, 255));
+    case 'runtime-absent':
+    case 'network-epoch-ended':
+      return isExactRecord(valueArg, ['kind']);
+    default:
+      return false;
+  }
+};
+
 const assertObservation = (valueArg: unknown): IRuntimeAssignmentObservation => {
   if (!isExactRecord(valueArg, ['assignment', 'reporterSessionId',
-    'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'])
+    'sequence', 'observedAt', 'phase', 'ready', 'runtime', 'digest'], ['cause'])
     || !isAssignmentReference(valueArg.assignment)
     || !isIdentifier(valueArg.reporterSessionId) || !isPositiveInteger(valueArg.sequence)
     || !isPositiveInteger(valueArg.observedAt) || !isDigest(valueArg.digest)
@@ -448,6 +507,10 @@ const assertObservation = (valueArg: unknown): IRuntimeAssignmentObservation =>
     || (valueArg.phase === 'removed' && valueArg.runtime !== null)) {
     fail('runtime observation readiness and identity contradict its phase');
   }
+  if (Object.hasOwn(valueArg, 'cause') && (valueArg.phase !== 'failed' || !isFailureCause(valueArg.cause)
+    || (valueArg.cause.kind === 'image-pull-refused' && valueArg.runtime !== null))) {
+    fail('runtime observation failure cause must be exact and belong to a failed run');
+  }
   canonical(valueArg);
   return valueArg as unknown as IRuntimeAssignmentObservation;
 };

package/ts/data/serviceruntime.ts

@@ -192,8 +192,11 @@ export interface IServiceRuntimeAssignmentView {
   /** The current revision; its generation is the one the disposition belongs to. */
   assignment: IRuntimeAssignmentReference;
   disposition: TRuntimeAssignmentDisposition;
-  /** The latest accepted observation of this attempt, which may cite an earlier revision. */
-  observation: Pick<IRuntimeAssignmentObservation, 'phase' | 'ready' | 'observedAt' | 'sequence'> | null;
+  /**
+   * The latest accepted observation of this attempt, which may cite an earlier revision. A failed
+   * one carries the node's failure cause when the node stated one.
+   */
+  observation: Pick<IRuntimeAssignmentObservation, 'phase' | 'ready' | 'observedAt' | 'sequence' | 'cause'> | null;
   /** Joined stop and remove receipts of this attempt. */
   terminalReceiptCount: 0 | 1 | 2;
   delivery: TServiceRuntimeAssignmentDelivery;