@serve.zone/interfaces 32.40.0 → 32.41.0

package/changelog.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 2026-10-02 - 32.41.0
+
+### Features
+
+- An administrator can export a cluster relay's bearer without an exec into Cloudly's process.
+  `exportClusterRelayAuthorization { identity, clusterId, expectedGeneration }` answers
+  `IClusterRelayAuthorizationExport`: the sealed relay credential at exactly that generation, the
+  bearer it delivered (`authorization`) and the audit `receipt` Cloudly writes before it answers.
+  Cloudly mints nothing to answer it; a new bearer is a `rotate` followed by an export.
+  `getClusterRelayAuthorizationExports { identity, clusterId }` answers the value-free receipts.
+  `data.clusterRelayAuthorizationExportRefusals` names the refusals, and
+  `bindClusterRelayAuthorizationExport`, `isClusterRelayAuthorization` and the exact-keyed
+  snapshots let a reader check an answer before it writes the bearer, without ever quoting it.
+
+## 2026-10-02 - 32.40.1
+
+### Fixes
+
+- Depend on `@push.rocks/smartcrypto` 3, which no longer ships node-forge, so consumers' production trees are free of node-forge advisory GHSA-86w9-cpqp-85rv (lenient RSA PKCS#1 v1.5 verification, no patched release). The contracts use only smartcrypto's X25519 envelope API, which is unchanged.
+
 ## 2026-10-02 - 32.40.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/clusterrelaycredential.d.ts

@@ -106,6 +106,50 @@ export interface IClusterLegacyRelayCredentialRetirementResult {
     /** A replay returns the recorded invalidation; nothing is revoked twice. */
     replayed: boolean;
 }
+/**
+ * What an administrator names to export one cluster's relay bearer: the cluster, at exactly the
+ * generation `getClusterRelayCredential` answered. Never a minimum: a rotation that committed
+ * after that read is refused rather than answered with a bearer the operator did not ask for.
+ */
+export interface IClusterRelayAuthorizationExportRequest {
+    clusterId: string;
+    expectedGeneration: number;
+}
+/**
+ * The audit record of one answered export, which Cloudly writes before it answers the bearer.
+ *
+ * Append-only and value-free: it names who received which credential's bearer and when, never
+ * the bearer or a hash of it. Every answered export writes one, so a retried export is a second
+ * receipt rather than a replay: each is a separate handover of the same bearer.
+ */
+export interface IClusterRelayAuthorizationExportReceipt {
+    id: string;
+    clusterId: string;
+    /** The exact relay credential whose bearer was answered: identity, generation and digest. */
+    credential: IRuntimeAuthorityReference;
+    /** The administrator the bearer was answered to, read from the verified credential. */
+    actorId: string;
+    exportedAt: number;
+}
+/**
+ * One cluster's relay bearer, answered to an administrator so it can be handed to the relay
+ * without reaching into Cloudly's process.
+ *
+ * The only member of this contract that carries a bearer. It is the delivered version the
+ * credential names, at the requested generation, proved against the hash that generation issued;
+ * Cloudly mints nothing to answer it. The reader owns the bytes: it writes them where the relay
+ * reads them and never logs, prints or persists them anywhere else.
+ */
+export interface IClusterRelayAuthorizationExport {
+    /** The relay credential the bearer authenticates as, at exactly the requested generation. */
+    credential: IClusterRelayCredential;
+    /**
+     * The bearer, byte for byte what the relay presents: `clusterRelayToken_`, the credential's
+     * 64-hex `id`, `_` and 64 hex characters, with no line terminator.
+     */
+    authorization: string;
+    receipt: IClusterRelayAuthorizationExportReceipt;
+}
 export declare const clusterRelayCredentialContract: Readonly<{
     readonly credentialDigestDomain: "serve.zone/cluster-relay-credential";
     readonly legacyCredentialDigestDomain: "serve.zone/cluster-relay-legacy-credential";
@@ -114,6 +158,12 @@ export declare const clusterRelayCredentialContract: Readonly<{
 /** 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];
+/**
+ * Every reason Cloudly answers instead of a relay bearer. Its own family, because an export
+ * changes no record: it has no `conflict`, and a generation it was not asked for is a mismatch.
+ */
+export declare const clusterRelayAuthorizationExportRefusals: readonly ["relay-credential-absent", "relay-credential-generation-mismatch", "relay-authorization-missing", "relay-authorization-ambiguous"];
+export type TClusterRelayAuthorizationExportRefusal = typeof clusterRelayAuthorizationExportRefusals[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>;
@@ -138,4 +188,26 @@ export declare const bindClusterLegacyRelayCredentialInvalidation: (invalidation
     legacyCredential: IClusterLegacyRelayCredential;
     acceptedRegistration: IClusterRelayAcceptedRegistration;
 }>;
+/**
+ * Whether a value has the exact shape of a relay bearer: `clusterRelayToken_<64 hex>_<64 hex>`.
+ *
+ * Shape only: whether it authenticates is Cloudly's to decide against the hash it keeps.
+ */
+export declare const isClusterRelayAuthorization: (valueArg: unknown) => valueArg is string;
+export declare const snapshotClusterRelayAuthorizationExportRequest: (valueArg: unknown) => IClusterRelayAuthorizationExportRequest;
+export declare const snapshotClusterRelayAuthorizationExportReceipt: (valueArg: unknown) => IClusterRelayAuthorizationExportReceipt;
+/**
+ * Structural copy of an export answer. A refusal never quotes the answer, because it carries a
+ * bearer: every failure is the contract's one value-free message.
+ */
+export declare const snapshotClusterRelayAuthorizationExport: (valueArg: unknown) => IClusterRelayAuthorizationExport;
+/**
+ * Joins an export answer to the request it answers, before a reader writes a byte of the bearer.
+ *
+ * The credential is sealed with its own digest and is the requested cluster's at exactly the
+ * requested generation; the bearer names that credential; the receipt names that cluster and that
+ * exact credential. Content join only: whether the bearer authenticates is Cloudly's to prove,
+ * and Cloudly proves it before it answers.
+ */
+export declare const bindClusterRelayAuthorizationExport: (exportArg: unknown, requestArg: unknown) => Promise<IClusterRelayAuthorizationExport>;
 export {};

package/dist_ts/data/clusterrelaycredential.js

@@ -22,6 +22,20 @@ export const clusterRelayCredentialRefusals = Object.freeze([
     /** An expected generation was not the exact current one, or a mutation ID met a changed body. */
     'conflict',
 ]);
+/**
+ * Every reason Cloudly answers instead of a relay bearer. Its own family, because an export
+ * changes no record: it has no `conflict`, and a generation it was not asked for is a mismatch.
+ */
+export const clusterRelayAuthorizationExportRefusals = Object.freeze([
+    /** No relay credential is minted for the cluster. */
+    'relay-credential-absent',
+    /** The credential is at another generation than the one named, before the read or after it. */
+    'relay-credential-generation-mismatch',
+    /** The version the credential delivered is not stored as an active version. */
+    'relay-authorization-missing',
+    /** The secret's active version, or its bytes, are not what the credential issued. */
+    'relay-authorization-ambiguous',
+]);
 const fail = () => { throw new Error('Cluster relay credential contract rejected.'); };
 const safe = (operationArg) => {
     try {
@@ -189,4 +203,71 @@ export const bindClusterLegacyRelayCredentialInvalidation = async (invalidationA
         return fail();
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusterrelaycredential.js","sourceRoot":"","sources":["../../ts/data/clusterrelaycredential.ts"],"names":[],"mappings":"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"}
+const clusterRelayAuthorizationPrefix = 'clusterRelayToken_';
+const clusterRelayAuthorizationPattern = /^clusterRelayToken_[a-f0-9]{64}_[a-f0-9]{64}$/;
+/**
+ * Whether a value has the exact shape of a relay bearer: `clusterRelayToken_<64 hex>_<64 hex>`.
+ *
+ * Shape only: whether it authenticates is Cloudly's to decide against the hash it keeps.
+ */
+export const isClusterRelayAuthorization = (valueArg) => typeof valueArg === 'string' && clusterRelayAuthorizationPattern.test(valueArg);
+/** The credential identity a relay bearer names: the 64 hex characters after its prefix. */
+const clusterRelayAuthorizationCredentialId = (authorizationArg) => authorizationArg.slice(clusterRelayAuthorizationPrefix.length, clusterRelayAuthorizationPrefix.length + 64);
+export const snapshotClusterRelayAuthorizationExportRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['clusterId', 'expectedGeneration']);
+    return {
+        clusterId: networkId(value.clusterId),
+        expectedGeneration: networkCounter(value.expectedGeneration),
+    };
+});
+export const snapshotClusterRelayAuthorizationExportReceipt = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), [
+        'id', 'clusterId', 'credential', 'actorId', 'exportedAt',
+    ]);
+    return {
+        id: networkId(value.id),
+        clusterId: networkId(value.clusterId),
+        credential: networkReference(value.credential),
+        actorId: networkId(value.actorId),
+        exportedAt: networkCounter(value.exportedAt),
+    };
+});
+/**
+ * Structural copy of an export answer. A refusal never quotes the answer, because it carries a
+ * bearer: every failure is the contract's one value-free message.
+ */
+export const snapshotClusterRelayAuthorizationExport = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['credential', 'authorization', 'receipt']);
+    requireNetwork(isClusterRelayAuthorization(value.authorization));
+    return {
+        credential: snapshotClusterRelayCredential(value.credential),
+        authorization: value.authorization,
+        receipt: snapshotClusterRelayAuthorizationExportReceipt(value.receipt),
+    };
+});
+/**
+ * Joins an export answer to the request it answers, before a reader writes a byte of the bearer.
+ *
+ * The credential is sealed with its own digest and is the requested cluster's at exactly the
+ * requested generation; the bearer names that credential; the receipt names that cluster and that
+ * exact credential. Content join only: whether the bearer authenticates is Cloudly's to prove,
+ * and Cloudly proves it before it answers.
+ */
+export const bindClusterRelayAuthorizationExport = async (exportArg, requestArg) => {
+    try {
+        const request = snapshotClusterRelayAuthorizationExportRequest(requestArg);
+        const answer = snapshotClusterRelayAuthorizationExport(exportArg);
+        if ((await validateClusterRelayCredential(answer.credential)).length)
+            fail();
+        requireNetwork(answer.credential.clusterId === request.clusterId
+            && answer.credential.generation === request.expectedGeneration
+            && clusterRelayAuthorizationCredentialId(answer.authorization) === answer.credential.id
+            && answer.receipt.clusterId === request.clusterId
+            && networkEqual(answer.receipt.credential, networkReferenceOf(answer.credential)));
+        return answer;
+    }
+    catch {
+        return fail();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusterrelaycredential.js","sourceRoot":"","sources":["../../ts/data/clusterrelaycredential.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/cluster.d.ts

@@ -170,6 +170,40 @@ export interface IReq_Admin_Cloudly_RetireLegacyClusterRelayCredential extends p
     };
     response: relayCredentialInterfaces.IClusterLegacyRelayCredentialRetirementResult;
 }
+/**
+ * Answers one cluster's relay bearer to an administrator, so it reaches the relay without an exec
+ * into Cloudly's process.
+ *
+ * Cloudly mints nothing here: a bearer is issued by `mutateClusterRelayCredential` and delivered as
+ * the encrypted version the credential names, and this reads exactly that version at exactly
+ * `expectedGeneration`, proved against the hash that generation issued. A new bearer is a
+ * rotation followed by an export at the new generation. Only the verified credential of a freshly
+ * authenticated administrator is read, as for a credential mutation, and Cloudly writes the
+ * `receipt` before it answers, so no bearer leaves without an audit record. The bearer is in this
+ * answer and nowhere else: never in a log, a receipt or another request. Cloudly refuses with one
+ * of `data.clusterRelayAuthorizationExportRefusals`.
+ */
+export interface IReq_Admin_Cloudly_ExportClusterRelayAuthorization extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_Cloudly_ExportClusterRelayAuthorization> {
+    method: 'exportClusterRelayAuthorization';
+    request: relayCredentialInterfaces.IClusterRelayAuthorizationExportRequest & {
+        identity: userInterfaces.IIdentityCredential;
+    };
+    response: relayCredentialInterfaces.IClusterRelayAuthorizationExport;
+}
+/**
+ * The audit trail of one cluster's relay bearer exports: every receipt, oldest first. Value-free,
+ * like the receipts themselves; empty while no bearer was ever exported.
+ */
+export interface IReq_Admin_Cloudly_GetClusterRelayAuthorizationExports extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_Cloudly_GetClusterRelayAuthorizationExports> {
+    method: 'getClusterRelayAuthorizationExports';
+    request: {
+        identity: userInterfaces.IIdentityCredential;
+        clusterId: string;
+    };
+    response: {
+        receipts: relayCredentialInterfaces.IClusterRelayAuthorizationExportReceipt[];
+    };
+}
 /**
  * Cloudly hands the cluster relay the DNS lease renewals it has signed ahead of time for one node.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.40.0",
+  "version": "32.41.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -22,7 +22,7 @@
   "license": "MIT",
   "dependencies": {
     "@api.global/typedrequest-interfaces": "^7.1.0",
-    "@push.rocks/smartcrypto": "^2.2.0",
+    "@push.rocks/smartcrypto": "^3.0.0",
     "@push.rocks/smartlog": "^4.0.0",
     "@tsclass/tsclass": "^9.5.1"
   },

package/readme.md

@@ -2723,8 +2723,9 @@ cluster authority every cluster-side component used before it. `IClusterRelayCre
 metadata: the cluster, a `generation` that advances by one per accepted mint or rotation, the
 machine `userId` it authenticates as, and `delivery`, the `ISecretVersionReference` of the
 immutable encrypted version the bearer was delivered as. No record, receipt, request or response
-of this contract carries a bearer, a hash or key material, and every reader is exact-keyed, so a
-peer that adds a secret-looking member is refused rather than copied.
+of this contract carries a bearer, a hash or key material, except the one answer that exists to
+hand the bearer over (see the export below), and every reader is exact-keyed, so a peer that adds
+a secret-looking member is refused rather than copied.
 
 The credential authenticates the cluster's whole control-plane session, exactly what the shared
 authority authenticated, so a relay changes one credential and keeps every call it makes. The gain
@@ -2776,7 +2777,36 @@ it names or that record's revoked successor — and to a registration whose `cre
 invalidation's `replacement`. It is a content check; dereferencing each record as current and
 requiring the live socket remain Cloudly's.
 
-All three requests read only the verified `IIdentityCredential`, never an identity member a caller
+`exportClusterRelayAuthorization { identity, clusterId, expectedGeneration }` answers the bearer
+itself, so an operator hands it to the relay without an exec into Cloudly's process. Cloudly mints
+nothing to answer it: the bearer is the encrypted version the credential's `delivery` names, read
+at exactly `expectedGeneration` (never a minimum) and proved against the hash that generation
+issued, so a rotation committing meanwhile is refused rather than answered. A new bearer is a
+`rotate` followed by an export at the new generation. It requires a freshly authenticated
+administrator, exactly as a credential mutation does. `IClusterRelayAuthorizationExport` carries
+the sealed `credential` at that generation, the `authorization` (the bearer, byte for byte what the
+relay presents: `clusterRelayToken_<credential id>_<64 hex>`, no line terminator) and the
+`receipt`. It is the only answer of this contract that carries a bearer; Cloudly never logs it, and
+its reader writes it where the relay reads it and nowhere else.
+
+Every answered export is audited: Cloudly writes `IClusterRelayAuthorizationExportReceipt`
+(`id`, `clusterId`, the exact `credential` reference, the administrator's `actorId`,
+`exportedAt`) before it answers, so no bearer leaves without a record, and a retried export is a
+second receipt rather than a replay. A receipt is value-free: no bearer, no hash.
+`getClusterRelayAuthorizationExports { identity, clusterId }` answers a cluster's receipts, oldest
+first. Refusals are `data.clusterRelayAuthorizationExportRefusals`
+(`data.TClusterRelayAuthorizationExportRefusal`): `relay-credential-absent`,
+`relay-credential-generation-mismatch`, `relay-authorization-missing` and
+`relay-authorization-ambiguous`. A reader checks an answer with
+`bindClusterRelayAuthorizationExport(answer, { clusterId, expectedGeneration })` before it writes a
+byte: the credential's digest holds, it is the requested cluster's at the requested generation, the
+bearer names that credential, and the receipt names that exact credential. Every refusal is the
+contract's one value-free message and never quotes the answer. `isClusterRelayAuthorization`
+states the bearer's shape, and `snapshotClusterRelayAuthorizationExportRequest`,
+`snapshotClusterRelayAuthorizationExportReceipt` and `snapshotClusterRelayAuthorizationExport` are
+the exact-keyed readers.
+
+All five requests read only the verified `IIdentityCredential`, never an identity member a caller
 states about itself.
 
 ### Spark Legacy Runtime Retirement

package/ts/00_commitinfo_data.ts

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

package/ts/data/clusterrelaycredential.ts

@@ -128,6 +128,53 @@ export interface IClusterLegacyRelayCredentialRetirementResult {
   replayed: boolean;
 }
 
+/**
+ * What an administrator names to export one cluster's relay bearer: the cluster, at exactly the
+ * generation `getClusterRelayCredential` answered. Never a minimum: a rotation that committed
+ * after that read is refused rather than answered with a bearer the operator did not ask for.
+ */
+export interface IClusterRelayAuthorizationExportRequest {
+  clusterId: string;
+  expectedGeneration: number;
+}
+
+/**
+ * The audit record of one answered export, which Cloudly writes before it answers the bearer.
+ *
+ * Append-only and value-free: it names who received which credential's bearer and when, never
+ * the bearer or a hash of it. Every answered export writes one, so a retried export is a second
+ * receipt rather than a replay: each is a separate handover of the same bearer.
+ */
+export interface IClusterRelayAuthorizationExportReceipt {
+  id: string;
+  clusterId: string;
+  /** The exact relay credential whose bearer was answered: identity, generation and digest. */
+  credential: IRuntimeAuthorityReference;
+  /** The administrator the bearer was answered to, read from the verified credential. */
+  actorId: string;
+  exportedAt: number;
+}
+
+/**
+ * One cluster's relay bearer, answered to an administrator so it can be handed to the relay
+ * without reaching into Cloudly's process.
+ *
+ * The only member of this contract that carries a bearer. It is the delivered version the
+ * credential names, at the requested generation, proved against the hash that generation issued;
+ * Cloudly mints nothing to answer it. The reader owns the bytes: it writes them where the relay
+ * reads them and never logs, prints or persists them anywhere else.
+ */
+export interface IClusterRelayAuthorizationExport {
+  /** The relay credential the bearer authenticates as, at exactly the requested generation. */
+  credential: IClusterRelayCredential;
+  /**
+   * The bearer, byte for byte what the relay presents: `clusterRelayToken_`, the credential's
+   * 64-hex `id`, `_` and 64 hex characters, with no line terminator.
+   */
+  authorization: string;
+  receipt: IClusterRelayAuthorizationExportReceipt;
+}
+
 export const clusterRelayCredentialContract = Object.freeze({
   credentialDigestDomain: 'serve.zone/cluster-relay-credential',
   legacyCredentialDigestDomain: 'serve.zone/cluster-relay-legacy-credential',
@@ -154,6 +201,24 @@ export const clusterRelayCredentialRefusals = Object.freeze([
 
 export type TClusterRelayCredentialRefusal = typeof clusterRelayCredentialRefusals[number];
 
+/**
+ * Every reason Cloudly answers instead of a relay bearer. Its own family, because an export
+ * changes no record: it has no `conflict`, and a generation it was not asked for is a mismatch.
+ */
+export const clusterRelayAuthorizationExportRefusals = Object.freeze([
+  /** No relay credential is minted for the cluster. */
+  'relay-credential-absent',
+  /** The credential is at another generation than the one named, before the read or after it. */
+  'relay-credential-generation-mismatch',
+  /** The version the credential delivered is not stored as an active version. */
+  'relay-authorization-missing',
+  /** The secret's active version, or its bytes, are not what the credential issued. */
+  'relay-authorization-ambiguous',
+] as const);
+
+export type TClusterRelayAuthorizationExportRefusal =
+  typeof clusterRelayAuthorizationExportRefusals[number];
+
 const fail = (): never => { throw new Error('Cluster relay credential contract rejected.'); };
 const safe = <T>(operationArg: () => T): T => {
   try { return operationArg(); } catch { return fail(); }
@@ -359,3 +424,87 @@ export const bindClusterLegacyRelayCredentialInvalidation = async (
     return { invalidation, legacyCredential, acceptedRegistration };
   } catch { return fail(); }
 };
+
+const clusterRelayAuthorizationPrefix = 'clusterRelayToken_';
+const clusterRelayAuthorizationPattern = /^clusterRelayToken_[a-f0-9]{64}_[a-f0-9]{64}$/;
+
+/**
+ * Whether a value has the exact shape of a relay bearer: `clusterRelayToken_<64 hex>_<64 hex>`.
+ *
+ * Shape only: whether it authenticates is Cloudly's to decide against the hash it keeps.
+ */
+export const isClusterRelayAuthorization = (valueArg: unknown): valueArg is string =>
+  typeof valueArg === 'string' && clusterRelayAuthorizationPattern.test(valueArg);
+
+/** The credential identity a relay bearer names: the 64 hex characters after its prefix. */
+const clusterRelayAuthorizationCredentialId = (authorizationArg: string): string =>
+  authorizationArg.slice(
+    clusterRelayAuthorizationPrefix.length,
+    clusterRelayAuthorizationPrefix.length + 64,
+  );
+
+export const snapshotClusterRelayAuthorizationExportRequest = (
+  valueArg: unknown,
+): IClusterRelayAuthorizationExportRequest => safe(() => {
+  const value = networkRecord(captureNetwork(valueArg), ['clusterId', 'expectedGeneration']);
+  return {
+    clusterId: networkId(value.clusterId),
+    expectedGeneration: networkCounter(value.expectedGeneration),
+  };
+});
+
+export const snapshotClusterRelayAuthorizationExportReceipt = (
+  valueArg: unknown,
+): IClusterRelayAuthorizationExportReceipt => safe(() => {
+  const value = networkRecord(captureNetwork(valueArg), [
+    'id', 'clusterId', 'credential', 'actorId', 'exportedAt',
+  ]);
+  return {
+    id: networkId(value.id),
+    clusterId: networkId(value.clusterId),
+    credential: networkReference(value.credential),
+    actorId: networkId(value.actorId),
+    exportedAt: networkCounter(value.exportedAt),
+  };
+});
+
+/**
+ * Structural copy of an export answer. A refusal never quotes the answer, because it carries a
+ * bearer: every failure is the contract's one value-free message.
+ */
+export const snapshotClusterRelayAuthorizationExport = (
+  valueArg: unknown,
+): IClusterRelayAuthorizationExport => safe(() => {
+  const value = networkRecord(captureNetwork(valueArg), ['credential', 'authorization', 'receipt']);
+  requireNetwork(isClusterRelayAuthorization(value.authorization));
+  return {
+    credential: snapshotClusterRelayCredential(value.credential),
+    authorization: value.authorization,
+    receipt: snapshotClusterRelayAuthorizationExportReceipt(value.receipt),
+  };
+});
+
+/**
+ * Joins an export answer to the request it answers, before a reader writes a byte of the bearer.
+ *
+ * The credential is sealed with its own digest and is the requested cluster's at exactly the
+ * requested generation; the bearer names that credential; the receipt names that cluster and that
+ * exact credential. Content join only: whether the bearer authenticates is Cloudly's to prove,
+ * and Cloudly proves it before it answers.
+ */
+export const bindClusterRelayAuthorizationExport = async (
+  exportArg: unknown,
+  requestArg: unknown,
+): Promise<IClusterRelayAuthorizationExport> => {
+  try {
+    const request = snapshotClusterRelayAuthorizationExportRequest(requestArg);
+    const answer = snapshotClusterRelayAuthorizationExport(exportArg);
+    if ((await validateClusterRelayCredential(answer.credential)).length) fail();
+    requireNetwork(answer.credential.clusterId === request.clusterId
+      && answer.credential.generation === request.expectedGeneration
+      && clusterRelayAuthorizationCredentialId(answer.authorization) === answer.credential.id
+      && answer.receipt.clusterId === request.clusterId
+      && networkEqual(answer.receipt.credential, networkReferenceOf(answer.credential)));
+    return answer;
+  } catch { return fail(); }
+};

package/ts/requests/cluster.ts

@@ -219,6 +219,50 @@ extends plugins.typedrequestInterfaces.implementsTR<
   response: relayCredentialInterfaces.IClusterLegacyRelayCredentialRetirementResult;
 }
 
+/**
+ * Answers one cluster's relay bearer to an administrator, so it reaches the relay without an exec
+ * into Cloudly's process.
+ *
+ * Cloudly mints nothing here: a bearer is issued by `mutateClusterRelayCredential` and delivered as
+ * the encrypted version the credential names, and this reads exactly that version at exactly
+ * `expectedGeneration`, proved against the hash that generation issued. A new bearer is a
+ * rotation followed by an export at the new generation. Only the verified credential of a freshly
+ * authenticated administrator is read, as for a credential mutation, and Cloudly writes the
+ * `receipt` before it answers, so no bearer leaves without an audit record. The bearer is in this
+ * answer and nowhere else: never in a log, a receipt or another request. Cloudly refuses with one
+ * of `data.clusterRelayAuthorizationExportRefusals`.
+ */
+export interface IReq_Admin_Cloudly_ExportClusterRelayAuthorization
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_Cloudly_ExportClusterRelayAuthorization
+> {
+  method: 'exportClusterRelayAuthorization';
+  request: relayCredentialInterfaces.IClusterRelayAuthorizationExportRequest & {
+    identity: userInterfaces.IIdentityCredential;
+  };
+  response: relayCredentialInterfaces.IClusterRelayAuthorizationExport;
+}
+
+/**
+ * The audit trail of one cluster's relay bearer exports: every receipt, oldest first. Value-free,
+ * like the receipts themselves; empty while no bearer was ever exported.
+ */
+export interface IReq_Admin_Cloudly_GetClusterRelayAuthorizationExports
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_Cloudly_GetClusterRelayAuthorizationExports
+> {
+  method: 'getClusterRelayAuthorizationExports';
+  request: {
+    identity: userInterfaces.IIdentityCredential;
+    clusterId: string;
+  };
+  response: {
+    receipts: relayCredentialInterfaces.IClusterRelayAuthorizationExportReceipt[];
+  };
+}
+
 /**
  * Cloudly hands the cluster relay the DNS lease renewals it has signed ahead of time for one node.
  *