@serve.zone/interfaces 32.15.0 → 32.17.0

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDIn0=

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 {};

package/dist_ts/data/sparklegacyretirement.js

@@ -0,0 +1,206 @@
+import { isReleaseVersion } from '../private/releaseversion.js';
+import { captureNetwork, networkCounter, networkDigest, networkEqual, networkHash, networkId, networkNodeId, networkRecord, networkReference, networkRevision, requireNetwork, } from '../private/networkcontract.js';
+/** The two runtimes a released Spark could be put into by its `mode` configuration key. */
+export const sparkLegacyRuntimeModes = ['cloudly', 'coreflow-node'];
+/**
+ * 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 const sparkLegacyRuntimeModeServices = Object.freeze({
+    'cloudly': Object.freeze(['cloudly']),
+    'coreflow-node': Object.freeze(['coreflow', 'corestore', 'coretraffic']),
+});
+export const sparkLegacyRetirementContract = Object.freeze({
+    modeRefusalDigestDomain: 'serve.zone/spark-legacy-mode-refusal',
+    configurationRetirementDigestDomain: 'serve.zone/spark-legacy-configuration-retirement',
+});
+/** Every reason Cloudly answers instead of advancing a node's legacy retirement state. */
+export const sparkLegacyRetirementRefusals = Object.freeze([
+    /** The observed owner generation is below the accepted one. */
+    'legacy-retirement-generation-stale',
+    /** The observed owner generation equals the accepted one and states something else. */
+    'legacy-retirement-generation-conflict',
+    /** A node imported one source once; another source digest describes another host. */
+    'legacy-retirement-source-changed',
+    /** A removed source cannot become a retained one. */
+    'legacy-retirement-disposition-reversed',
+    /** The stated bundle is below the release whose refusal this server accepts as real. */
+    'legacy-retirement-bundle-below-minimum',
+]);
+const fail = () => { throw new Error('Spark legacy retirement contract rejected.'); };
+const safe = (operationArg) => {
+    try {
+        return operationArg();
+    }
+    catch {
+        return fail();
+    }
+};
+const sha256Hex = (valueArg) => {
+    requireNetwork(typeof valueArg === 'string' && /^[a-f0-9]{64}$/.test(valueArg));
+    return valueArg;
+};
+const sourceCommit = (valueArg) => {
+    requireNetwork(typeof valueArg === 'string' && /^[a-f0-9]{40}$/.test(valueArg));
+    return valueArg;
+};
+const releaseVersion = (valueArg) => {
+    requireNetwork(isReleaseVersion(valueArg));
+    return valueArg;
+};
+const legacyRuntimeMode = (valueArg) => {
+    requireNetwork(sparkLegacyRuntimeModes.includes(valueArg));
+    return valueArg;
+};
+const configurationDisposition = (valueArg) => {
+    requireNetwork(valueArg === 'retained-inert' || valueArg === 'removed');
+    return valueArg;
+};
+/** Structural copy only; whether the tree it describes is installed is the node's to observe. */
+export const snapshotSparkNodeBundleIdentity = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'version', 'sourceCommit', 'manifestSha256', 'unitName', 'unitDigest',
+    ]);
+    return {
+        version: releaseVersion(value.version),
+        sourceCommit: sourceCommit(value.sourceCommit),
+        manifestSha256: sha256Hex(value.manifestSha256),
+        unitName: networkId(value.unitName),
+        unitDigest: networkDigest(value.unitDigest),
+    };
+});
+export const snapshotSparkLegacyConfigurationState = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'ownerGeneration', 'sourceSha256', 'disposition',
+    ]);
+    return {
+        ownerGeneration: networkCounter(value.ownerGeneration),
+        sourceSha256: sha256Hex(value.sourceSha256),
+        disposition: configurationDisposition(value.disposition),
+    };
+});
+export const snapshotSparkLegacyRuntimeRetirement = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'refusedMode', 'bundle', 'configuration',
+    ]);
+    return {
+        refusedMode: legacyRuntimeMode(value.refusedMode),
+        bundle: snapshotSparkNodeBundleIdentity(value.bundle),
+        configuration: snapshotSparkLegacyConfigurationState(value.configuration),
+    };
+});
+/**
+ * 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 const validateSparkLegacyRuntimeRetirement = (valueArg) => {
+    try {
+        snapshotSparkLegacyRuntimeRetirement(valueArg);
+        return [];
+    }
+    catch {
+        return ['Spark legacy runtime retirement must use its exact canonical schema'];
+    }
+};
+/** The revision rule every accepted receipt of this contract obeys, read once for both of them. */
+const retirementReceiptBase = (valueArg, ownKeysArg) => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'generation', 'previous', 'clusterId', 'nodeId', 'observation', 'reporterSessionId',
+        'observationSequence', 'acceptedAt', 'digest',
+        ...ownKeysArg,
+    ]);
+    const { id, generation, previous } = networkRevision(value);
+    return {
+        base: {
+            id,
+            generation,
+            previous,
+            clusterId: networkId(value.clusterId),
+            nodeId: networkNodeId(value.nodeId),
+            observation: networkReference(value.observation),
+            reporterSessionId: networkId(value.reporterSessionId),
+            observationSequence: networkCounter(value.observationSequence),
+            acceptedAt: networkCounter(value.acceptedAt),
+            digest: networkDigest(value.digest),
+        },
+        record: value,
+    };
+};
+export const snapshotSparkLegacyModeRefusal = (valueArg) => safe(() => {
+    const { base, record } = retirementReceiptBase(valueArg, ['refusedMode', 'bundle']);
+    return {
+        ...base,
+        refusedMode: legacyRuntimeMode(record.refusedMode),
+        bundle: snapshotSparkNodeBundleIdentity(record.bundle),
+    };
+});
+export const computeSparkLegacyModeRefusalDigest = async (valueArg) => networkHash(sparkLegacyRetirementContract.modeRefusalDigestDomain, snapshotSparkLegacyModeRefusal(valueArg));
+export const validateSparkLegacyModeRefusal = async (valueArg) => {
+    try {
+        const value = snapshotSparkLegacyModeRefusal(valueArg);
+        return value.digest === await computeSparkLegacyModeRefusalDigest(value)
+            ? [] : ['Spark legacy mode refusal digest does not match'];
+    }
+    catch {
+        return ['Spark legacy mode refusal must use its exact canonical schema'];
+    }
+};
+export const snapshotSparkLegacyConfigurationRetirement = (valueArg) => safe(() => {
+    const { base, record } = retirementReceiptBase(valueArg, ['configuration']);
+    return { ...base, configuration: snapshotSparkLegacyConfigurationState(record.configuration) };
+});
+export const computeSparkLegacyConfigurationRetirementDigest = async (valueArg) => networkHash(sparkLegacyRetirementContract.configurationRetirementDigestDomain, snapshotSparkLegacyConfigurationRetirement(valueArg));
+export const validateSparkLegacyConfigurationRetirement = async (valueArg) => {
+    try {
+        const value = snapshotSparkLegacyConfigurationRetirement(valueArg);
+        return value.digest === await computeSparkLegacyConfigurationRetirementDigest(value)
+            ? [] : ['Spark legacy configuration retirement digest does not match'];
+    }
+    catch {
+        return ['Spark legacy configuration retirement must use its exact canonical schema'];
+    }
+};
+/**
+ * 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 const advancesSparkLegacyConfigurationState = (currentArg, nextArg) => {
+    const next = snapshotSparkLegacyConfigurationState(nextArg);
+    if (currentArg === null)
+        return true;
+    if (next.sourceSha256 !== currentArg.sourceSha256)
+        return false;
+    if (next.ownerGeneration <= currentArg.ownerGeneration)
+        return false;
+    return !(currentArg.disposition === 'removed' && next.disposition !== 'removed');
+};
+/**
+ * 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 const bindSparkLegacyRetirement = async (modeRefusalArg, configurationRetirementArg) => {
+    try {
+        const modeRefusal = snapshotSparkLegacyModeRefusal(modeRefusalArg);
+        const configurationRetirement = snapshotSparkLegacyConfigurationRetirement(configurationRetirementArg);
+        if ((await validateSparkLegacyModeRefusal(modeRefusal)).length
+            || (await validateSparkLegacyConfigurationRetirement(configurationRetirement)).length)
+            fail();
+        requireNetwork(modeRefusal.clusterId === configurationRetirement.clusterId
+            && modeRefusal.nodeId === configurationRetirement.nodeId
+            && modeRefusal.reporterSessionId === configurationRetirement.reporterSessionId
+            && modeRefusal.observationSequence === configurationRetirement.observationSequence
+            && networkEqual(modeRefusal.observation, configurationRetirement.observation));
+        return { modeRefusal, configurationRetirement };
+    }
+    catch {
+        return fail();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparklegacyretirement.js","sourceRoot":"","sources":["../../ts/data/sparklegacyretirement.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/cluster.d.ts

@@ -1,5 +1,6 @@
 import * as userInterfaces from '../data/user.js';
 import * as clusterInterfaces from '../data/cluster.js';
+import type * as relayCredentialInterfaces from '../data/clusterrelaycredential.js';
 import type * as clusterVpnInterfaces from '../data/clustervpn.js';
 import type { IClusterRuntime, TClusterRuntimeBlocker } from '../data/clusterruntime.js';
 import type { IServiceRuntimeAssignmentView } from '../data/serviceruntime.js';
@@ -116,6 +117,59 @@ export interface IReq_Relay_Cloudly_RegisterClusterRelay extends plugins.typedre
     request: clusterInterfaces.IRegisterClusterRelayRequest;
     response: clusterInterfaces.IRegisterClusterRelayResponse;
 }
+/**
+ * Mints a cluster's relay credential, or rotates it at its exact current generation.
+ *
+ * Only the verified credential is read from the caller: a credential mutation trusts no identity
+ * member a caller states about itself. The bearer is never in the answer; it is delivered as the
+ * encrypted secret version `credential.delivery` names. The first mint also records the shared
+ * authority the cluster still carries, so a replacement never exists without a named predecessor.
+ * Cloudly refuses with one of `data.clusterRelayCredentialRefusals`.
+ */
+export interface IReq_Admin_Cloudly_MutateClusterRelayCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_Cloudly_MutateClusterRelayCredential> {
+    method: 'mutateClusterRelayCredential';
+    request: {
+        identity: userInterfaces.IIdentityCredential;
+        mutation: relayCredentialInterfaces.TClusterRelayCredentialMutation;
+    };
+    response: relayCredentialInterfaces.IClusterRelayCredentialMutationResult;
+}
+/**
+ * One cluster's relay authority chain as Cloudly records it: the relay credential, the shared
+ * authority it replaces and the current accepted registration, each `null` while no record exists.
+ *
+ * Liveness is not here. It is a fact of a socket, which `getClusterRelayRegistrations` answers and
+ * which Cloudly checks for itself before it accepts a retirement.
+ */
+export interface IReq_Any_Cloudly_GetClusterRelayCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetClusterRelayCredential> {
+    method: 'getClusterRelayCredential';
+    request: {
+        identity: userInterfaces.IIdentityCredential;
+        clusterId: string;
+    };
+    response: {
+        credential: relayCredentialInterfaces.IClusterRelayCredential | null;
+        legacy: relayCredentialInterfaces.IClusterLegacyRelayCredential | null;
+        registration: clusterInterfaces.IClusterRelayAcceptedRegistration | null;
+    };
+}
+/**
+ * Revokes a cluster's shared pre-relay authority, which is the last step of replacing it.
+ *
+ * Its own request rather than a mutation of the relay credential, because it is the one step that
+ * removes authority: Cloudly accepts it only while the named replacement is the current relay
+ * credential, the named registration is current and was made under that replacement, and a
+ * verified socket carries that registration. Every other answer is one of
+ * `data.clusterRelayCredentialRefusals`.
+ */
+export interface IReq_Admin_Cloudly_RetireLegacyClusterRelayCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_Cloudly_RetireLegacyClusterRelayCredential> {
+    method: 'retireLegacyClusterRelayCredential';
+    request: {
+        identity: userInterfaces.IIdentityCredential;
+        retirement: relayCredentialInterfaces.IClusterLegacyRelayCredentialRetirementRequest;
+    };
+    response: relayCredentialInterfaces.IClusterLegacyRelayCredentialRetirementResult;
+}
 /**
  * Cloudly hands the cluster relay the DNS lease renewals it has signed ahead of time for one node.
  *

package/dist_ts/requests/cluster.js

@@ -1,4 +1,4 @@
 import * as userInterfaces from '../data/user.js';
 import * as clusterInterfaces from '../data/cluster.js';
 import * as plugins from '../plugins.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2x1c3Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3JlcXVlc3RzL2NsdXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLGNBQWMsTUFBTSxpQkFBaUIsQ0FBQztBQUNsRCxPQUFPLEtBQUssaUJBQWlCLE1BQU0sb0JBQW9CLENBQUM7QUFLeEQsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2x1c3Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3JlcXVlc3RzL2NsdXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLGNBQWMsTUFBTSxpQkFBaUIsQ0FBQztBQUNsRCxPQUFPLEtBQUssaUJBQWlCLE1BQU0sb0JBQW9CLENBQUM7QUFNeEQsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.15.0",
+  "version": "32.17.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {