@serve.zone/interfaces 32.41.0 → 32.43.0

package/dist_ts/data/networkcredential.d.ts

@@ -39,17 +39,21 @@ export declare const snapshotGetRuntimeManagedVpnCredentialResponse: (value: unk
 export declare const bindGetRuntimeManagedVpnCredentialRequest: (value: unknown, projectionValue: unknown, trustedSessionValue: unknown) => Promise<IGetRuntimeManagedVpnCredentialRequest>;
 /**
  * Whether `next` continues the managed VPN membership `previous` belongs to: the same projection
- * lineage (`id`), the same protected authority, and the same handoff lease, which names the node
- * scope and carries the node's router incarnation. Both must hold a handoff, because a node without
- * one is no member. `next` is `previous` itself or a later generation; an earlier one, or another
- * projection under the same generation, continues nothing.
+ * lineage (`id`), a protected authority that continues the previous one
+ * (`continuesRuntimeNetworkProtection`: the same authority, or its next step that only adds), and
+ * the same handoff lease, which names the node scope and carries the node's router incarnation.
+ * Both must hold a handoff, because a node without one is no member. `next` is `previous` itself
+ * or a later generation; an earlier one, or another projection under the same generation,
+ * continues nothing.
  *
  * Everything else a projection states may move under one membership: its workload endpoints, their
  * readiness, observations and egress, its private networks, its router selection and its DNS window.
- * Those are what the member's network carries, never who the member is. A protection bump, a fresh
- * handoff (router reincarnation) or a new controller epoch ends the membership. Whether the hub a
- * credential names is still selected is the credential's question
- * (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
+ * Those are what the member's network carries, never who the member is. So does a cluster topology
+ * change: a node joining the egress or a cluster hub joining the platform endpoints is an additive
+ * protection step, and every member keeps its key pair across it. A protection step that removes or
+ * changes anything, or skips a step, a fresh handoff (router reincarnation) or a new controller
+ * epoch ends the membership. Whether the hub a credential names is still selected is the
+ * credential's question (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
  *
  * Validates both complete projections and rejects either that does not validate; a valid pair that
  * is not one membership answers `false`. It samples no clock and fences no session.

package/dist_ts/data/networkcredential.js

@@ -1,5 +1,6 @@
 import { runtimeNetworkAddressPlanContract } from './networkaddressplan.js';
 import { snapshotRuntimeSessionBinding } from './runtimesession.js';
+import { continuesRuntimeNetworkProtection } from './networkauthority.js';
 import { snapshotRuntimeNetworkProjection, validateRuntimeNetworkProjection } from './networkprojection.js';
 import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
 import { captureNetwork, failNetwork, networkAuthorityId, networkCounter, networkEffectiveDnsWindow, networkEqual, networkId, networkIpv4, networkNoiseKey, networkRecord, networkReference, networkReferenceOf, networkSafe, networkSameScope, requireNetwork } from '../private/networkcontract.js';
@@ -46,10 +47,10 @@ export const bindGetRuntimeManagedVpnCredentialRequest = async (value, projectio
  * A valid projection's handoff lease names the projection's own node scope, so one handoff
  * reference is one node scope and the scope needs no comparison of its own.
  */
-const continuesMembership = (previous, next) => previous.handoff !== null && next.handoff !== null && previous.id === next.id
-    && networkEqual(networkReferenceOf(previous.protectedAuthority), networkReferenceOf(next.protectedAuthority))
+const continuesMembership = async (previous, next) => previous.handoff !== null && next.handoff !== null && previous.id === next.id
     && networkEqual(networkReferenceOf(previous.handoff), networkReferenceOf(next.handoff))
-    && (next.generation > previous.generation || networkEqual(networkReferenceOf(previous), networkReferenceOf(next)));
+    && (next.generation > previous.generation || networkEqual(networkReferenceOf(previous), networkReferenceOf(next)))
+    && await continuesRuntimeNetworkProtection(previous.protectedAuthority, next.protectedAuthority);
 /** What a membership's credential keeps across its projections: everything but the projection and the expiry. */
 const credentialIdentity = (value) => ({
     transport: value.transport, hub: value.hub, authorityId: value.authorityId, serverPublicKey: value.serverPublicKey,
@@ -57,17 +58,21 @@ const credentialIdentity = (value) => ({
 });
 /**
  * Whether `next` continues the managed VPN membership `previous` belongs to: the same projection
- * lineage (`id`), the same protected authority, and the same handoff lease, which names the node
- * scope and carries the node's router incarnation. Both must hold a handoff, because a node without
- * one is no member. `next` is `previous` itself or a later generation; an earlier one, or another
- * projection under the same generation, continues nothing.
+ * lineage (`id`), a protected authority that continues the previous one
+ * (`continuesRuntimeNetworkProtection`: the same authority, or its next step that only adds), and
+ * the same handoff lease, which names the node scope and carries the node's router incarnation.
+ * Both must hold a handoff, because a node without one is no member. `next` is `previous` itself
+ * or a later generation; an earlier one, or another projection under the same generation,
+ * continues nothing.
  *
  * Everything else a projection states may move under one membership: its workload endpoints, their
  * readiness, observations and egress, its private networks, its router selection and its DNS window.
- * Those are what the member's network carries, never who the member is. A protection bump, a fresh
- * handoff (router reincarnation) or a new controller epoch ends the membership. Whether the hub a
- * credential names is still selected is the credential's question
- * (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
+ * Those are what the member's network carries, never who the member is. So does a cluster topology
+ * change: a node joining the egress or a cluster hub joining the platform endpoints is an additive
+ * protection step, and every member keeps its key pair across it. A protection step that removes or
+ * changes anything, or skips a step, a fresh handoff (router reincarnation) or a new controller
+ * epoch ends the membership. Whether the hub a credential names is still selected is the
+ * credential's question (`bindGetRuntimeManagedVpnCredentialSuccessor`), not the membership's.
  *
  * Validates both complete projections and rejects either that does not validate; a valid pair that
  * is not one membership answers `false`. It samples no clock and fences no session.
@@ -146,7 +151,7 @@ export const bindGetRuntimeManagedVpnCredentialSuccessor = async (value, previou
         const previousProjection = await validateRuntimeNetworkProjection(previousInput);
         const projection = await validateRuntimeNetworkProjection(projectionInput);
         const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
-        requireNetwork(continuesMembership(previousProjection, projection));
+        requireNetwork(await continuesMembership(previousProjection, projection));
         requireNetwork(networkEqual(previous.session, trusted)
             && networkEqual(previous.projection, networkReferenceOf(previousProjection)));
         requireNetwork(networkEqual(credentialIdentity(previous), credentialIdentity(response)));
@@ -156,4 +161,4 @@ export const bindGetRuntimeManagedVpnCredentialSuccessor = async (value, previou
         return failNetwork();
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcredential.js","sourceRoot":"","sources":["../../ts/data/networkcredential.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcredential.js","sourceRoot":"","sources":["../../ts/data/networkcredential.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/networkegressretirement.d.ts

@@ -0,0 +1,129 @@
+import type { TSha256Digest } from './immutableimage.js';
+import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
+import type { IRuntimeNetworkNodeScope } from './networkprojection.js';
+import type { IRuntimeNetworkProtectedAuthority } from './networkauthority.js';
+import { type TNodeRuntimeRetirementDisposition } from './noderetirement.js';
+/** One egress owner of a protected authority, as `IRuntimeNetworkProtectedAuthority.egressAuthorities` names it. */
+export interface IRuntimeNetworkEgressOwner {
+    nodeId: string;
+    runtimeNamespace: string;
+}
+/** A remaining owner's acknowledged projection head, which carries no endpoint of the retired owner. */
+export interface IRuntimeNetworkEgressRetirementClearance extends IRuntimeNetworkEgressOwner {
+    projection: IRuntimeAuthorityReference;
+}
+/**
+ * The independent fence that lets one egress owner leave a protected authority.
+ *
+ * A protected authority's egress owners only grow by default: an owner that is offline, revoked or
+ * gone can never acknowledge a successor, and omitting it is not a revocation. This record is the
+ * controller's statement that the owner holds no packet authority any more, recorded against the
+ * exact authority it is about to leave. Every member is evidence the controller read from its own
+ * durable state when it recorded the fence:
+ *
+ * 1. the node carries an `INodeRuntimeRetirement` row (`disposition` copies it);
+ * 2. both node credentials are revoked (`revokedCredentials`, committed at `revokedAt`), so the node
+ *    can no longer register, renew a DNS lease or fetch a managed VPN credential;
+ * 3. every DNS and managed VPN window the node was ever issued has ended (`packetWindowExpiresAt`),
+ *    so no hub relays for it even if it was never told to stop;
+ * 4. every handoff and workload lease the node was granted is quarantined (`quarantinedHandoffs`,
+ *    `quarantinedWorkloads`) and is never handed out again;
+ * 5. every remaining owner of `protectedAuthority` acknowledged a projection head that carries no
+ *    endpoint of the node (`clearedProjections`). An owner whose own `lost` fence is recorded
+ *    against the same authority is not a remaining owner here: it never acknowledges anything again,
+ *    so it can never clear another owner's endpoints, and it leaves behind its own fence.
+ *
+ * `lastReceipt` is the node's last accepted protection receipt. A `withdrawn` node took part in its
+ * retirement, so it always has one — its null withdrawal; a `lost` node may never have reported.
+ *
+ * A structural snapshot and digest do not authenticate any of it: the controller must fence the
+ * rows it read together with the authority it stages.
+ */
+export interface IRuntimeNetworkEgressRetirement extends IRuntimeNetworkNodeScope {
+    /** The exact protected authority the owner leaves: the predecessor of the step that drops it. */
+    protectedAuthority: IRuntimeAuthorityReference;
+    disposition: TNodeRuntimeRetirementDisposition;
+    lastReceipt: IRuntimeAuthorityReference | null;
+    /** The generation each node credential was revoked at. */
+    revokedCredentials: {
+        spark: number;
+        pallet: number;
+    };
+    /** Unix milliseconds on the controller's clock when the later of the two revocations committed. */
+    revokedAt: number;
+    /**
+     * Unix milliseconds: the latest end of any DNS or managed VPN window the node was ever issued, or
+     * `revokedAt` when it was issued none.
+     */
+    packetWindowExpiresAt: number;
+    /** Unix milliseconds when the fence was recorded: never before `revokedAt` or `packetWindowExpiresAt`. */
+    fencedAt: number;
+    /** Every handoff lease the node was granted, each quarantined, in canonical order. */
+    quarantinedHandoffs: IRuntimeAuthorityReference[];
+    /** Every workload lease the node was granted, each quarantined, in canonical order. */
+    quarantinedWorkloads: IRuntimeAuthorityReference[];
+    /**
+     * One entry per remaining owner of `protectedAuthority` whose own `lost` fence is not recorded
+     * against that authority, in canonical owner order.
+     */
+    clearedProjections: IRuntimeNetworkEgressRetirementClearance[];
+    digest: TSha256Digest;
+}
+export declare const runtimeNetworkEgressRetirementContract: Readonly<{
+    readonly digestDomain: "serve.zone/runtime-network-egress-retirement";
+    readonly maximumQuarantinedHandoffs: 256;
+    readonly maximumQuarantinedWorkloads: 512;
+    readonly maximumClearedProjections: number;
+    /** Fences one step may consume. Each is read on its own, so one step stays bounded. */
+    readonly maximumFencesPerStep: 16;
+    /**
+     * Lost fences one step may hold as exemptions: owners it keeps that no consumed fence's clearance
+     * has to name. At least one owner is kept, so this is one fewer than the owners an authority has.
+     */
+    readonly maximumExemptionsPerStep: number;
+    /**
+     * Retired owners one step may be given: the caller's history restricted to owners `previous` or
+     * `next` names, which is at most every owner of both.
+     */
+    readonly maximumRetiredOwners: number;
+    readonly removal: "absent-owner-requires-fence-bound-to-exact-previous-authority";
+    readonly reentry: "a-fenced-owner-never-returns";
+}>;
+/** Exact-key structural snapshot, detached from its input. It verifies no digest and fences nothing. */
+export declare const snapshotRuntimeNetworkEgressRetirement: (value: unknown) => IRuntimeNetworkEgressRetirement;
+export declare const computeRuntimeNetworkEgressRetirementDigest: (value: IRuntimeNetworkEgressRetirement) => Promise<TSha256Digest>;
+/**
+ * Whether `next` may succeed `previous`, judged on its egress owners and the address space it keeps.
+ *
+ * Pure and fail-closed. `fences` are the egress retirements this step consumes. `exemptions` are
+ * `lost` fences of owners this step keeps, recorded against the same `previous`: such an owner never
+ * acknowledges another projection head, so no consumed fence's clearance can wait for it. They are
+ * read, not consumed, and default to none. `retiredOwners` is the caller's durable history of
+ * fenced owners restricted to the owners `previous` or `next` names, in canonical owner order. The
+ * step is accepted only when:
+ *
+ * - `next` is the exact successor of `previous` under the same controller, and both digests verify;
+ * - an owner of `previous` is absent from `next` only when exactly one fence, recorded against the
+ *   exact `previous` reference and verified by its digest, names it — a fence for an owner `next`
+ *   still names, or for an owner `previous` does not name, refuses the step;
+ * - every exemption verifies by its digest, is `lost`, is recorded under the same controller against
+ *   the exact `previous` reference, and names an owner both `previous` and `next` name, no fence
+ *   names and no other exemption names; at most `maximumExemptionsPerStep`, in canonical owner order;
+ * - every fence's `clearedProjections` names exactly the owners of `previous` this step keeps, less
+ *   the exempt owners; an exemption's own clearance is not judged here, only when its owner leaves;
+ * - `retiredOwners` is empty: any entry is either an owner a side names that was fenced before, or
+ *   not part of the restriction at all, so a fenced owner never returns;
+ * - every pool of `previous` is kept unchanged and the prefixes of `next` cover those of `previous`;
+ *   a step that removes an owner also keeps every resolver of `previous` unchanged.
+ *
+ * Owners that join in the same step are admitted. With no fence this is the additive owner rule:
+ * nobody leaves, and exemptions relax nothing. It verifies no fence evidence against live state and
+ * fences no record: the caller fences every fence and exemption it read together with the authority
+ * it stages.
+ */
+export declare const bindRuntimeNetworkProtectedAuthorityRetirement: (previousValue: unknown, nextValue: unknown, fencesValue: unknown, retiredOwnersValue: unknown, exemptionsValue?: unknown) => Promise<{
+    previous: IRuntimeNetworkProtectedAuthority;
+    next: IRuntimeNetworkProtectedAuthority;
+    fences: IRuntimeNetworkEgressRetirement[];
+    exemptions: IRuntimeNetworkEgressRetirement[];
+}>;

package/dist_ts/data/networkegressretirement.js

@@ -0,0 +1,142 @@
+import { computeRuntimeNetworkProtectedAuthorityDigest, runtimeNetworkAuthorityContract, snapshotRuntimeNetworkProtectedAuthority } from './networkauthority.js';
+import { nodeRuntimeRetirementDispositions } from './noderetirement.js';
+import { readDataElements } from '../private/dataproperties.js';
+import { isOneOf } from '../private/producercontract.js';
+import { captureNetwork, failNetwork, networkCanonical, networkCounter, networkCoveredBy, networkDigest, networkEqual, networkHash, networkId, networkList, networkNodeId, networkRecord, networkReference, networkReferenceOf, networkSafe, networkScope, networkSorted, requireNetwork } from '../private/networkcontract.js';
+export const runtimeNetworkEgressRetirementContract = Object.freeze({
+    digestDomain: 'serve.zone/runtime-network-egress-retirement',
+    maximumQuarantinedHandoffs: runtimeNetworkAuthorityContract.maximumRetainedHandoffLeases,
+    maximumQuarantinedWorkloads: 512,
+    maximumClearedProjections: runtimeNetworkAuthorityContract.maximumEgressAuthorities - 1,
+    /** Fences one step may consume. Each is read on its own, so one step stays bounded. */
+    maximumFencesPerStep: 16,
+    /**
+     * Lost fences one step may hold as exemptions: owners it keeps that no consumed fence's clearance
+     * has to name. At least one owner is kept, so this is one fewer than the owners an authority has.
+     */
+    maximumExemptionsPerStep: runtimeNetworkAuthorityContract.maximumEgressAuthorities - 1,
+    /**
+     * Retired owners one step may be given: the caller's history restricted to owners `previous` or
+     * `next` names, which is at most every owner of both.
+     */
+    maximumRetiredOwners: 2 * runtimeNetworkAuthorityContract.maximumEgressAuthorities,
+    removal: 'absent-owner-requires-fence-bound-to-exact-previous-authority',
+    reentry: 'a-fenced-owner-never-returns',
+});
+const ownerKey = (value) => networkCanonical([value.nodeId, value.runtimeNamespace]);
+const referenceKey = (value) => networkCanonical(value);
+const readOwner = (value) => {
+    const item = networkRecord(value, ['nodeId', 'runtimeNamespace']);
+    return { nodeId: networkNodeId(item.nodeId), runtimeNamespace: networkId(item.runtimeNamespace) };
+};
+const readReferences = (value, maximum) => networkSorted(networkList(value, maximum, networkReference), referenceKey);
+const readClearance = (value) => {
+    const item = networkRecord(value, ['nodeId', 'runtimeNamespace', 'projection']);
+    return { ...readOwner({ nodeId: item.nodeId, runtimeNamespace: item.runtimeNamespace }),
+        projection: networkReference(item.projection) };
+};
+/** Exact-key structural snapshot, detached from its input. It verifies no digest and fences nothing. */
+export const snapshotRuntimeNetworkEgressRetirement = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['controller', 'nodeId', 'runtimeNamespace', 'protectedAuthority',
+        'disposition', 'lastReceipt', 'revokedCredentials', 'revokedAt', 'packetWindowExpiresAt', 'fencedAt',
+        'quarantinedHandoffs', 'quarantinedWorkloads', 'clearedProjections', 'digest']);
+    const scope = networkScope(item);
+    const disposition = item.disposition;
+    requireNetwork(isOneOf(nodeRuntimeRetirementDispositions, disposition));
+    const lastReceipt = item.lastReceipt === null ? null : networkReference(item.lastReceipt);
+    requireNetwork(disposition === 'lost' || lastReceipt !== null);
+    const credentials = networkRecord(item.revokedCredentials, ['spark', 'pallet']);
+    const revokedAt = networkCounter(item.revokedAt), packetWindowExpiresAt = networkCounter(item.packetWindowExpiresAt);
+    const fencedAt = networkCounter(item.fencedAt);
+    requireNetwork(fencedAt >= revokedAt && fencedAt >= packetWindowExpiresAt);
+    const contract = runtimeNetworkEgressRetirementContract;
+    const clearedProjections = networkSorted(networkList(item.clearedProjections, contract.maximumClearedProjections, readClearance), ownerKey);
+    requireNetwork(clearedProjections.every(owner => ownerKey(owner) !== ownerKey(scope)));
+    return { ...scope, protectedAuthority: networkReference(item.protectedAuthority), disposition, lastReceipt,
+        revokedCredentials: { spark: networkCounter(credentials.spark), pallet: networkCounter(credentials.pallet) },
+        revokedAt, packetWindowExpiresAt, fencedAt,
+        quarantinedHandoffs: readReferences(item.quarantinedHandoffs, contract.maximumQuarantinedHandoffs),
+        quarantinedWorkloads: readReferences(item.quarantinedWorkloads, contract.maximumQuarantinedWorkloads),
+        clearedProjections, digest: networkDigest(item.digest) };
+});
+export const computeRuntimeNetworkEgressRetirementDigest = (value) => networkHash(runtimeNetworkEgressRetirementContract.digestDomain, snapshotRuntimeNetworkEgressRetirement(value));
+/**
+ * Whether `next` may succeed `previous`, judged on its egress owners and the address space it keeps.
+ *
+ * Pure and fail-closed. `fences` are the egress retirements this step consumes. `exemptions` are
+ * `lost` fences of owners this step keeps, recorded against the same `previous`: such an owner never
+ * acknowledges another projection head, so no consumed fence's clearance can wait for it. They are
+ * read, not consumed, and default to none. `retiredOwners` is the caller's durable history of
+ * fenced owners restricted to the owners `previous` or `next` names, in canonical owner order. The
+ * step is accepted only when:
+ *
+ * - `next` is the exact successor of `previous` under the same controller, and both digests verify;
+ * - an owner of `previous` is absent from `next` only when exactly one fence, recorded against the
+ *   exact `previous` reference and verified by its digest, names it — a fence for an owner `next`
+ *   still names, or for an owner `previous` does not name, refuses the step;
+ * - every exemption verifies by its digest, is `lost`, is recorded under the same controller against
+ *   the exact `previous` reference, and names an owner both `previous` and `next` name, no fence
+ *   names and no other exemption names; at most `maximumExemptionsPerStep`, in canonical owner order;
+ * - every fence's `clearedProjections` names exactly the owners of `previous` this step keeps, less
+ *   the exempt owners; an exemption's own clearance is not judged here, only when its owner leaves;
+ * - `retiredOwners` is empty: any entry is either an owner a side names that was fenced before, or
+ *   not part of the restriction at all, so a fenced owner never returns;
+ * - every pool of `previous` is kept unchanged and the prefixes of `next` cover those of `previous`;
+ *   a step that removes an owner also keeps every resolver of `previous` unchanged.
+ *
+ * Owners that join in the same step are admitted. With no fence this is the additive owner rule:
+ * nobody leaves, and exemptions relax nothing. It verifies no fence evidence against live state and
+ * fences no record: the caller fences every fence and exemption it read together with the authority
+ * it stages.
+ */
+export const bindRuntimeNetworkProtectedAuthorityRetirement = async (previousValue, nextValue, fencesValue, retiredOwnersValue, exemptionsValue = []) => {
+    try {
+        const contract = runtimeNetworkEgressRetirementContract;
+        const previous = snapshotRuntimeNetworkProtectedAuthority(captureNetwork(previousValue));
+        const next = snapshotRuntimeNetworkProtectedAuthority(captureNetwork(nextValue));
+        const elements = readDataElements(fencesValue, contract.maximumFencesPerStep);
+        requireNetwork(elements);
+        const fences = networkSorted(elements.map(snapshotRuntimeNetworkEgressRetirement), ownerKey);
+        const exemptionElements = readDataElements(exemptionsValue, contract.maximumExemptionsPerStep);
+        requireNetwork(exemptionElements);
+        const exemptions = networkSorted(exemptionElements.map(snapshotRuntimeNetworkEgressRetirement), ownerKey);
+        const retiredOwners = networkSorted(networkList(captureNetwork(retiredOwnersValue), contract.maximumRetiredOwners, readOwner), ownerKey);
+        requireNetwork(previous.digest === await computeRuntimeNetworkProtectedAuthorityDigest(previous)
+            && next.digest === await computeRuntimeNetworkProtectedAuthorityDigest(next));
+        const reference = networkReferenceOf(previous);
+        requireNetwork(networkEqual(next.controller, previous.controller) && next.id === previous.id
+            && next.generation === previous.generation + 1 && networkEqual(next.previous, reference));
+        const previousOwners = new Set(previous.egressAuthorities.map(ownerKey));
+        const nextOwners = new Set(next.egressAuthorities.map(ownerKey));
+        const fenced = new Set(fences.map(ownerKey));
+        for (const fence of fences) {
+            requireNetwork(fence.digest === await computeRuntimeNetworkEgressRetirementDigest(fence)
+                && networkEqual(fence.controller, previous.controller) && networkEqual(fence.protectedAuthority, reference)
+                && previousOwners.has(ownerKey(fence)) && !nextOwners.has(ownerKey(fence)));
+        }
+        requireNetwork([...previousOwners].every(owner => nextOwners.has(owner) || fenced.has(owner)));
+        for (const exemption of exemptions) {
+            requireNetwork(exemption.digest === await computeRuntimeNetworkEgressRetirementDigest(exemption)
+                && exemption.disposition === 'lost' && networkEqual(exemption.controller, previous.controller)
+                && networkEqual(exemption.protectedAuthority, reference) && previousOwners.has(ownerKey(exemption))
+                && nextOwners.has(ownerKey(exemption)));
+        }
+        // A fence's owner is never named by `next`, so no exemption names an owner a fence names.
+        const exempt = new Set(exemptions.map(ownerKey));
+        const cleared = previous.egressAuthorities.map(ownerKey).filter(owner => !fenced.has(owner) && !exempt.has(owner));
+        for (const fence of fences) {
+            requireNetwork(networkEqual(fence.clearedProjections.map(ownerKey), cleared));
+        }
+        requireNetwork(retiredOwners.length === 0);
+        requireNetwork(previous.pools.every(pool => next.pools.some(candidate => networkEqual(candidate, pool)))
+            && previous.prefixes.every(prefix => networkCoveredBy(next.prefixes, prefix)));
+        if (fences.length > 0) {
+            requireNetwork(previous.resolvers.every(resolver => next.resolvers.some(candidate => networkEqual(candidate, resolver))));
+        }
+        return { previous, next, fences, exemptions };
+    }
+    catch {
+        return failNetwork();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkegressretirement.js","sourceRoot":"","sources":["../../ts/data/networkegressretirement.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/noderetirement.d.ts

@@ -1,10 +1,26 @@
 declare const nodeRuntimeRetirementStates: readonly ["retiring", "retired"];
 /**
  * How far a node's retirement has come: `retiring` while the producer still stops and removes the
- * node's slots, the compiler quarantines its handoff and both node credentials are revoked;
- * `retired` once all of that has settled and nothing but the node document is left to delete.
+ * node's slots, the compiler quarantines its handoff and leases, both node credentials are revoked
+ * and the node's egress fence (`IRuntimeNetworkEgressRetirement`) is not yet recorded; `retired`
+ * once the protected authority no longer names the node and nothing but the node document is left
+ * to delete.
  */
 export type TNodeRuntimeRetirementState = typeof nodeRuntimeRetirementStates[number];
+/** Every way a node can leave its runtime, in the order an escalation moves through them. */
+export declare const nodeRuntimeRetirementDispositions: readonly ["withdrawn", "lost"];
+/**
+ * How the node leaves.
+ *
+ * `withdrawn`: the node still runs and takes part. Its slots are removed against its own removal
+ * receipts, and its Pallet withdraws its protection receipt before its credentials are revoked.
+ *
+ * `lost`: an administrator states that the node will never report again — its host is gone, wiped
+ * or unreachable for good. Its slots are abandoned without removal receipts, which is the one thing
+ * this statement authorizes. It authorizes nothing about packets: a lost node leaves the protected
+ * authority behind exactly the same controller-owned fence as a withdrawn one.
+ */
+export type TNodeRuntimeRetirementDisposition = typeof nodeRuntimeRetirementDispositions[number];
 /**
  * That one node leaves its cluster's runtime, stored beside the node document rather than inside
  * it, because a node update merges caller data and no caller may retire a node with it.
@@ -19,7 +35,9 @@ export interface INodeRuntimeRetirement {
     /** The cluster the node is retiring from, copied by Cloudly; never caller-chosen. */
     clusterId: string;
     state: TNodeRuntimeRetirementState;
-    /** The administrator who asked for the retirement. */
+    /** How the node leaves; a `withdrawn` retirement still `retiring` may be escalated to `lost`. */
+    disposition: TNodeRuntimeRetirementDisposition;
+    /** The administrator who asked for the retirement, or for its escalation. */
     actorId: string;
     /** Unix milliseconds on Cloudly's clock, when the row entered its current state. */
     since: number;
@@ -28,9 +46,11 @@ export interface INodeRuntimeRetirement {
  * Every reason Cloudly answers instead of retiring a node. Each travels as a `TypedResponseError`,
  * and none of them takes anything away: a refused retirement leaves the node exactly as it was.
  */
-export declare const nodeRuntimeRetirementRefusals: readonly ["node-missing", "cluster-runtime-not-pallet", "node-already-retired", "conflict"];
+export declare const nodeRuntimeRetirementRefusals: readonly ["node-missing", "cluster-runtime-not-pallet", "node-already-retired", "conflict", "node-still-reporting"];
 /** One of the reasons Cloudly answers instead of a retirement row. */
 export type TNodeRuntimeRetirementRefusal = typeof nodeRuntimeRetirementRefusals[number];
+/** One disposition, exactly as `nodeRuntimeRetirementDispositions` spells it. */
+export declare const snapshotNodeRuntimeRetirementDisposition: (value: unknown) => TNodeRuntimeRetirementDisposition;
 /**
  * Structural snapshot for exact persistence; whether the node exists and whether its cluster admits
  * the retirement is Cloudly's.

package/dist_ts/data/noderetirement.js

@@ -1,6 +1,8 @@
 import { captureNetwork, networkCounter, networkId, networkNodeId, networkRecord, requireNetwork } from '../private/networkcontract.js';
 import { isOneOf, producerSafe } from '../private/producercontract.js';
 const nodeRuntimeRetirementStates = ['retiring', 'retired'];
+/** Every way a node can leave its runtime, in the order an escalation moves through them. */
+export const nodeRuntimeRetirementDispositions = Object.freeze(['withdrawn', 'lost']);
 /**
  * Every reason Cloudly answers instead of retiring a node. Each travels as a `TypedResponseError`,
  * and none of them takes anything away: a refused retirement leaves the node exactly as it was.
@@ -13,19 +15,34 @@ export const nodeRuntimeRetirementRefusals = Object.freeze([
      * `pallet`. Which of the two it is, `getClusterRuntime` says.
      */
     'cluster-runtime-not-pallet',
-    /** The node already carries a retirement row; neither of its states is left by retiring again. */
+    /**
+     * The node already carries a retirement row that this request cannot move: anything but a
+     * `withdrawn` row still `retiring`, asked again as `lost`.
+     */
     'node-already-retired',
     /** `expectedGeneration` is not the cluster runtime's current generation, so a cutover moved underneath the caller. */
     'conflict',
+    /**
+     * A `lost` retirement of a node whose last accepted report is younger than
+     * `clusterNodeObservationFreshnessMs`: a node that still reports is not lost, and it leaves as
+     * `withdrawn`.
+     */
+    'node-still-reporting',
 ]);
+/** One disposition, exactly as `nodeRuntimeRetirementDispositions` spells it. */
+export const snapshotNodeRuntimeRetirementDisposition = (value) => producerSafe(() => {
+    requireNetwork(isOneOf(nodeRuntimeRetirementDispositions, value));
+    return value;
+});
 /**
  * Structural snapshot for exact persistence; whether the node exists and whether its cluster admits
  * the retirement is Cloudly's.
  */
 export const snapshotNodeRuntimeRetirement = (value) => producerSafe(() => {
-    const item = networkRecord(captureNetwork(value), ['id', 'clusterId', 'state', 'actorId', 'since']);
+    const item = networkRecord(captureNetwork(value), ['id', 'clusterId', 'state', 'disposition', 'actorId', 'since']);
     requireNetwork(isOneOf(nodeRuntimeRetirementStates, item.state));
     return { id: networkNodeId(item.id), clusterId: networkId(item.clusterId), state: item.state,
+        disposition: snapshotNodeRuntimeRetirementDisposition(item.disposition),
         actorId: networkId(item.actorId), since: networkCounter(item.since) };
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZXJldGlyZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL25vZGVyZXRpcmVtZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsY0FBYyxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsYUFBYSxFQUFFLGNBQWMsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3hJLE9BQU8sRUFBRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFdkUsTUFBTSwyQkFBMkIsR0FBRyxDQUFDLFVBQVUsRUFBRSxTQUFTLENBQVUsQ0FBQztBQTZCckU7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN6RCxnRUFBZ0U7SUFDaEUsY0FBYztJQUNkOzs7T0FHRztJQUNILDRCQUE0QjtJQUM1QixrR0FBa0c7SUFDbEcsc0JBQXNCO0lBQ3RCLHNIQUFzSDtJQUN0SCxVQUFVO0NBQ0YsQ0FBQyxDQUFDO0FBS1o7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsQ0FBQyxLQUFjLEVBQTBCLEVBQUUsQ0FBQyxZQUFZLENBQUMsR0FBRyxFQUFFO0lBQ3pHLE1BQU0sSUFBSSxHQUFHLGFBQWEsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUNwRyxjQUFjLENBQUMsT0FBTyxDQUFDLDJCQUEyQixFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ2pFLE9BQU8sRUFBRSxFQUFFLEVBQUUsYUFBYSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxTQUFTLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUs7UUFDMUYsT0FBTyxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsS0FBSyxFQUFFLGNBQWMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztBQUMxRSxDQUFDLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZXJldGlyZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL25vZGVyZXRpcmVtZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsY0FBYyxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsYUFBYSxFQUFFLGNBQWMsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3hJLE9BQU8sRUFBRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFdkUsTUFBTSwyQkFBMkIsR0FBRyxDQUFDLFVBQVUsRUFBRSxTQUFTLENBQVUsQ0FBQztBQVdyRSw2RkFBNkY7QUFDN0YsTUFBTSxDQUFDLE1BQU0saUNBQWlDLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFdBQVcsRUFBRSxNQUFNLENBQVUsQ0FBQyxDQUFDO0FBcUMvRjs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSw2QkFBNkIsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ3pELGdFQUFnRTtJQUNoRSxjQUFjO0lBQ2Q7OztPQUdHO0lBQ0gsNEJBQTRCO0lBQzVCOzs7T0FHRztJQUNILHNCQUFzQjtJQUN0QixzSEFBc0g7SUFDdEgsVUFBVTtJQUNWOzs7O09BSUc7SUFDSCxzQkFBc0I7Q0FDZCxDQUFDLENBQUM7QUFLWixpRkFBaUY7QUFDakYsTUFBTSxDQUFDLE1BQU0sd0NBQXdDLEdBQUcsQ0FBQyxLQUFjLEVBQXFDLEVBQUUsQ0FBQyxZQUFZLENBQUMsR0FBRyxFQUFFO0lBQy9ILGNBQWMsQ0FBQyxPQUFPLENBQUMsaUNBQWlDLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUNsRSxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMsQ0FBQyxDQUFDO0FBRUg7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsQ0FBQyxLQUFjLEVBQTBCLEVBQUUsQ0FBQyxZQUFZLENBQUMsR0FBRyxFQUFFO0lBQ3pHLE1BQU0sSUFBSSxHQUFHLGFBQWEsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxhQUFhLEVBQUUsU0FBUyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDbkgsY0FBYyxDQUFDLE9BQU8sQ0FBQywyQkFBMkIsRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUNqRSxPQUFPLEVBQUUsRUFBRSxFQUFFLGFBQWEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLEVBQUUsU0FBUyxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLO1FBQzFGLFdBQVcsRUFBRSx3Q0FBd0MsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDO1FBQ3ZFLE9BQU8sRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7QUFDMUUsQ0FBQyxDQUFDLENBQUMifQ==

package/dist_ts/private/networkcontract.d.ts

@@ -93,3 +93,5 @@ export declare const networkPrefix: (value: unknown) => string;
 export declare const networkPrivatePrefix: (value: unknown) => string;
 export declare const networkContains: (outer: string, inner: string) => boolean;
 export declare const networkOverlaps: (left: string, right: string) => boolean;
+/** Whether the union of `prefixes`, which never overlap one another, covers every address of `prefix`. */
+export declare const networkCoveredBy: (prefixes: string[], prefix: string) => boolean;