@serve.zone/interfaces 32.40.1 → 32.42.0

package/changelog.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 2026-10-02 - 32.42.0
+
+### Features
+
+- A cluster topology change no longer ends every node's managed VPN membership. The new
+  `continuesRuntimeNetworkProtection(previous, next)` states which protected-authority successor
+  only adds: the same authority, or exactly its next step that keeps every egress owner, pool,
+  resolver and platform endpoint unchanged and still covers every protected address.
+  `continuesRuntimeManagedVpnMembership` and `bindGetRuntimeManagedVpnCredentialSuccessor` accept
+  such a step where they required the same authority, so a node joining the egress or a cluster
+  hub joining the platform endpoints keeps each member's key pair and hub session. A step that
+  removes or changes anything, or skips a step, still ends the membership, and every egress owner
+  still acknowledges the new authority with its own protection receipt before an allocation binds
+  to it.
+- An administrator can store the Corestore control token without an exec into Cloudly's process.
+  `requests.corestorecontrol.IReq_Admin_Cloudly_SetCorestoreControlToken`
+  (`setCorestoreControlToken { identity, token, expected }`) stores it for both Corestore provider
+  configs, fenced on the exact `data.TCorestoreControlTokenState` the administrator last read
+  (absent, or present at a revision), and answers the produced state and a value-free receipt
+  Cloudly writes with the token. `IReq_Admin_Cloudly_GetCorestoreControlTokenState` answers the
+  state and its most recent receipts. `data.corestoreControlTokenSetRefusals` names the refusals;
+  `bindCorestoreControlTokenSet` and the exact-keyed snapshots check an answer without ever
+  quoting the token, and the request reader admits only a token `isCorestoreControlToken` admits.
+- An egress owner can now leave the protected authority. `IRuntimeNetworkEgressRetirement` is the
+  controller-owned fence for one owner, recorded against the exact authority it leaves: its node
+  retirement row, both node credentials revoked, every DNS and managed VPN window it was issued
+  ended, every handoff and workload lease quarantined, and every remaining owner's acknowledged
+  projection head free of its endpoints. `snapshotRuntimeNetworkEgressRetirement` reads it with exact
+  keys and `computeRuntimeNetworkEgressRetirementDigest` seals it.
+  `bindRuntimeNetworkProtectedAuthorityRetirement(previous, next, fences, retiredOwners)` is the pure,
+  fail-closed successor rule: an owner may be absent from `next` only behind a fence bound to the
+  exact `previous`, a fence for an owner still named refuses the step, a fenced owner never returns,
+  and pools, prefix coverage and — when an owner leaves — resolvers are kept. Owners may join in the
+  same step. Before this, an owner that left blocked every new allocation after the next protection
+  change, permanently.
+- `INodeRuntimeRetirement` states its `disposition` (`withdrawn` or `lost`,
+  `nodeRuntimeRetirementDispositions`, `snapshotNodeRuntimeRetirementDisposition`), and
+  `retireClusterNode` takes an optional `disposition`: absent asks for `withdrawn`, the retirement
+  it always described, and `lost` escalates a `withdrawn` retirement still `retiring`. The new
+  refusal `node-still-reporting` refuses `lost` for a node that still reports. Cloudly serves
+  neither yet, so no stored row or caller is affected.
+
+### Fixes
+
+- Require `@push.rocks/smartlog` ^4.0.3, which reaches `@push.rocks/smartcrypto` 3 and no longer brings `node-forge` (advisory GHSA-86w9-cpqp-85rv, no patched release) into consumers' production trees.
+
+### Maintenance
+
+- Release tooling: `@git.zone/tsbuild` 5.1.1 and pnpm 12.7.0.
+
+## 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

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '32.40.1',
+    version: '32.42.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/data/corestorecontroltoken.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Whether Cloudly holds the Corestore control token, and at which revision. Value-free.
+ *
+ * There is one token for both Corestore provider configs, so this is one state rather than one per
+ * provider. `revision` is 1 for the first token ever stored and advances by exactly one with every
+ * accepted set, whichever path set it. No request removes a token, so a present token never turns
+ * absent again.
+ */
+export type TCorestoreControlTokenState = {
+    state: 'absent';
+} | {
+    state: 'present';
+    revision: number;
+};
+/**
+ * What an administrator names to store the Corestore control token: the token, and the state the
+ * administrator last read. Never a minimum: a set that committed after that read is refused rather
+ * than overwritten.
+ *
+ * `token` is the secret itself, the only member of this contract that carries it. A sender never
+ * logs, hooks or persists the request; Cloudly never answers or records the token.
+ */
+export interface ICorestoreControlTokenSetRequest {
+    token: string;
+    expected: TCorestoreControlTokenState;
+}
+/**
+ * Which path stored a token: an administrator's typed request, or the `secrets
+ * set-corestore-control-token` command run inside Cloudly's container.
+ */
+export type TCorestoreControlTokenSetPath = 'admin-request' | 'container-cli';
+/**
+ * The audit record of one accepted set, which Cloudly writes in the transaction that stores the
+ * token. Append-only and value-free: it names which revision was stored, by whom, how and when,
+ * never the token or a hash of it.
+ */
+export interface ICorestoreControlTokenSetReceipt {
+    id: string;
+    /** The revision this set stored. */
+    revision: number;
+    via: TCorestoreControlTokenSetPath;
+    /** The administrator read from the verified credential, or `operator:secrets-cli`. */
+    actorId: string;
+    setAt: number;
+}
+/** What Cloudly answers to an accepted set: the state it produced and its receipt. Value-free. */
+export interface ICorestoreControlTokenSetResult {
+    state: {
+        state: 'present';
+        revision: number;
+    };
+    receipt: ICorestoreControlTokenSetReceipt;
+}
+/**
+ * The token's state and its most recent receipts, oldest first: every receipt while the token has
+ * been set at most `corestoreControlTokenMaximumReceipts` times, the latest that many after. Value-free.
+ */
+export interface ICorestoreControlTokenStateRead {
+    state: TCorestoreControlTokenState;
+    receipts: ICorestoreControlTokenSetReceipt[];
+}
+/** Every reason Cloudly answers instead of storing a Corestore control token. */
+export declare const corestoreControlTokenSetRefusals: readonly ["token-invalid", "token-present", "token-absent", "token-revision-mismatch", "provider-unavailable"];
+export type TCorestoreControlTokenSetRefusal = typeof corestoreControlTokenSetRefusals[number];
+/** The actor a receipt names when the in-container command stored the token. */
+export declare const corestoreControlTokenContainerCliActorId: "operator:secrets-cli";
+/** The most receipts one state read answers: the latest ones, once a token has been set more often. */
+export declare const corestoreControlTokenMaximumReceipts = 4096;
+export declare const snapshotCorestoreControlTokenState: (valueArg: unknown) => TCorestoreControlTokenState;
+/**
+ * Structural copy of a set request. A refusal never quotes the request, because it carries the
+ * token: every failure is the contract's one value-free message.
+ */
+export declare const snapshotCorestoreControlTokenSetRequest: (valueArg: unknown) => ICorestoreControlTokenSetRequest;
+export declare const snapshotCorestoreControlTokenSetReceipt: (valueArg: unknown) => ICorestoreControlTokenSetReceipt;
+export declare const snapshotCorestoreControlTokenSetResult: (valueArg: unknown) => ICorestoreControlTokenSetResult;
+/**
+ * Structural copy of a state read. No token stored means no receipt. A stored token's receipts are
+ * contiguous and end at its revision, and they start at revision 1 -- or at 2, because only a token
+ * stored before receipts existed reaches revision 1 without one -- unless the read is a full window
+ * of `corestoreControlTokenMaximumReceipts`, whose oldest receipt may name any later revision.
+ */
+export declare const snapshotCorestoreControlTokenStateRead: (valueArg: unknown) => ICorestoreControlTokenStateRead;
+/**
+ * Joins a set answer to the request it answers. The answered state is the one the request
+ * produces -- revision 1 when no token was stored, the expected revision plus one otherwise -- and
+ * the receipt is an administrator's receipt for exactly that revision. Content join only: whether
+ * the token was stored is Cloudly's to prove, and the answer never carries it.
+ */
+export declare const bindCorestoreControlTokenSet: (resultArg: unknown, requestArg: unknown) => ICorestoreControlTokenSetResult;

package/dist_ts/data/corestorecontroltoken.js

@@ -0,0 +1,106 @@
+import { isCorestoreControlToken } from '../runtime.corestore.js';
+import { captureNetwork, networkCounter, networkId, networkList, networkRecord, requireNetwork, } from '../private/networkcontract.js';
+/** Every reason Cloudly answers instead of storing a Corestore control token. */
+export const corestoreControlTokenSetRefusals = Object.freeze([
+    /** The token is outside the contract: its length, encoding or whitespace (`isCorestoreControlToken`). */
+    'token-invalid',
+    /** `expected` said absent, and a token is stored. */
+    'token-present',
+    /** `expected` named a revision, and no token is stored. */
+    'token-absent',
+    /** `expected` named a revision, and the stored token is at another one. */
+    'token-revision-mismatch',
+    /** A Corestore provider config is missing or disabled, so there is nothing to store it under. */
+    'provider-unavailable',
+]);
+/** The actor a receipt names when the in-container command stored the token. */
+export const corestoreControlTokenContainerCliActorId = 'operator:secrets-cli';
+/** The most receipts one state read answers: the latest ones, once a token has been set more often. */
+export const corestoreControlTokenMaximumReceipts = 4096;
+const fail = () => { throw new Error('Corestore control token contract rejected.'); };
+const safe = (operationArg) => {
+    try {
+        return operationArg();
+    }
+    catch {
+        return fail();
+    }
+};
+const readState = (valueArg) => {
+    const value = networkRecord(valueArg, ['state'], ['revision']);
+    if (value.state === 'absent') {
+        networkRecord(value, ['state']);
+        return { state: 'absent' };
+    }
+    requireNetwork(value.state === 'present');
+    return { state: 'present', revision: networkCounter(networkRecord(value, ['state', 'revision']).revision) };
+};
+export const snapshotCorestoreControlTokenState = (valueArg) => safe(() => readState(captureNetwork(valueArg)));
+/**
+ * Structural copy of a set request. A refusal never quotes the request, because it carries the
+ * token: every failure is the contract's one value-free message.
+ */
+export const snapshotCorestoreControlTokenSetRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['token', 'expected']);
+    requireNetwork(isCorestoreControlToken(value.token));
+    return { token: value.token, expected: readState(value.expected) };
+});
+const readReceipt = (valueArg) => {
+    const value = networkRecord(valueArg, ['id', 'revision', 'via', 'actorId', 'setAt']);
+    requireNetwork(value.via === 'admin-request' || value.via === 'container-cli');
+    const actorId = networkId(value.actorId);
+    requireNetwork(value.via === 'admin-request'
+        ? actorId !== corestoreControlTokenContainerCliActorId
+        : actorId === corestoreControlTokenContainerCliActorId);
+    return {
+        id: networkId(value.id),
+        revision: networkCounter(value.revision),
+        via: value.via,
+        actorId,
+        setAt: networkCounter(value.setAt),
+    };
+};
+export const snapshotCorestoreControlTokenSetReceipt = (valueArg) => safe(() => readReceipt(captureNetwork(valueArg)));
+export const snapshotCorestoreControlTokenSetResult = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['state', 'receipt']);
+    const state = readState(value.state);
+    requireNetwork(state.state === 'present');
+    return { state, receipt: readReceipt(value.receipt) };
+});
+/**
+ * Structural copy of a state read. No token stored means no receipt. A stored token's receipts are
+ * contiguous and end at its revision, and they start at revision 1 -- or at 2, because only a token
+ * stored before receipts existed reaches revision 1 without one -- unless the read is a full window
+ * of `corestoreControlTokenMaximumReceipts`, whose oldest receipt may name any later revision.
+ */
+export const snapshotCorestoreControlTokenStateRead = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['state', 'receipts']);
+    const state = readState(value.state);
+    const receipts = networkList(value.receipts, corestoreControlTokenMaximumReceipts, readReceipt);
+    if (state.state === 'absent') {
+        requireNetwork(receipts.length === 0);
+        return { state, receipts };
+    }
+    const first = state.revision - receipts.length + 1;
+    requireNetwork(first >= 1
+        && (first <= 2 || receipts.length === corestoreControlTokenMaximumReceipts)
+        && receipts.every((receipt, index) => receipt.revision === first + index));
+    return { state, receipts };
+});
+/**
+ * Joins a set answer to the request it answers. The answered state is the one the request
+ * produces -- revision 1 when no token was stored, the expected revision plus one otherwise -- and
+ * the receipt is an administrator's receipt for exactly that revision. Content join only: whether
+ * the token was stored is Cloudly's to prove, and the answer never carries it.
+ */
+export const bindCorestoreControlTokenSet = (resultArg, requestArg) => safe(() => {
+    const request = snapshotCorestoreControlTokenSetRequest(requestArg);
+    const result = snapshotCorestoreControlTokenSetResult(resultArg);
+    const produced = request.expected.state === 'absent' ? 1 : request.expected.revision + 1;
+    requireNetwork(Number.isSafeInteger(produced)
+        && result.state.revision === produced
+        && result.receipt.revision === produced
+        && result.receipt.via === 'admin-request');
+    return result;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/data/index.d.ts

@@ -7,6 +7,7 @@ export * from './clusteringressdesignation.js';
 export * from './clusterrelaycredential.js';
 export * from './config.js';
 export * from './corestore.js';
+export * from './corestorecontroltoken.js';
 export * from './corestorelegacyadoption.js';
 export * from './coremail.js';
 export * from './coremail.runtime.js';
@@ -38,6 +39,7 @@ export * from './networkaddressplan.js';
 export * from './networkauthority.js';
 export * from './networkcredential.js';
 export * from './networkdelivery.js';
+export * from './networkegressretirement.js';
 export * from './networklease.js';
 export * from './networknode.js';
 export * from './networkprojection.js';

package/dist_ts/data/index.js

@@ -7,6 +7,7 @@ export * from './clusteringressdesignation.js';
 export * from './clusterrelaycredential.js';
 export * from './config.js';
 export * from './corestore.js';
+export * from './corestorecontroltoken.js';
 export * from './corestorelegacyadoption.js';
 export * from './coremail.js';
 export * from './coremail.runtime.js';
@@ -38,6 +39,7 @@ export * from './networkaddressplan.js';
 export * from './networkauthority.js';
 export * from './networkcredential.js';
 export * from './networkdelivery.js';
+export * from './networkegressretirement.js';
 export * from './networklease.js';
 export * from './networknode.js';
 export * from './networkprojection.js';
@@ -77,4 +79,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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