@serve.zone/interfaces 32.38.0 → 32.39.0

package/changelog.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 2026-10-02 - 32.39.0
+
+### Maintenance
+
+- Update release tooling to tsbuild 5.1.0 and tsdoc 3.0.1 (Node.js types stay 26.6.2 and pnpm 12.6.0 until their seven-day release age).
+
+### Features
+
+- A node's managed VPN membership now outlives its network projection.
+  `continuesRuntimeManagedVpnMembership(previous, next)` states what a membership is: one
+  projection lineage under one protected authority and one handoff lease (its node scope and
+  router incarnation), at a later generation (the same generation only as the identical projection). Workload, readiness, egress, router
+  selection and DNS window changes keep it; a protection bump, a fresh handoff or a new controller
+  epoch ends it. `bindGetRuntimeManagedVpnCredentialSuccessor` binds the credential for a successor
+  projection: the same session, transport, hub, authority and key pair as the held credential,
+  with only `projection` and `expiresAt` moved and the expiry inside the successor's effective DNS
+  window, which must cover the caller's time. A controller keeps a member and its key pair across a
+  projection change with it, so the node's hub session survives a workload change.
+
 ## 2026-09-30 - 32.38.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/networkcredential.d.ts

@@ -7,7 +7,12 @@ export interface IGetRuntimeManagedVpnCredentialRequest {
 }
 /** Secret response over the current authenticated physical peer only. Never
  * persist, hash, log, or include it in a signed network projection. The native
- * Noise owner validates and uses the keys; these shapes confer no TUN readiness. */
+ * Noise owner validates and uses the keys; these shapes confer no TUN readiness.
+ *
+ * One response names one exact projection, but its key pair belongs to the node's managed VPN
+ * membership, which outlives a projection: a credential for a successor projection of the same
+ * membership (`continuesRuntimeManagedVpnMembership`) carries the same transport, hub, authority and
+ * keys, bound by `bindGetRuntimeManagedVpnCredentialSuccessor`. */
 export interface IGetRuntimeManagedVpnCredentialResponse extends IGetRuntimeManagedVpnCredentialRequest {
     transport: TRuntimeNetworkVpnTransport;
     /** The cluster hub endpoint this node dials, named by the id its signed projection selected. */
@@ -32,6 +37,24 @@ export declare const snapshotGetRuntimeManagedVpnCredentialResponse: (value: unk
 /** Content binding only. The caller must resolve the exact current projection
  * and authenticate/fence the current physical peer before and after native work. */
 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare const continuesRuntimeManagedVpnMembership: (previousValue: unknown, nextValue: unknown) => Promise<boolean>;
 /** Bind the secret response to the original request and the exact selected router
  * endpoint of the credential's transport, inside the projection's effective DNS window. renewalValue is the
  * bare lease renewal the caller already verified and admitted for this exact
@@ -39,3 +62,22 @@ export declare const bindGetRuntimeManagedVpnCredentialRequest: (value: unknown,
  * this helper does not sample a clock, authenticate a transport, admit policy or
  * prove a running managed connection. */
 export declare const bindGetRuntimeManagedVpnCredentialResponse: (value: unknown, requestValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown, renewalValue?: unknown | null) => Promise<IGetRuntimeManagedVpnCredentialResponse>;
+/**
+ * Bind the credential a node holds under its successor projection: `value` names `projectionValue`
+ * and is bound exactly as `bindGetRuntimeManagedVpnCredentialResponse` binds the answer to
+ * `{ session: trustedSession, projection }`, inside that projection's effective DNS window
+ * (`renewalValue`, as there). It must also continue `previousValue`, the credential issued for
+ * `previousProjectionValue` over the same session: the two projections are one membership
+ * (`continuesRuntimeManagedVpnMembership`) and the transport, hub, authority, server key and client
+ * key pair are unchanged. Only `projection` and `expiresAt` move. The current effective window
+ * alone bounds the successor, so a membership whose current window does not cover the
+ * caller-qualified `nowValue` binds no successor; the held credential's own expiry is not
+ * consulted, because a renewal or a successor may have moved the window past it.
+ *
+ * The issuer binds the successor it states for a member, so the node's session and key pair survive
+ * a workload, readiness or policy change; the node binds a fresh answer with it to tell a successor,
+ * which keeps its live session, from a new membership, which replaces it. A previous credential for
+ * the same projection binds too, which is how a renewal moves the expiry. Content binding only, as
+ * for the response binder.
+ */
+export declare const bindGetRuntimeManagedVpnCredentialSuccessor: (value: unknown, previousValue: unknown, previousProjectionValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown, renewalValue?: unknown | null) => Promise<IGetRuntimeManagedVpnCredentialResponse>;

package/dist_ts/data/networkcredential.js

@@ -1,6 +1,6 @@
 import { runtimeNetworkAddressPlanContract } from './networkaddressplan.js';
 import { snapshotRuntimeSessionBinding } from './runtimesession.js';
-import { validateRuntimeNetworkProjection } from './networkprojection.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';
 export const snapshotGetRuntimeManagedVpnCredentialRequest = (value) => networkSafe(() => {
@@ -41,6 +41,62 @@ export const bindGetRuntimeManagedVpnCredentialRequest = async (value, projectio
         return failNetwork();
     }
 };
+/**
+ * The membership rule of `continuesRuntimeManagedVpnMembership`, over projections already validated.
+ * 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))
+    && networkEqual(networkReferenceOf(previous.handoff), networkReferenceOf(next.handoff))
+    && (next.generation > previous.generation || networkEqual(networkReferenceOf(previous), networkReferenceOf(next)));
+/** 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,
+    clientPublicKey: value.clientPublicKey, clientPrivateKey: value.clientPrivateKey,
+});
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export const continuesRuntimeManagedVpnMembership = async (previousValue, nextValue) => {
+    let previous, next;
+    try {
+        const previousInput = snapshotRuntimeNetworkProjection(previousValue), nextInput = snapshotRuntimeNetworkProjection(nextValue);
+        previous = await validateRuntimeNetworkProjection(previousInput);
+        next = await validateRuntimeNetworkProjection(nextInput);
+    }
+    catch {
+        return failNetwork();
+    }
+    return continuesMembership(previous, next);
+};
+/** The response binding over inputs already captured and validated. */
+const bindResponse = (response, request, projection, renewal, trusted, now) => {
+    const window = networkEffectiveDnsWindow(projection, renewal);
+    bindRequest(request, projection, trusted);
+    requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
+    requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
+    const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
+    const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
+    requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
+        && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
+    requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
+    return response;
+};
 /** Bind the secret response to the original request and the exact selected router
  * endpoint of the credential's transport, inside the projection's effective DNS window. renewalValue is the
  * bare lease renewal the caller already verified and admitted for this exact
@@ -55,19 +111,49 @@ export const bindGetRuntimeManagedVpnCredentialResponse = async (value, requestV
         const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
         const projection = await validateRuntimeNetworkProjection(projectionValue);
         const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
-        const window = networkEffectiveDnsWindow(projection, renewal);
-        bindRequest(request, projection, trusted);
-        requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
-        requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
-        const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
-        const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
-        requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
-            && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
-        requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
-        return response;
+        return bindResponse(response, request, projection, renewal, trusted, now);
+    }
+    catch {
+        return failNetwork();
+    }
+};
+/**
+ * Bind the credential a node holds under its successor projection: `value` names `projectionValue`
+ * and is bound exactly as `bindGetRuntimeManagedVpnCredentialResponse` binds the answer to
+ * `{ session: trustedSession, projection }`, inside that projection's effective DNS window
+ * (`renewalValue`, as there). It must also continue `previousValue`, the credential issued for
+ * `previousProjectionValue` over the same session: the two projections are one membership
+ * (`continuesRuntimeManagedVpnMembership`) and the transport, hub, authority, server key and client
+ * key pair are unchanged. Only `projection` and `expiresAt` move. The current effective window
+ * alone bounds the successor, so a membership whose current window does not cover the
+ * caller-qualified `nowValue` binds no successor; the held credential's own expiry is not
+ * consulted, because a renewal or a successor may have moved the window past it.
+ *
+ * The issuer binds the successor it states for a member, so the node's session and key pair survive
+ * a workload, readiness or policy change; the node binds a fresh answer with it to tell a successor,
+ * which keeps its live session, from a new membership, which replaces it. A previous credential for
+ * the same projection binds too, which is how a renewal moves the expiry. Content binding only, as
+ * for the response binder.
+ */
+export const bindGetRuntimeManagedVpnCredentialSuccessor = async (value, previousValue, previousProjectionValue, projectionValue, trustedSessionValue, nowValue, renewalValue = null) => {
+    try {
+        const response = snapshotGetRuntimeManagedVpnCredentialResponse(value);
+        const previous = snapshotGetRuntimeManagedVpnCredentialResponse(previousValue);
+        const previousInput = snapshotRuntimeNetworkProjection(previousProjectionValue);
+        const projectionInput = snapshotRuntimeNetworkProjection(projectionValue);
+        const trusted = snapshotRuntimeSessionBinding(trustedSessionValue), now = networkCounter(nowValue);
+        const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
+        const previousProjection = await validateRuntimeNetworkProjection(previousInput);
+        const projection = await validateRuntimeNetworkProjection(projectionInput);
+        const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
+        requireNetwork(continuesMembership(previousProjection, projection));
+        requireNetwork(networkEqual(previous.session, trusted)
+            && networkEqual(previous.projection, networkReferenceOf(previousProjection)));
+        requireNetwork(networkEqual(credentialIdentity(previous), credentialIdentity(response)));
+        return bindResponse(response, { session: trusted, projection: networkReferenceOf(projection) }, projection, renewal, trusted, now);
     }
     catch {
         return failNetwork();
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcredential.js","sourceRoot":"","sources":["../../ts/data/networkcredential.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iCAAiC,EAAoC,MAAM,yBAAyB,CAAC;AAC9G,OAAO,EAAE,6BAA6B,EAA+B,MAAM,qBAAqB,CAAC;AACjG,OAAO,EAAE,gCAAgC,EAAE,gCAAgC,EACzC,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,qCAAqC,EAAE,qCAAqC,EAC9C,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,kBAAkB,EAAE,cAAc,EAAE,yBAAyB,EAAE,YAAY,EAC/G,SAAS,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,WAAW,EACzG,gBAAgB,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AA+B1E,MAAM,CAAC,MAAM,6CAA6C,GAAG,CAAC,KAAc,EAA0C,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE;IACxI,MAAM,IAAI,GAAG,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IAC7E,OAAO,EAAE,OAAO,EAAE,6BAA6B,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;AACjH,CAAC,CAAC,CAAC;AAEH,MAAM,WAAW,GAAG,CAAC,KAAc,EAA+B,EAAE;IAClE,MAAM,GAAG,GAAG,iCAAiC,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC;IAC7G,cAAc,CAAC,GAAG,CAAC,CAAC;IAAC,OAAO,GAAG,CAAC,SAAS,CAAC;AAC5C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,8CAA8C,GAAG,CAAC,KAAc,EAA2C,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE;IAC1I,MAAM,IAAI,GAAG,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa;QAC3G,iBAAiB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,WAAW,CAAC,CAAC,CAAC;IAC1E,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/D,OAAO,EAAE,OAAO,EAAE,6BAA6B,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC;QAC1G,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC;QACtC,GAAG,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE;QACxG,WAAW,EAAE,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,eAAe,EAAE,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC;QACzG,eAAe,EAAE,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAAC,IAAI,CAAC,gBAAgB,CAAC;QAChH,SAAS,EAAE,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;AAChD,CAAC,CAAC,CAAC;AAEH,MAAM,WAAW,GAAG,CAAC,OAA+C,EAClE,UAAqC,EAAE,OAA+B,EAAQ,EAAE;IAChF,cAAc,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;WACpH,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;AACpE,CAAC,CAAC;AAEF;oFACoF;AACpF,MAAM,CAAC,MAAM,yCAAyC,GAAG,KAAK,EAAE,KAAc,EAAE,eAAwB,EACtG,mBAA4B,EAAmD,EAAE;IACjF,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,6CAA6C,CAAC,KAAK,CAAC,CAAC;QACrE,MAAM,OAAO,GAAG,6BAA6B,CAAC,mBAAmB,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,MAAM,gCAAgC,CAAC,eAAe,CAAC,CAAC;QAC3E,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAC1C,OAAO,OAAO,CAAC;IACjB,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;IAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,mBAAmB,GAAG,CAAC,QAAmC,EAAE,IAA+B,EAAW,EAAE,CAC5G,QAAQ,CAAC,OAAO,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,QAAQ,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE;OAC1E,YAAY,CAAC,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;OAC1G,YAAY,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;OACpF,CAAC,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,UAAU,IAAI,YAAY,CAAC,kBAAkB,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAErH,iHAAiH;AACjH,MAAM,kBAAkB,GAAG,CAAC,KAA8C,EAAE,EAAE,CAAC,CAAC;IAC9E,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,eAAe,EAAE,KAAK,CAAC,eAAe;IAClH,eAAe,EAAE,KAAK,CAAC,eAAe,EAAE,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;CACjF,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,KAAK,EAAE,aAAsB,EAAE,SAAkB,EAAoB,EAAE;IACzH,IAAI,QAAmC,EAAE,IAA+B,CAAC;IACzE,IAAI,CAAC;QACH,MAAM,aAAa,GAAG,gCAAgC,CAAC,aAAa,CAAC,EAAE,SAAS,GAAG,gCAAgC,CAAC,SAAS,CAAC,CAAC;QAC/H,QAAQ,GAAG,MAAM,gCAAgC,CAAC,aAAa,CAAC,CAAC;QACjE,IAAI,GAAG,MAAM,gCAAgC,CAAC,SAAS,CAAC,CAAC;IAC3D,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;IAAC,CAAC;IACjC,OAAO,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC,CAAC;AAEF,uEAAuE;AACvE,MAAM,YAAY,GAAG,CAAC,QAAiD,EAAE,OAA+C,EACtH,UAAqC,EAAE,OAA8C,EAAE,OAA+B,EACtH,GAAW,EAA2C,EAAE;IACxD,MAAM,MAAM,GAAG,yBAAyB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC9D,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAC1C,cAAc,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IACzH,cAAc,CAAC,UAAU,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACjF,MAAM,QAAQ,GAAG,UAAU,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3G,MAAM,QAAQ,GAAG,iCAAiC,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,SAAS,KAAK,QAAQ,CAAC,SAAS,CAAC,CAAC;IACnH,cAAc,CAAC,QAAQ,IAAI,QAAQ,IAAI,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,QAAQ;WACzE,QAAQ,CAAC,OAAO,KAAK,QAAQ,CAAC,GAAG,CAAC,OAAO,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACvF,cAAc,CAAC,MAAM,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,GAAG,QAAQ,CAAC,SAAS,IAAI,QAAQ,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;IAC9G,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF;;;;;yCAKyC;AACzC,MAAM,CAAC,MAAM,0CAA0C,GAAG,KAAK,EAAE,KAAc,EAAE,YAAqB,EACpG,eAAwB,EAAE,mBAA4B,EAAE,QAAiB,EACzE,eAA+B,IAAI,EAAoD,EAAE;IACzF,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,8CAA8C,CAAC,KAAK,CAAC,CAAC;QACvE,MAAM,OAAO,GAAG,6CAA6C,CAAC,YAAY,CAAC,CAAC;QAC5E,MAAM,OAAO,GAAG,6BAA6B,CAAC,mBAAmB,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;QACnG,MAAM,YAAY,GAAG,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,qCAAqC,CAAC,YAAY,CAAC,CAAC;QACxG,MAAM,UAAU,GAAG,MAAM,gCAAgC,CAAC,eAAe,CAAC,CAAC;QAC3E,MAAM,OAAO,GAAG,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,qCAAqC,CAAC,YAAY,CAAC,CAAC;QACzG,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAC5E,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;IAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG,KAAK,EAAE,KAAc,EAAE,aAAsB,EACtG,uBAAgC,EAAE,eAAwB,EAAE,mBAA4B,EAAE,QAAiB,EAC3G,eAA+B,IAAI,EAAoD,EAAE;IACzF,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,8CAA8C,CAAC,KAAK,CAAC,CAAC;QACvE,MAAM,QAAQ,GAAG,8CAA8C,CAAC,aAAa,CAAC,CAAC;QAC/E,MAAM,aAAa,GAAG,gCAAgC,CAAC,uBAAuB,CAAC,CAAC;QAChF,MAAM,eAAe,GAAG,gCAAgC,CAAC,eAAe,CAAC,CAAC;QAC1E,MAAM,OAAO,GAAG,6BAA6B,CAAC,mBAAmB,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;QACnG,MAAM,YAAY,GAAG,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,qCAAqC,CAAC,YAAY,CAAC,CAAC;QACxG,MAAM,kBAAkB,GAAG,MAAM,gCAAgC,CAAC,aAAa,CAAC,CAAC;QACjF,MAAM,UAAU,GAAG,MAAM,gCAAgC,CAAC,eAAe,CAAC,CAAC;QAC3E,MAAM,OAAO,GAAG,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,qCAAqC,CAAC,YAAY,CAAC,CAAC;QACzG,cAAc,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,CAAC;QACpE,cAAc,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;eACjD,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QAChF,cAAc,CAAC,YAAY,CAAC,kBAAkB,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACzF,OAAO,YAAY,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,kBAAkB,CAAC,UAAU,CAAC,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACrI,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;IAAC,CAAC;AACnC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.38.0",
+  "version": "32.39.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -27,8 +27,8 @@
     "@tsclass/tsclass": "^9.5.1"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^5.0.0",
-    "@git.zone/tsdoc": "^2.2.2",
+    "@git.zone/tsbuild": "^5.1.0",
+    "@git.zone/tsdoc": "^3.0.1",
     "@git.zone/tsrun": "^3.0.2",
     "@git.zone/tstest": "6.3.2",
     "@types/node": "26.6.2"

package/readme.md

@@ -728,6 +728,32 @@ Expiry must be after the caller-qualified time and no later than the referenced
 projection's effective DNS window (see [DNS Lease Renewals](#dns-lease-renewals));
 acceptance before that window starts rejects.
 
+A credential names one projection, but its key pair belongs to the node's managed VPN
+membership, which outlives it. Every workload add, removal, readiness change or policy change
+signs a new projection generation; none of them changes who the member is.
+`continuesRuntimeManagedVpnMembership(previous, next)` is that rule: `next` continues the
+membership when it is the same projection lineage (`id`) under the same protected authority and
+the same handoff lease (which names the node scope and carries the router incarnation), and is
+`previous` itself or a later generation. A protection bump, a fresh handoff (router
+reincarnation) or a new controller epoch is a new membership; an earlier generation or another
+projection of the same generation continues nothing. It validates both projections and rejects
+one that does not validate.
+
+`bindGetRuntimeManagedVpnCredentialSuccessor(response, previous, previousProjection, projection,
+trustedSession, now, renewal = null)` binds the credential for the successor. `response` is bound
+exactly as the response binder binds an answer to `{ session: trustedSession, projection }`, so
+the hub must still be selected and the expiry stays inside the successor's effective DNS window.
+It must also continue `previous`, the credential issued for `previousProjection` over the same
+session: the two projections are one membership and the transport, hub, authority, server key and
+client key pair are unchanged. Only `projection` and `expiresAt` move. The current effective
+window is the one limit: a membership whose current window does not cover `now` binds no
+successor, while the held credential's own expiry is not consulted, because a renewal or a
+successor may already have moved the window past it. The issuer binds the successor it states
+for a member with it, so the node keeps its key pair and its hub session across a projection
+change; a node binds a fresh answer with it to tell a successor, which keeps the live session,
+from a new membership, which replaces it. A previous credential for the same projection binds as
+its own successor, which is how a DNS lease renewal moves the expiry.
+
 These helpers perform content validation. Callers authenticate and fence the
 current physical peer and projection before and after native work, qualify time
 independently, and retain ownership through revocation and shutdown. The native

package/ts/00_commitinfo_data.ts

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

package/ts/data/networkcredential.ts

@@ -1,8 +1,10 @@
 import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
 import { runtimeNetworkAddressPlanContract, type TRuntimeNetworkVpnTransport } from './networkaddressplan.js';
 import { snapshotRuntimeSessionBinding, type IRuntimeSessionBinding } from './runtimesession.js';
-import { validateRuntimeNetworkProjection, type IRuntimeNetworkProjection } from './networkprojection.js';
-import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
+import { snapshotRuntimeNetworkProjection, validateRuntimeNetworkProjection,
+  type IRuntimeNetworkProjection } from './networkprojection.js';
+import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal,
+  type IRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
 import { captureNetwork, failNetwork, networkAuthorityId, networkCounter, networkEffectiveDnsWindow, networkEqual,
   networkId, networkIpv4, networkNoiseKey, networkRecord, networkReference, networkReferenceOf, networkSafe,
   networkSameScope, requireNetwork } from '../private/networkcontract.js';
@@ -14,7 +16,12 @@ export interface IGetRuntimeManagedVpnCredentialRequest {
 
 /** Secret response over the current authenticated physical peer only. Never
  * persist, hash, log, or include it in a signed network projection. The native
- * Noise owner validates and uses the keys; these shapes confer no TUN readiness. */
+ * Noise owner validates and uses the keys; these shapes confer no TUN readiness.
+ *
+ * One response names one exact projection, but its key pair belongs to the node's managed VPN
+ * membership, which outlives a projection: a credential for a successor projection of the same
+ * membership (`continuesRuntimeManagedVpnMembership`) carries the same transport, hub, authority and
+ * keys, bound by `bindGetRuntimeManagedVpnCredentialSuccessor`. */
 export interface IGetRuntimeManagedVpnCredentialResponse extends IGetRuntimeManagedVpnCredentialRequest {
   transport: TRuntimeNetworkVpnTransport;
   /** The cluster hub endpoint this node dials, named by the id its signed projection selected. */
@@ -72,6 +79,66 @@ export const bindGetRuntimeManagedVpnCredentialRequest = async (value: unknown,
   } catch { return failNetwork(); }
 };
 
+/**
+ * The membership rule of `continuesRuntimeManagedVpnMembership`, over projections already validated.
+ * 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: IRuntimeNetworkProjection, next: IRuntimeNetworkProjection): boolean =>
+  previous.handoff !== null && next.handoff !== null && previous.id === next.id
+  && networkEqual(networkReferenceOf(previous.protectedAuthority), networkReferenceOf(next.protectedAuthority))
+  && networkEqual(networkReferenceOf(previous.handoff), networkReferenceOf(next.handoff))
+  && (next.generation > previous.generation || networkEqual(networkReferenceOf(previous), networkReferenceOf(next)));
+
+/** What a membership's credential keeps across its projections: everything but the projection and the expiry. */
+const credentialIdentity = (value: IGetRuntimeManagedVpnCredentialResponse) => ({
+  transport: value.transport, hub: value.hub, authorityId: value.authorityId, serverPublicKey: value.serverPublicKey,
+  clientPublicKey: value.clientPublicKey, clientPrivateKey: value.clientPrivateKey,
+});
+
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export const continuesRuntimeManagedVpnMembership = async (previousValue: unknown, nextValue: unknown): Promise<boolean> => {
+  let previous: IRuntimeNetworkProjection, next: IRuntimeNetworkProjection;
+  try {
+    const previousInput = snapshotRuntimeNetworkProjection(previousValue), nextInput = snapshotRuntimeNetworkProjection(nextValue);
+    previous = await validateRuntimeNetworkProjection(previousInput);
+    next = await validateRuntimeNetworkProjection(nextInput);
+  } catch { return failNetwork(); }
+  return continuesMembership(previous, next);
+};
+
+/** The response binding over inputs already captured and validated. */
+const bindResponse = (response: IGetRuntimeManagedVpnCredentialResponse, request: IGetRuntimeManagedVpnCredentialRequest,
+  projection: IRuntimeNetworkProjection, renewal: IRuntimeNetworkDnsLeaseRenewal | null, trusted: IRuntimeSessionBinding,
+  now: number): IGetRuntimeManagedVpnCredentialResponse => {
+  const window = networkEffectiveDnsWindow(projection, renewal);
+  bindRequest(request, projection, trusted);
+  requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
+  requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
+  const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
+  const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
+  requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
+    && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
+  requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
+  return response;
+};
+
 /** Bind the secret response to the original request and the exact selected router
  * endpoint of the credential's transport, inside the projection's effective DNS window. renewalValue is the
  * bare lease renewal the caller already verified and admitted for this exact
@@ -88,15 +155,45 @@ export const bindGetRuntimeManagedVpnCredentialResponse = async (value: unknown,
     const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
     const projection = await validateRuntimeNetworkProjection(projectionValue);
     const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
-    const window = networkEffectiveDnsWindow(projection, renewal);
-    bindRequest(request, projection, trusted);
-    requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
-    requireNetwork(projection.router?.platformEndpointIds.includes(response.hub.id));
-    const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.hub.id);
-    const expected = runtimeNetworkAddressPlanContract.hubTransports.find(row => row.transport === response.transport);
-    requireNetwork(endpoint && expected && endpoint.protocol === expected.protocol
-      && endpoint.address === response.hub.address && endpoint.port === response.hub.port);
-    requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
-    return response;
+    return bindResponse(response, request, projection, renewal, trusted, now);
+  } catch { return failNetwork(); }
+};
+
+/**
+ * Bind the credential a node holds under its successor projection: `value` names `projectionValue`
+ * and is bound exactly as `bindGetRuntimeManagedVpnCredentialResponse` binds the answer to
+ * `{ session: trustedSession, projection }`, inside that projection's effective DNS window
+ * (`renewalValue`, as there). It must also continue `previousValue`, the credential issued for
+ * `previousProjectionValue` over the same session: the two projections are one membership
+ * (`continuesRuntimeManagedVpnMembership`) and the transport, hub, authority, server key and client
+ * key pair are unchanged. Only `projection` and `expiresAt` move. The current effective window
+ * alone bounds the successor, so a membership whose current window does not cover the
+ * caller-qualified `nowValue` binds no successor; the held credential's own expiry is not
+ * consulted, because a renewal or a successor may have moved the window past it.
+ *
+ * The issuer binds the successor it states for a member, so the node's session and key pair survive
+ * a workload, readiness or policy change; the node binds a fresh answer with it to tell a successor,
+ * which keeps its live session, from a new membership, which replaces it. A previous credential for
+ * the same projection binds too, which is how a renewal moves the expiry. Content binding only, as
+ * for the response binder.
+ */
+export const bindGetRuntimeManagedVpnCredentialSuccessor = async (value: unknown, previousValue: unknown,
+  previousProjectionValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown,
+  renewalValue: unknown | null = null): Promise<IGetRuntimeManagedVpnCredentialResponse> => {
+  try {
+    const response = snapshotGetRuntimeManagedVpnCredentialResponse(value);
+    const previous = snapshotGetRuntimeManagedVpnCredentialResponse(previousValue);
+    const previousInput = snapshotRuntimeNetworkProjection(previousProjectionValue);
+    const projectionInput = snapshotRuntimeNetworkProjection(projectionValue);
+    const trusted = snapshotRuntimeSessionBinding(trustedSessionValue), now = networkCounter(nowValue);
+    const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
+    const previousProjection = await validateRuntimeNetworkProjection(previousInput);
+    const projection = await validateRuntimeNetworkProjection(projectionInput);
+    const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
+    requireNetwork(continuesMembership(previousProjection, projection));
+    requireNetwork(networkEqual(previous.session, trusted)
+      && networkEqual(previous.projection, networkReferenceOf(previousProjection)));
+    requireNetwork(networkEqual(credentialIdentity(previous), credentialIdentity(response)));
+    return bindResponse(response, { session: trusted, projection: networkReferenceOf(projection) }, projection, renewal, trusted, now);
   } catch { return failNetwork(); }
 };