@serve.zone/interfaces 32.16.0 → 32.17.0

package/dist_ts/data/clusterrelaycredential.d.ts

@@ -0,0 +1,141 @@
+import type { IClusterRelayAcceptedRegistration } from './cluster.js';
+import type { IFleetCutoverAcceptedEvidenceReference } from './fleetcutover.js';
+import type { TSha256Digest } from './immutableimage.js';
+import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
+import type { ISecretVersionReference } from './secret.js';
+/**
+ * The relay authority Cloudly mints for one cluster. Public metadata only: never a bearer or hash.
+ *
+ * It authenticates the cluster's whole control-plane session, exactly what the shared cluster
+ * authority authenticated before it, so the relay changes one credential and keeps every call it
+ * makes. What it adds is a generation Cloudly fences each socket against and an authority it can
+ * rotate without touching the shared one; its scope is not narrower. One cluster has one relay and
+ * therefore one such record, and rotation is its whole lifecycle: it never expires by itself.
+ */
+export interface IClusterRelayCredential {
+    id: string;
+    clusterId: string;
+    /** Monotonic state: one accepted mint or rotation advances it by exactly one. */
+    generation: number;
+    /** The machine identity this credential authenticates as; Cloudly's own, never caller-chosen. */
+    userId: string;
+    /** The immutable encrypted version the bearer was delivered as. */
+    delivery: ISecretVersionReference;
+    actorId: string;
+    acceptedAt: number;
+    digest: TSha256Digest;
+}
+interface IClusterRelayCredentialMutationBase {
+    clusterId: string;
+    /** Retain the complete request and this ID across retries; a changed body with it fails closed. */
+    mutationId: string;
+}
+/**
+ * Creation is absent-only; rotation requires the exact current generation, never a minimum.
+ *
+ * There is no revocation: a rotation already ends the previous generation at commit, so it covers a
+ * compromised credential without a state in which the cluster has no relay authority at all.
+ */
+export type TClusterRelayCredentialMutation = IClusterRelayCredentialMutationBase & ({
+    operation: 'ensure';
+    expectedGeneration: null;
+} | {
+    operation: 'rotate';
+    expectedGeneration: number;
+});
+export interface IClusterRelayCredentialMutationResult {
+    credential: IClusterRelayCredential;
+    /** The shared pre-relay authority this cluster still carries; null when no record names one. */
+    legacy: IClusterLegacyRelayCredential | null;
+    /** A replay returns the original result without renewing delivery, generation or authority. */
+    replayed: boolean;
+}
+/**
+ * Cloudly's record of the shared cluster authority that predates the relay credential, so it can
+ * be named and retired. It is the machine identity every cluster-side component authenticated as;
+ * like the relay credential it carries no bearer and no hash.
+ */
+export interface IClusterLegacyRelayCredential {
+    id: string;
+    clusterId: string;
+    userId: string;
+    generation: number;
+    state: 'active' | 'revoked';
+    /**
+     * The accepted invalidation that revoked it; null exactly while it is still accepted.
+     *
+     * The invalidation names this record at the generation before the revocation and this record
+     * names the invalidation at the generation after it, so neither digest covers the other's.
+     */
+    invalidation: IFleetCutoverAcceptedEvidenceReference | null;
+    recordedAt: number;
+    digest: TSha256Digest;
+}
+/**
+ * Caller intent only. Both references are compare-and-swap inputs: Cloudly dereferences them
+ * against its own current records and checks the relay's live socket itself.
+ */
+export interface IClusterLegacyRelayCredentialRetirementRequest {
+    /** Retain the complete request and this ID across retries; a changed body with it fails closed. */
+    mutationId: string;
+    clusterId: string;
+    expectedLegacyGeneration: number;
+    /** The exact replacement relay credential generation the caller observed as current. */
+    replacement: IRuntimeAuthorityReference;
+    /** The exact accepted registration the caller observed as current. */
+    acceptedRegistration: IFleetCutoverAcceptedEvidenceReference;
+}
+/** The accepted receipt that one shared cluster authority stopped being accepted; written once. */
+export interface IClusterLegacyRelayCredentialInvalidation {
+    id: string;
+    generation: 1;
+    clusterId: string;
+    /** The exact legacy generation this invalidated, read before the record advanced. */
+    credential: IRuntimeAuthorityReference;
+    /** The relay credential generation that was current when this was accepted. */
+    replacement: IRuntimeAuthorityReference;
+    /** The registration that was current, made under `replacement`, and live when this was accepted. */
+    acceptedRegistration: IFleetCutoverAcceptedEvidenceReference;
+    actorId: string;
+    acceptedAt: number;
+    digest: TSha256Digest;
+}
+export interface IClusterLegacyRelayCredentialRetirementResult {
+    credential: IClusterLegacyRelayCredential;
+    invalidation: IClusterLegacyRelayCredentialInvalidation;
+    /** A replay returns the recorded invalidation; nothing is revoked twice. */
+    replayed: boolean;
+}
+export declare const clusterRelayCredentialContract: Readonly<{
+    readonly credentialDigestDomain: "serve.zone/cluster-relay-credential";
+    readonly legacyCredentialDigestDomain: "serve.zone/cluster-relay-legacy-credential";
+    readonly legacyInvalidationDigestDomain: "serve.zone/cluster-relay-legacy-credential-invalidation";
+}>;
+/** Every reason Cloudly answers instead of mutating or retiring a cluster relay authority. */
+export declare const clusterRelayCredentialRefusals: readonly ["relay-credential-absent", "legacy-credential-absent", "legacy-credential-already-retired", "legacy-retirement-replacement-not-current", "legacy-retirement-registration-not-current", "legacy-retirement-relay-not-live", "conflict"];
+export type TClusterRelayCredentialRefusal = typeof clusterRelayCredentialRefusals[number];
+/** Structural copy only; whether the record is the cluster's current one is Cloudly's to decide. */
+export declare const snapshotClusterRelayCredential: (valueArg: unknown) => IClusterRelayCredential;
+export declare const computeClusterRelayCredentialDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterRelayCredential: (valueArg: unknown) => Promise<string[]>;
+export declare const snapshotClusterRelayCredentialMutation: (valueArg: unknown) => TClusterRelayCredentialMutation;
+export declare const snapshotClusterLegacyRelayCredential: (valueArg: unknown) => IClusterLegacyRelayCredential;
+export declare const computeClusterLegacyRelayCredentialDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterLegacyRelayCredential: (valueArg: unknown) => Promise<string[]>;
+export declare const snapshotClusterLegacyRelayCredentialRetirementRequest: (valueArg: unknown) => IClusterLegacyRelayCredentialRetirementRequest;
+export declare const snapshotClusterLegacyRelayCredentialInvalidation: (valueArg: unknown) => IClusterLegacyRelayCredentialInvalidation;
+export declare const computeClusterLegacyRelayCredentialInvalidationDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterLegacyRelayCredentialInvalidation: (valueArg: unknown) => Promise<string[]>;
+/**
+ * Joins an invalidation to the shared authority it revoked and to the registration that justified
+ * it, which must have been made under the very replacement the invalidation names.
+ *
+ * Content join only. Cloudly must still dereference each record as its cluster's current one and
+ * require a live verified socket for the registration while holding its compare-and-swap.
+ */
+export declare const bindClusterLegacyRelayCredentialInvalidation: (invalidationArg: unknown, legacyCredentialArg: unknown, acceptedRegistrationArg: unknown) => Promise<{
+    invalidation: IClusterLegacyRelayCredentialInvalidation;
+    legacyCredential: IClusterLegacyRelayCredential;
+    acceptedRegistration: IClusterRelayAcceptedRegistration;
+}>;
+export {};

package/dist_ts/data/clusterrelaycredential.js

@@ -0,0 +1,192 @@
+import { snapshotClusterRelayAcceptedRegistration, validateClusterRelayAcceptedRegistration, } from './cluster.js';
+import { captureNetwork, networkCounter, networkDigest, networkEqual, networkHash, networkId, networkRecord, networkReference, networkReferenceOf, requireNetwork, } from '../private/networkcontract.js';
+export const clusterRelayCredentialContract = Object.freeze({
+    credentialDigestDomain: 'serve.zone/cluster-relay-credential',
+    legacyCredentialDigestDomain: 'serve.zone/cluster-relay-legacy-credential',
+    legacyInvalidationDigestDomain: 'serve.zone/cluster-relay-legacy-credential-invalidation',
+});
+/** Every reason Cloudly answers instead of mutating or retiring a cluster relay authority. */
+export const clusterRelayCredentialRefusals = Object.freeze([
+    /** A rotation named a cluster that has no relay credential yet. */
+    'relay-credential-absent',
+    /** A retirement named a cluster whose shared authority no record names. */
+    'legacy-credential-absent',
+    /** The shared authority is already revoked; its invalidation is written once. */
+    'legacy-credential-already-retired',
+    /** The named replacement is not the cluster's relay credential at its current generation. */
+    'legacy-retirement-replacement-not-current',
+    /** The named registration is not current, or it was made under another credential generation. */
+    'legacy-retirement-registration-not-current',
+    /** No verified socket carries the named registration at the instant of acceptance. */
+    'legacy-retirement-relay-not-live',
+    /** An expected generation was not the exact current one, or a mutation ID met a changed body. */
+    'conflict',
+]);
+const fail = () => { throw new Error('Cluster relay credential contract rejected.'); };
+const safe = (operationArg) => {
+    try {
+        return operationArg();
+    }
+    catch {
+        return fail();
+    }
+};
+const secretVersionReference = (valueArg) => {
+    const value = networkRecord(valueArg, ['secretId', 'secretVersionId']);
+    return {
+        secretId: networkId(value.secretId),
+        secretVersionId: networkId(value.secretVersionId),
+    };
+};
+/** Structural copy only; whether the record is the cluster's current one is Cloudly's to decide. */
+export const snapshotClusterRelayCredential = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'clusterId', 'generation', 'userId', 'delivery', 'actorId', 'acceptedAt', 'digest',
+    ]);
+    return {
+        id: networkId(value.id),
+        clusterId: networkId(value.clusterId),
+        generation: networkCounter(value.generation),
+        userId: networkId(value.userId),
+        delivery: secretVersionReference(value.delivery),
+        actorId: networkId(value.actorId),
+        acceptedAt: networkCounter(value.acceptedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterRelayCredentialDigest = async (valueArg) => networkHash(clusterRelayCredentialContract.credentialDigestDomain, snapshotClusterRelayCredential(valueArg));
+export const validateClusterRelayCredential = async (valueArg) => {
+    try {
+        const value = snapshotClusterRelayCredential(valueArg);
+        return value.digest === await computeClusterRelayCredentialDigest(value)
+            ? [] : ['cluster relay credential digest does not match'];
+    }
+    catch {
+        return ['cluster relay credential must use its exact canonical schema'];
+    }
+};
+export const snapshotClusterRelayCredentialMutation = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'clusterId', 'mutationId', 'operation', 'expectedGeneration',
+    ]);
+    const base = { clusterId: networkId(value.clusterId), mutationId: networkId(value.mutationId) };
+    const operation = value.operation;
+    requireNetwork(operation === 'ensure' || operation === 'rotate');
+    if (operation === 'ensure') {
+        requireNetwork(value.expectedGeneration === null);
+        return { ...base, operation, expectedGeneration: null };
+    }
+    return { ...base, operation, expectedGeneration: networkCounter(value.expectedGeneration) };
+});
+export const snapshotClusterLegacyRelayCredential = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'clusterId', 'userId', 'generation', 'state', 'invalidation', 'recordedAt', 'digest',
+    ]);
+    const state = value.state;
+    requireNetwork(state === 'active' || state === 'revoked');
+    const generation = networkCounter(value.generation);
+    const invalidation = value.invalidation === null ? null : networkReference(value.invalidation);
+    // Revoked exactly when an invalidation names it, and only as the successor of an active record.
+    requireNetwork(state === 'active'
+        ? invalidation === null
+        : invalidation !== null && invalidation.generation === 1 && generation > 1);
+    return {
+        id: networkId(value.id),
+        clusterId: networkId(value.clusterId),
+        userId: networkId(value.userId),
+        generation,
+        state,
+        invalidation,
+        recordedAt: networkCounter(value.recordedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterLegacyRelayCredentialDigest = async (valueArg) => networkHash(clusterRelayCredentialContract.legacyCredentialDigestDomain, snapshotClusterLegacyRelayCredential(valueArg));
+export const validateClusterLegacyRelayCredential = async (valueArg) => {
+    try {
+        const value = snapshotClusterLegacyRelayCredential(valueArg);
+        return value.digest === await computeClusterLegacyRelayCredentialDigest(value)
+            ? [] : ['cluster legacy relay credential digest does not match'];
+    }
+    catch {
+        return ['cluster legacy relay credential must use its exact canonical schema'];
+    }
+};
+export const snapshotClusterLegacyRelayCredentialRetirementRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'mutationId', 'clusterId', 'expectedLegacyGeneration', 'replacement', 'acceptedRegistration',
+    ]);
+    return {
+        mutationId: networkId(value.mutationId),
+        clusterId: networkId(value.clusterId),
+        expectedLegacyGeneration: networkCounter(value.expectedLegacyGeneration),
+        replacement: networkReference(value.replacement),
+        acceptedRegistration: networkReference(value.acceptedRegistration),
+    };
+});
+export const snapshotClusterLegacyRelayCredentialInvalidation = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'generation', 'clusterId', 'credential', 'replacement', 'acceptedRegistration',
+        'actorId', 'acceptedAt', 'digest',
+    ]);
+    requireNetwork(value.generation === 1);
+    return {
+        id: networkId(value.id),
+        generation: 1,
+        clusterId: networkId(value.clusterId),
+        credential: networkReference(value.credential),
+        replacement: networkReference(value.replacement),
+        acceptedRegistration: networkReference(value.acceptedRegistration),
+        actorId: networkId(value.actorId),
+        acceptedAt: networkCounter(value.acceptedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterLegacyRelayCredentialInvalidationDigest = async (valueArg) => networkHash(clusterRelayCredentialContract.legacyInvalidationDigestDomain, snapshotClusterLegacyRelayCredentialInvalidation(valueArg));
+export const validateClusterLegacyRelayCredentialInvalidation = async (valueArg) => {
+    try {
+        const value = snapshotClusterLegacyRelayCredentialInvalidation(valueArg);
+        return value.digest === await computeClusterLegacyRelayCredentialInvalidationDigest(value)
+            ? [] : ['cluster legacy relay credential invalidation digest does not match'];
+    }
+    catch {
+        return ['cluster legacy relay credential invalidation must use its exact canonical schema'];
+    }
+};
+/**
+ * The active record is named exactly. The revoked one is that record's successor, so it is named
+ * by identity and the generation before it, and it names the invalidation back.
+ */
+const invalidationNamesLegacyCredential = (invalidationArg, legacyCredentialArg) => legacyCredentialArg.state === 'active'
+    ? networkEqual(invalidationArg.credential, networkReferenceOf(legacyCredentialArg))
+    : invalidationArg.credential.id === legacyCredentialArg.id
+        && invalidationArg.credential.generation === legacyCredentialArg.generation - 1
+        && networkEqual(legacyCredentialArg.invalidation, networkReferenceOf(invalidationArg));
+/**
+ * Joins an invalidation to the shared authority it revoked and to the registration that justified
+ * it, which must have been made under the very replacement the invalidation names.
+ *
+ * Content join only. Cloudly must still dereference each record as its cluster's current one and
+ * require a live verified socket for the registration while holding its compare-and-swap.
+ */
+export const bindClusterLegacyRelayCredentialInvalidation = async (invalidationArg, legacyCredentialArg, acceptedRegistrationArg) => {
+    try {
+        const invalidation = snapshotClusterLegacyRelayCredentialInvalidation(invalidationArg);
+        const legacyCredential = snapshotClusterLegacyRelayCredential(legacyCredentialArg);
+        const acceptedRegistration = snapshotClusterRelayAcceptedRegistration(acceptedRegistrationArg);
+        if ((await validateClusterLegacyRelayCredentialInvalidation(invalidation)).length
+            || (await validateClusterLegacyRelayCredential(legacyCredential)).length
+            || (await validateClusterRelayAcceptedRegistration(acceptedRegistration)).length)
+            fail();
+        requireNetwork(legacyCredential.clusterId === invalidation.clusterId
+            && acceptedRegistration.clusterId === invalidation.clusterId
+            && invalidationNamesLegacyCredential(invalidation, legacyCredential)
+            && networkEqual(invalidation.acceptedRegistration, networkReferenceOf(acceptedRegistration))
+            && networkEqual(invalidation.replacement, acceptedRegistration.credential));
+        return { invalidation, legacyCredential, acceptedRegistration };
+    }
+    catch {
+        return fail();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusterrelaycredential.js","sourceRoot":"","sources":["../../ts/data/clusterrelaycredential.ts"],"names":[],"mappings":"AACA,OAAO,EACL,wCAAwC,EACxC,wCAAwC,GACzC,MAAM,cAAc,CAAC;AAKtB,OAAO,EACL,cAAc,EACd,cAAc,EACd,aAAa,EACb,YAAY,EACZ,WAAW,EACX,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,GACf,MAAM,+BAA+B,CAAC;AA8GvC,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,CAAC;IAC1D,sBAAsB,EAAE,qCAAqC;IAC7D,4BAA4B,EAAE,4CAA4C;IAC1E,8BAA8B,EAAE,yDAAyD;CACjF,CAAC,CAAC;AAEZ,8FAA8F;AAC9F,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,CAAC;IAC1D,mEAAmE;IACnE,yBAAyB;IACzB,2EAA2E;IAC3E,0BAA0B;IAC1B,iFAAiF;IACjF,mCAAmC;IACnC,6FAA6F;IAC7F,2CAA2C;IAC3C,iGAAiG;IACjG,4CAA4C;IAC5C,sFAAsF;IACtF,kCAAkC;IAClC,iGAAiG;IACjG,UAAU;CACF,CAAC,CAAC;AAIZ,MAAM,IAAI,GAAG,GAAU,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9F,MAAM,IAAI,GAAG,CAAI,YAAqB,EAAK,EAAE;IAC3C,IAAI,CAAC;QAAC,OAAO,YAAY,EAAE,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,IAAI,EAAE,CAAC;IAAC,CAAC;AACzD,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAAC,QAAiB,EAA2B,EAAE;IAC5E,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACvE,OAAO;QACL,QAAQ,EAAE,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC;QACnC,eAAe,EAAE,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC;KAClD,CAAC;AACJ,CAAC,CAAC;AAEF,oGAAoG;AACpG,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAC5C,QAAiB,EACQ,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACtC,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;QACpD,IAAI,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ;KACzF,CAAC,CAAC;IACH,OAAO;QACL,EAAE,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QACrC,UAAU,EAAE,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC;QAC5C,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC;QAC/B,QAAQ,EAAE,sBAAsB,CAAC,KAAK,CAAC,QAAQ,CAAC;QAChD,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC;QACjC,UAAU,EAAE,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC;QAC5C,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;KACpC,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,mCAAmC,GAAG,KAAK,EACtD,QAAiB,EACO,EAAE,CAAC,WAAW,CACtC,8BAA8B,CAAC,sBAAsB,EACrD,8BAA8B,CAAC,QAAQ,CAAC,CACzC,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EAAE,QAAiB,EAAqB,EAAE;IAC3F,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,8BAA8B,CAAC,QAAQ,CAAC,CAAC;QACvD,OAAO,KAAK,CAAC,MAAM,KAAK,MAAM,mCAAmC,CAAC,KAAK,CAAC;YACtE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,gDAAgD,CAAC,CAAC;IAC9D,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,CAAC,8DAA8D,CAAC,CAAC;IAAC,CAAC;AACtF,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GAAG,CACpD,QAAiB,EACgB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAC9C,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;QACpD,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,oBAAoB;KAC7D,CAAC,CAAC;IACH,MAAM,IAAI,GAAG,EAAE,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;IAChG,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAClC,cAAc,CAAC,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,QAAQ,CAAC,CAAC;IACjE,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;QAC3B,cAAc,CAAC,KAAK,CAAC,kBAAkB,KAAK,IAAI,CAAC,CAAC;QAClD,OAAO,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;IAC1D,CAAC;IACD,OAAO,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,kBAAkB,EAAE,cAAc,CAAC,KAAK,CAAC,kBAAkB,CAAC,EAAE,CAAC;AAC9F,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAClD,QAAiB,EACc,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAC5C,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;QACpD,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ;KAC3F,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC1B,cAAc,CAAC,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC;IAC1D,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACpD,MAAM,YAAY,GAAG,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAC/F,gGAAgG;IAChG,cAAc,CAAC,KAAK,KAAK,QAAQ;QAC/B,CAAC,CAAC,YAAY,KAAK,IAAI;QACvB,CAAC,CAAC,YAAY,KAAK,IAAI,IAAI,YAAY,CAAC,UAAU,KAAK,CAAC,IAAI,UAAU,GAAG,CAAC,CAAC,CAAC;IAC9E,OAAO;QACL,EAAE,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QACrC,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC;QAC/B,UAAU;QACV,KAAK;QACL,YAAY;QACZ,UAAU,EAAE,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC;QAC5C,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;KACpC,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yCAAyC,GAAG,KAAK,EAC5D,QAAiB,EACO,EAAE,CAAC,WAAW,CACtC,8BAA8B,CAAC,4BAA4B,EAC3D,oCAAoC,CAAC,QAAQ,CAAC,CAC/C,CAAC;AAEF,MAAM,CAAC,MAAM,oCAAoC,GAAG,KAAK,EACvD,QAAiB,EACE,EAAE;IACrB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,oCAAoC,CAAC,QAAQ,CAAC,CAAC;QAC7D,OAAO,KAAK,CAAC,MAAM,KAAK,MAAM,yCAAyC,CAAC,KAAK,CAAC;YAC5E,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,uDAAuD,CAAC,CAAC;IACrE,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,CAAC,qEAAqE,CAAC,CAAC;IAAC,CAAC;AAC7F,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qDAAqD,GAAG,CACnE,QAAiB,EAC+B,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAC7D,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;QACpD,YAAY,EAAE,WAAW,EAAE,0BAA0B,EAAE,aAAa,EAAE,sBAAsB;KAC7F,CAAC,CAAC;IACH,OAAO;QACL,UAAU,EAAE,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC;QACvC,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QACrC,wBAAwB,EAAE,cAAc,CAAC,KAAK,CAAC,wBAAwB,CAAC;QACxE,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,WAAW,CAAC;QAChD,oBAAoB,EAAE,gBAAgB,CAAC,KAAK,CAAC,oBAAoB,CAAC;KACnE,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gDAAgD,GAAG,CAC9D,QAAiB,EAC0B,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACxD,MAAM,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;QACpD,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB;QACpF,SAAS,EAAE,YAAY,EAAE,QAAQ;KAClC,CAAC,CAAC;IACH,cAAc,CAAC,KAAK,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC;IACvC,OAAO;QACL,EAAE,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,UAAU,EAAE,CAAC;QACb,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;QACrC,UAAU,EAAE,gBAAgB,CAAC,KAAK,CAAC,UAAU,CAAC;QAC9C,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,WAAW,CAAC;QAChD,oBAAoB,EAAE,gBAAgB,CAAC,KAAK,CAAC,oBAAoB,CAAC;QAClE,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC;QACjC,UAAU,EAAE,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC;QAC5C,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;KACpC,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,qDAAqD,GAAG,KAAK,EACxE,QAAiB,EACO,EAAE,CAAC,WAAW,CACtC,8BAA8B,CAAC,8BAA8B,EAC7D,gDAAgD,CAAC,QAAQ,CAAC,CAC3D,CAAC;AAEF,MAAM,CAAC,MAAM,gDAAgD,GAAG,KAAK,EACnE,QAAiB,EACE,EAAE;IACrB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,gDAAgD,CAAC,QAAQ,CAAC,CAAC;QACzE,OAAO,KAAK,CAAC,MAAM,KAAK,MAAM,qDAAqD,CAAC,KAAK,CAAC;YACxF,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,oEAAoE,CAAC,CAAC;IAClF,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,kFAAkF,CAAC,CAAC;IAC9F,CAAC;AACH,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,iCAAiC,GAAG,CACxC,eAA0D,EAC1D,mBAAkD,EACzC,EAAE,CAAC,mBAAmB,CAAC,KAAK,KAAK,QAAQ;IAClD,CAAC,CAAC,YAAY,CAAC,eAAe,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;IACnF,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,KAAK,mBAAmB,CAAC,EAAE;WACrD,eAAe,CAAC,UAAU,CAAC,UAAU,KAAK,mBAAmB,CAAC,UAAU,GAAG,CAAC;WAC5E,YAAY,CAAC,mBAAmB,CAAC,YAAY,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAAC,CAAC;AAE3F;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,4CAA4C,GAAG,KAAK,EAC/D,eAAwB,EACxB,mBAA4B,EAC5B,uBAAgC,EAK/B,EAAE;IACH,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,gDAAgD,CAAC,eAAe,CAAC,CAAC;QACvF,MAAM,gBAAgB,GAAG,oCAAoC,CAAC,mBAAmB,CAAC,CAAC;QACnF,MAAM,oBAAoB,GAAG,wCAAwC,CAAC,uBAAuB,CAAC,CAAC;QAC/F,IAAI,CAAC,MAAM,gDAAgD,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM;eAC5E,CAAC,MAAM,oCAAoC,CAAC,gBAAgB,CAAC,CAAC,CAAC,MAAM;eACrE,CAAC,MAAM,wCAAwC,CAAC,oBAAoB,CAAC,CAAC,CAAC,MAAM;YAAE,IAAI,EAAE,CAAC;QAC3F,cAAc,CAAC,gBAAgB,CAAC,SAAS,KAAK,YAAY,CAAC,SAAS;eAC/D,oBAAoB,CAAC,SAAS,KAAK,YAAY,CAAC,SAAS;eACzD,iCAAiC,CAAC,YAAY,EAAE,gBAAgB,CAAC;eACjE,YAAY,CAAC,YAAY,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;eACzF,YAAY,CAAC,YAAY,CAAC,WAAW,EAAE,oBAAoB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;IAClE,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,IAAI,EAAE,CAAC;IAAC,CAAC;AAC5B,CAAC,CAAC"}

package/dist_ts/data/index.d.ts

@@ -3,6 +3,7 @@ export * from './cluster.js';
 export * from './clusterruntime.js';
 export * from './clustervpn.js';
 export * from './clusteringress.js';
+export * from './clusterrelaycredential.js';
 export * from './config.js';
 export * from './corestore.js';
 export * from './coremail.js';
@@ -52,6 +53,7 @@ export * from './baseos.js';
 export * from './backup.js';
 export * from './clusternode.js';
 export * from './settings.js';
+export * from './sparklegacyretirement.js';
 export * from './sparknodereport.js';
 export * from './service.js';
 export * from './servicecredential.js';

package/dist_ts/data/index.js

@@ -3,6 +3,7 @@ export * from './cluster.js';
 export * from './clusterruntime.js';
 export * from './clustervpn.js';
 export * from './clusteringress.js';
+export * from './clusterrelaycredential.js';
 export * from './config.js';
 export * from './corestore.js';
 export * from './coremail.js';
@@ -51,6 +52,7 @@ export * from './baseos.js';
 export * from './backup.js';
 export * from './clusternode.js';
 export * from './settings.js';
+export * from './sparklegacyretirement.js';
 export * from './sparknodereport.js';
 export * from './service.js';
 export * from './servicecredential.js';
@@ -62,4 +64,4 @@ export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/data/sparklegacyretirement.d.ts

@@ -0,0 +1,137 @@
+import type { IFleetCutoverAcceptedEvidenceReference } from './fleetcutover.js';
+import type { TSha256Digest } from './immutableimage.js';
+/** The two runtimes a released Spark could be put into by its `mode` configuration key. */
+export declare const sparkLegacyRuntimeModes: readonly ["cloudly", "coreflow-node"];
+export type TSparkLegacyRuntimeMode = typeof sparkLegacyRuntimeModes[number];
+/**
+ * Which Docker services a released mode owns, sorted, so a refusal names a mode instead of
+ * restating a set. A record over the mode union: a mode cannot be added without naming its
+ * services, and a reader can never meet a mode whose services it does not know.
+ */
+export declare const sparkLegacyRuntimeModeServices: Readonly<{
+    cloudly: readonly string[];
+    'coreflow-node': readonly string[];
+}>;
+/**
+ * Which verified Spark code is installed on one host and which systemd unit will boot it.
+ *
+ * Every member is read back from the installed tree and the installed unit file, never from the
+ * running process's own build constants: a build can state its own version, it cannot state that
+ * the host will start that same code again.
+ */
+export interface ISparkNodeBundleIdentity {
+    /** The installed bundle's release, exactly as its verified manifest names it. */
+    version: string;
+    /** The commit that manifest was built from, in the 40-hex form the manifest carries. */
+    sourceCommit: string;
+    /** The manifest digest the installed tree was verified against, in its bare 64-hex form. */
+    manifestSha256: string;
+    /** The systemd unit that starts this bundle at boot. */
+    unitName: string;
+    /** SHA-256 of the exact installed unit-file bytes. */
+    unitDigest: TSha256Digest;
+}
+/**
+ * The released key-value configuration source, by digest and disposition only.
+ *
+ * Never its bytes and never a decoded member: that file carries this node's released bearer and
+ * its jump code. `sourceSha256` covers the whole file, whose smallest unguessable part is a
+ * 256-bit token, so it identifies the file without stating anything that is in it.
+ */
+export interface ISparkLegacyConfigurationState {
+    /** The node's own monotonic counter; one accepted local disposition change advances it by one. */
+    ownerGeneration: number;
+    /** SHA-256 of the exact source bytes this node imported, once, under its fenced read. */
+    sourceSha256: string;
+    /** On disk and read by nothing, or unlinked. Erasure is not a cutover requirement. */
+    disposition: 'retained-inert' | 'removed';
+}
+/**
+ * What one node states about the released Spark runtime it is replacing, on one observation.
+ *
+ * Observed values and one statement the owner makes about its own behaviour. It names no node:
+ * Cloudly binds it to the reporter it already authenticated, so there is nothing to disagree
+ * with. It carries no digest of its own either, because the whole observation is digested by
+ * `computeSparkSwarmObservationDigest`.
+ */
+export interface ISparkLegacyRuntimeRetirement {
+    /** The released mode this process is configured in and no longer serves. */
+    refusedMode: TSparkLegacyRuntimeMode;
+    bundle: ISparkNodeBundleIdentity;
+    configuration: ISparkLegacyConfigurationState;
+}
+interface ISparkLegacyRetirementReceiptBase {
+    id: string;
+    generation: number;
+    previous: IFleetCutoverAcceptedEvidenceReference | null;
+    clusterId: string;
+    nodeId: string;
+    /** The accepted observation this was derived from; Cloudly read it, the node never named it. */
+    observation: IFleetCutoverAcceptedEvidenceReference;
+    reporterSessionId: string;
+    observationSequence: number;
+    acceptedAt: number;
+    digest: TSha256Digest;
+}
+/**
+ * Cloudly's accepted record that one node refuses its released owning mode.
+ *
+ * It is revisioned rather than written once: a node restates the refusal on every observation,
+ * and a bundle upgrade changes what the boot path is, which is a new fact about the same node.
+ */
+export interface ISparkLegacyModeRefusal extends ISparkLegacyRetirementReceiptBase {
+    refusedMode: TSparkLegacyRuntimeMode;
+    bundle: ISparkNodeBundleIdentity;
+}
+/**
+ * Cloudly's accepted record of one node's released configuration source at an exact generation.
+ *
+ * Two counters, deliberately: `generation` is contiguous because it is this record's own
+ * revision, while `configuration.ownerGeneration` is the node's and may skip — an observation
+ * that never arrived must not look like a skipped revision here.
+ */
+export interface ISparkLegacyConfigurationRetirement extends ISparkLegacyRetirementReceiptBase {
+    configuration: ISparkLegacyConfigurationState;
+}
+export declare const sparkLegacyRetirementContract: Readonly<{
+    readonly modeRefusalDigestDomain: "serve.zone/spark-legacy-mode-refusal";
+    readonly configurationRetirementDigestDomain: "serve.zone/spark-legacy-configuration-retirement";
+}>;
+/** Every reason Cloudly answers instead of advancing a node's legacy retirement state. */
+export declare const sparkLegacyRetirementRefusals: readonly ["legacy-retirement-generation-stale", "legacy-retirement-generation-conflict", "legacy-retirement-source-changed", "legacy-retirement-disposition-reversed", "legacy-retirement-bundle-below-minimum"];
+export type TSparkLegacyRetirementRefusal = typeof sparkLegacyRetirementRefusals[number];
+/** Structural copy only; whether the tree it describes is installed is the node's to observe. */
+export declare const snapshotSparkNodeBundleIdentity: (valueArg: unknown) => ISparkNodeBundleIdentity;
+export declare const snapshotSparkLegacyConfigurationState: (valueArg: unknown) => ISparkLegacyConfigurationState;
+export declare const snapshotSparkLegacyRuntimeRetirement: (valueArg: unknown) => ISparkLegacyRuntimeRetirement;
+/**
+ * Synchronous because the member carries no digest: the observation that transports it is
+ * digested as a whole, so a second domain here would only be a second thing to keep in step.
+ */
+export declare const validateSparkLegacyRuntimeRetirement: (valueArg: unknown) => string[];
+export declare const snapshotSparkLegacyModeRefusal: (valueArg: unknown) => ISparkLegacyModeRefusal;
+export declare const computeSparkLegacyModeRefusalDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateSparkLegacyModeRefusal: (valueArg: unknown) => Promise<string[]>;
+export declare const snapshotSparkLegacyConfigurationRetirement: (valueArg: unknown) => ISparkLegacyConfigurationRetirement;
+export declare const computeSparkLegacyConfigurationRetirementDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateSparkLegacyConfigurationRetirement: (valueArg: unknown) => Promise<string[]>;
+/**
+ * Whether one observed configuration state is a legal successor of the accepted one.
+ *
+ * `null` is a node's first accepted state. A replay states the accepted generation again and is
+ * therefore not an advance: it renews nothing, which is what keeps `acceptedAt` and the named
+ * observation from aging forward on a node that has stopped changing.
+ */
+export declare const advancesSparkLegacyConfigurationState: (currentArg: ISparkLegacyConfigurationState | null, nextArg: ISparkLegacyConfigurationState) => boolean;
+/**
+ * Joins the two accepted receipts a Coreflow retirement cites to the one observation they were
+ * derived from.
+ *
+ * Content join only. Whether each receipt is its node's current revision, and whether the
+ * observation it names is still fresh, remain Cloudly's to decide against its own records.
+ */
+export declare const bindSparkLegacyRetirement: (modeRefusalArg: unknown, configurationRetirementArg: unknown) => Promise<{
+    modeRefusal: ISparkLegacyModeRefusal;
+    configurationRetirement: ISparkLegacyConfigurationRetirement;
+}>;
+export {};