@serve.zone/interfaces 32.16.0 → 32.18.0

package/changelog.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 2026-09-22 - 32.18.0
+
+### Features
+
+- Answer a refused Spark legacy-retirement statement on the wire. The observation that carried it
+  stays accepted — a node's liveness and census are true whatever its released runtime states, and
+  the cluster's target set depends on their freshness — while the accepted receipt answers the
+  statement itself through the new optional member `fleetCutoverLegacyRetirement`, a
+  `TSparkLegacyRetirementOutcome` that is `accepted` at the generation both node-owned records
+  advanced to, `restated` for the replay that renewed nothing, or `refused` by one of the
+  contract's own refusal names and never retryable, because resending one exact statement cannot
+  change the answer. `validateSparkSwarmObservationResponse` binds answer to statement in both
+  directions: a receipt that answers a statement the observation never made, or leaves one it did
+  make unanswered, is refused, and a rejected receipt carries no outcome at all.
+  `evidence-refused` joins the observation rejection codes as the one non-retryable answer about
+  content rather than sequencing — an evidence member a server refuses for this body and every
+  resend of it — leaving a server-side condition a later attempt could pass as `acceptance-race`.
+  `sparkLegacyConfigurationDispositions` and `TSparkLegacyConfigurationDisposition` are exported
+  beside the runtime modes, and the release-version grammar (`IReleaseVersion`,
+  `parseReleaseVersion`, `isReleaseVersion`, `compareReleaseVersions`,
+  `maximumReleaseVersionLength`) moves from `private/` into `data/`, so a policy that orders two
+  released versions reads the package's own comparison instead of splitting strings of its own.
+  Every addition is additive; no existing shape narrows.
+
+### Maintenance
+
+- Pin pnpm 12.4.2 as the release package manager.
+
+## 2026-09-22 - 32.17.0
+
+### Features
+
+- Add generation-bearing cluster relay credential authority, its accepted registration record and
+  the legacy shared-credential retirement receipt. Cloudly can mint and rotate a relay credential
+  whose exact generation authenticates one socket, answer an accepted registration that names that
+  generation and the record it wrote, and accept an explicit retirement of the pre-relay shared
+  cluster authority only after a replacement relay has registered under the replacement credential
+  and is live. Rotation has no overlap window: a superseded generation ends the relay's custody
+  through the new `relay-credential-generation-stale` refusal. The credential authenticates the
+  same cluster control-plane session as before; the gain is generation and revocability, not a
+  narrower scope. No shape carries bearer, hash or key material; the bearer travels only as an
+  immutable encrypted secret version reference. `IRegisterClusterRelayResponse` gains `credential`
+  and `acceptedRegistration` as required members, so its one producer, Cloudly, must supply them
+  to compile; that break is the intended fail-closed.
+- Add the Spark-owned producers the Coreflow retirement evidence still lacked. A Swarm-era Spark
+  states, on the observation it already posts, the verified bundle installed on its host and the
+  unit that will boot it, the released owning mode it refuses, and its released configuration
+  source by digest, owner generation and disposition. There is no route for it: the evidence
+  requires the relay's node observation and the Spark observation to be the identical accepted
+  reference, so the facts travel on the census observation itself. Cloudly accepts them into two
+  revisioned node-owned records whose references complete `legacy.oldModeRefusal` and
+  `legacy.configurationCas`, and whose content it flattens into the evidence's Spark bundle, unit
+  and legacy-source members; `IFleetCutoverCoreflowRetirementEvidence` itself is unchanged. The new
+  member is optional, names no node, carries no proof boolean and can represent no decoded member
+  of the released configuration file, which holds that node's bearer and jump code. An omitted
+  member advances nothing, so a retirement is honest through the freshness of the observation its
+  records name, not through their existence. Cloudly reads this minor before Spark writes it:
+  every observation validator is exact-key, so a server that does not know the member refuses the
+  whole observation instead of ignoring it.
+
 ## 2026-09-20 - 32.16.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/cluster.d.ts

@@ -1,5 +1,8 @@
 import * as plugins from '../plugins.js';
 import type { IClusterNode } from './clusternode.js';
+import type { IFleetCutoverAcceptedEvidenceReference } from './fleetcutover.js';
+import type { TSha256Digest } from './immutableimage.js';
+import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
 import { type IProtocolOffer } from '../protocol.js';
 export interface ICluster {
     id: string;
@@ -119,6 +122,16 @@ export interface IRegisterClusterRelayResponse {
     origin: string;
     /** Cloudly's own offer, so an accepted relay judges the session it just registered into. */
     protocol: IProtocolOffer;
+    /**
+     * The relay credential generation Cloudly authenticated this socket as.
+     *
+     * Read from Cloudly's own record and never from the registration: a relay that stated its own
+     * generation would be asserting its own rank. It is how a relay learns the exact generation its
+     * readiness is bound to.
+     */
+    credential: IRuntimeAuthorityReference;
+    /** The accepted registration record this answer wrote, as a retirement record later cites it. */
+    acceptedRegistration: IFleetCutoverAcceptedEvidenceReference;
 }
 /**
  * The registration refusals that end a relay's custody of its cluster.
@@ -129,7 +142,7 @@ export interface IRegisterClusterRelayResponse {
  * says it could not verify the relay, a malformed or conflicting registration, an internal error —
  * state nothing about dispatch and are not listed here.
  */
-export declare const clusterRelayUndispatchedRefusals: readonly ["relay-cluster-not-enabled", "relay-node-foreign", "relay-sequence-not-advancing"];
+export declare const clusterRelayUndispatchedRefusals: readonly ["relay-cluster-not-enabled", "relay-node-foreign", "relay-sequence-not-advancing", "relay-credential-generation-stale"];
 /** One of the reasons Cloudly states that it does not dispatch to a relay. */
 export type TClusterRelayUndispatchedRefusal = typeof clusterRelayUndispatchedRefusals[number];
 /**
@@ -165,14 +178,12 @@ export declare const validateClusterRelayVpnHub: (valueArg: unknown, pathArg?: s
  */
 export declare const validateRegisterClusterRelayRequest: (valueArg: unknown, pathArg?: string) => string[];
 /**
- * One cluster's relay as Cloudly serves it to an administrator.
+ * What one accepted relay registration states about the relay that sent it.
  *
- * This is the read shape, not the registration a relay sends: `IRegisterClusterRelayRequest` is
- * what the relay puts on the wire, and this is what Cloudly answers with after it accepted one.
- * `clusterId` names the cluster the relay serves, and `acceptedAt` is Cloudly's own acceptance
- * time, which is what orders two registrations of one cluster.
+ * The part the served read shape and the accepted record share: no record identity, no digest and
+ * no liveness, so neither shape restates the other's fields.
  */
-export interface IClusterRelayRegistration {
+export interface IClusterRelayRegistrationFacts {
     clusterId: string;
     nodeId: string;
     listenAddress: string;
@@ -180,6 +191,16 @@ export interface IClusterRelayRegistration {
     version: string;
     registrationSequence: number;
     acceptedAt: number;
+}
+/**
+ * One cluster's relay as Cloudly serves it to an administrator.
+ *
+ * This is the read shape, not the registration a relay sends: `IRegisterClusterRelayRequest` is
+ * what the relay puts on the wire, and this is what Cloudly answers with after it accepted one.
+ * `clusterId` names the cluster the relay serves, and `acceptedAt` is Cloudly's own acceptance
+ * time, which is what orders two registrations of one cluster.
+ */
+export interface IClusterRelayRegistration extends IClusterRelayRegistrationFacts {
     /**
      * Whether a verified socket carries this relay at this instant.
      *
@@ -197,6 +218,28 @@ export interface IClusterRelayRegistration {
  * that passes here has claimed nothing.
  */
 export declare const validateClusterRelayRegistration: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * Cloudly's accepted registration record: the thing an evidence reference names.
+ *
+ * `credential` is the exact relay credential generation the registering socket authenticated as,
+ * so a reader can tell a registration made under the current credential from one made under a
+ * superseded one. Liveness is deliberately absent: a live socket is not a fact a record can hold,
+ * and a digest that covered it would change without anything having been registered.
+ */
+export interface IClusterRelayAcceptedRegistration extends IClusterRelayRegistrationFacts {
+    id: string;
+    /** Advances by one per accepted registration, so a reference to a superseded one fails closed. */
+    generation: number;
+    credential: IRuntimeAuthorityReference;
+    digest: TSha256Digest;
+}
+export declare const clusterRelayContract: Readonly<{
+    readonly acceptedRegistrationDigestDomain: "serve.zone/cluster-relay-accepted-registration";
+}>;
+/** Structural copy only; whether the record is the cluster's current one is Cloudly's to decide. */
+export declare const snapshotClusterRelayAcceptedRegistration: (valueArg: unknown) => IClusterRelayAcceptedRegistration;
+export declare const computeClusterRelayAcceptedRegistrationDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterRelayAcceptedRegistration: (valueArg: unknown) => Promise<string[]>;
 /**
  * The name the relay's certificate is issued for, and the A record Cloudly
  * owns for it. Derived from the origin so every consumer derives it

package/dist_ts/data/cluster.js

@@ -4,7 +4,7 @@ import { isPlausibleUnicastIpv4 } from '../private/ipv4.js';
 import { validateProtocolOfferOn } from '../protocol.js';
 import { hasExactKeys } from '../private/dataproperties.js';
 import { isClusterNodeId } from '../private/nodeidentifier.js';
-import { networkNoiseKey } from '../private/networkcontract.js';
+import { captureNetwork, networkCounter, networkDigest, networkHash, networkId, networkNoiseKey, networkRecord, networkReference, } from '../private/networkcontract.js';
 /**
  * The registration refusals that end a relay's custody of its cluster.
  *
@@ -21,6 +21,13 @@ export const clusterRelayUndispatchedRefusals = Object.freeze([
     'relay-node-foreign',
     /** A registration of this relay identity at the same or a higher sequence is already recorded. */
     'relay-sequence-not-advancing',
+    /**
+     * The credential this socket authenticated with is no longer the cluster's current generation.
+     *
+     * Rotation has no overlap, so another relay may already hold the current one: this relay is not
+     * the one Cloudly dispatches to, which `relay-identity-unverified` never states.
+     */
+    'relay-credential-generation-stale',
 ]);
 const maximumClusterRelayOriginLength = 2048;
 const maximumClusterRelayVersionLength = 64;
@@ -170,6 +177,20 @@ export const validateRegisterClusterRelayRequest = (valueArg, pathArg = 'cluster
     errors.push(...validateClusterRelayNonNegativeInteger(valueArg.registrationSequence, `${pathArg} registrationSequence`));
     return errors;
 };
+const clusterRelayRegistrationFactKeys = [
+    'clusterId', 'nodeId', 'listenAddress', 'listenPort', 'version', 'registrationSequence',
+    'acceptedAt',
+];
+/** The one format rule of every registration fact, whichever shape carries it. */
+const validateClusterRelayRegistrationFacts = (valueArg, pathArg) => [
+    ...validateClusterRelayIdentifier(valueArg.clusterId, `${pathArg} clusterId`),
+    ...validateClusterRelayIdentifier(valueArg.nodeId, `${pathArg} nodeId`),
+    ...validateClusterRelayListenAddress(valueArg.listenAddress, `${pathArg} listenAddress`),
+    ...validateClusterRelayListenPort(valueArg.listenPort, `${pathArg} listenPort`),
+    ...validateClusterRelayVersion(valueArg.version, `${pathArg} version`),
+    ...validateClusterRelayNonNegativeInteger(valueArg.registrationSequence, `${pathArg} registrationSequence`),
+    ...validateClusterRelayNonNegativeInteger(valueArg.acceptedAt, `${pathArg} acceptedAt`),
+];
 /**
  * Validates one served relay registration and names every reason it is refused.
  *
@@ -178,21 +199,61 @@ export const validateRegisterClusterRelayRequest = (valueArg, pathArg = 'cluster
  * that passes here has claimed nothing.
  */
 export const validateClusterRelayRegistration = (valueArg, pathArg = 'cluster relay registration') => {
-    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['clusterId', 'nodeId', 'listenAddress',
-        'listenPort', 'version', 'registrationSequence', 'acceptedAt', 'live'])) {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, [...clusterRelayRegistrationFactKeys, 'live'])) {
         return [`${pathArg} must use its exact schema`];
     }
     return [
-        ...validateClusterRelayIdentifier(valueArg.clusterId, `${pathArg} clusterId`),
-        ...validateClusterRelayIdentifier(valueArg.nodeId, `${pathArg} nodeId`),
-        ...validateClusterRelayListenAddress(valueArg.listenAddress, `${pathArg} listenAddress`),
-        ...validateClusterRelayListenPort(valueArg.listenPort, `${pathArg} listenPort`),
-        ...validateClusterRelayVersion(valueArg.version, `${pathArg} version`),
-        ...validateClusterRelayNonNegativeInteger(valueArg.registrationSequence, `${pathArg} registrationSequence`),
-        ...validateClusterRelayNonNegativeInteger(valueArg.acceptedAt, `${pathArg} acceptedAt`),
+        ...validateClusterRelayRegistrationFacts(valueArg, pathArg),
         ...(typeof valueArg.live === 'boolean' ? [] : [`${pathArg} live must be a boolean`]),
     ];
 };
+export const clusterRelayContract = Object.freeze({
+    acceptedRegistrationDigestDomain: 'serve.zone/cluster-relay-accepted-registration',
+});
+const failClusterRelayRecord = () => {
+    throw new Error('Cluster relay contract rejected.');
+};
+/** The facts of an already exact-keyed record, refused unless each passes its one format rule. */
+const readClusterRelayRegistrationFacts = (valueArg) => {
+    if (validateClusterRelayRegistrationFacts(valueArg, 'cluster relay registration').length > 0) {
+        failClusterRelayRecord();
+    }
+    const { clusterId, nodeId, listenAddress, listenPort, version, registrationSequence, acceptedAt, } = valueArg;
+    // Each member passed its format rule above, which is what the assertion states.
+    return {
+        clusterId, nodeId, listenAddress, listenPort, version, registrationSequence, acceptedAt,
+    };
+};
+/** Structural copy only; whether the record is the cluster's current one is Cloudly's to decide. */
+export const snapshotClusterRelayAcceptedRegistration = (valueArg) => {
+    try {
+        const value = networkRecord(captureNetwork(valueArg), [
+            ...clusterRelayRegistrationFactKeys, 'id', 'generation', 'credential', 'digest',
+        ]);
+        return {
+            ...readClusterRelayRegistrationFacts(value),
+            id: networkId(value.id),
+            generation: networkCounter(value.generation),
+            credential: networkReference(value.credential),
+            digest: networkDigest(value.digest),
+        };
+    }
+    catch {
+        return failClusterRelayRecord();
+    }
+};
+export const computeClusterRelayAcceptedRegistrationDigest = async (valueArg) => networkHash(clusterRelayContract.acceptedRegistrationDigestDomain, snapshotClusterRelayAcceptedRegistration(valueArg));
+export const validateClusterRelayAcceptedRegistration = async (valueArg) => {
+    try {
+        const value = snapshotClusterRelayAcceptedRegistration(valueArg);
+        return value.digest === await computeClusterRelayAcceptedRegistrationDigest(value)
+            ? [] : ['cluster relay accepted registration digest does not match'];
+    }
+    catch {
+        return ['cluster relay accepted registration must use its exact canonical schema'];
+    }
+};
 /**
  * The name the relay's certificate is issued for, and the A record Cloudly
  * owns for it. Derived from the origin so every consumer derives it
@@ -206,4 +267,4 @@ export const clusterRelayCertificateDomainName = (relayArg) => {
     }
     return new URL(relayArg.origin).hostname;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../ts/data/cluster.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../ts/data/cluster.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/clusternode.d.ts

@@ -2,6 +2,7 @@ import * as plugins from '../plugins.js';
 import { type TSha256Digest, type TImmutableContainerPlatform } from './immutableimage.js';
 import type { ISparkNodeReportRecord } from './sparknodereport.js';
 import { type IFleetCutoverAcceptedEvidenceReference, type IFleetCutoverHeldVolumeFenceEvidencePage, type IFleetCutoverLocalNodeSnapshot, type IFleetCutoverManagerSnapshot, type IFleetCutoverPreparedVolumeHandoffAggregate, type IFleetCutoverPreparedVolumeHandoffIntent, type IFleetCutoverPreparedVolumeHandoffPage } from './fleetcutover.js';
+import { type ISparkLegacyRuntimeRetirement, type TSparkLegacyRetirementOutcome } from './sparklegacyretirement.js';
 import { type IProtocolOffer } from '../protocol.js';
 import { isClusterNodeId } from '../private/nodeidentifier.js';
 /**
@@ -198,6 +199,8 @@ interface ISparkSwarmObservationBase {
     observedAt: number;
     /** Available in every observation state; exact page membership proves an empty node subset. */
     fleetCutoverHeldVolumeFences?: IFleetCutoverHeldVolumeFenceEvidencePage;
+    /** Available in every observation state too: this describes the host, not its Docker daemon. */
+    fleetCutoverLegacyRetirement?: ISparkLegacyRuntimeRetirement;
 }
 export type TSparkSwarmObservation = (ISparkSwarmObservationBase & {
     state: 'unknown';
@@ -221,7 +224,17 @@ export type TSparkSwarmObservation = (ISparkSwarmObservationBase & {
     /** Manager-visible services/tasks only; it never claims remote physical containers. */
     fleetCutoverManagerSnapshot?: IFleetCutoverManagerSnapshot;
 });
-export type TSparkSwarmObservationRejectionCode = 'sequence-conflict' | 'sequence-stale' | 'sequence-gap' | 'session-sequence-invalid' | 'session-retired' | 'observation-too-old' | 'observation-from-future' | 'observation-time-not-advancing' | 'acceptance-race';
+export type TSparkSwarmObservationRejectionCode = 'sequence-conflict' | 'sequence-stale' | 'sequence-gap' | 'session-sequence-invalid' | 'session-retired' | 'observation-too-old' | 'observation-from-future' | 'observation-time-not-advancing' | 'acceptance-race'
+/**
+ * An evidence member of this observation is refused, for this body and every resend of it.
+ *
+ * The whole observation is rejected because the refused content is what the body states, and a
+ * node that keeps resending it would never be recorded. It is the answer for a member whose
+ * content this server has decided against; a server-side condition that a later attempt could
+ * pass is `acceptance-race` instead, and telling the two apart while accepting evidence is the
+ * server's own work.
+ */
+ | 'evidence-refused';
 export declare const sparkSwarmObservationContract: Readonly<{
     readonly digestDomain: "serve.zone/spark-swarm-observation";
     readonly maximumPastAgeMs: 300000;
@@ -237,6 +250,7 @@ export declare const sparkSwarmObservationContract: Readonly<{
         'observation-from-future': false;
         'observation-time-not-advancing': false;
         'acceptance-race': true;
+        'evidence-refused': false;
     }>;
 }>;
 /** Cloudly derives node and cluster scope from this authenticated Spark request. */
@@ -278,6 +292,15 @@ export interface ISparkSwarmObservationAcceptedReceipt {
     acceptedAt: number;
     /** Runtime target generation observed immediately after this acceptance. */
     targetGenerationAtAcceptance: number;
+    /**
+     * What the server did with `fleetCutoverLegacyRetirement`, present exactly when it was stated.
+     *
+     * A statement about the node's own released runtime is judged against records rather than
+     * against this message, so its refusal is answered here instead of rejecting an observation
+     * whose liveness and census are true either way. Absent on the rejected receipt: an observation
+     * that was not accepted never reached the statement.
+     */
+    fleetCutoverLegacyRetirement?: TSparkLegacyRetirementOutcome;
     /** The answering server's offer; see `sparkSwarmNodeContracts`. */
     protocol: IProtocolOffer;
 }