@serve.zone/interfaces 32.37.0 → 32.39.0

package/changelog.md

@@ -1,5 +1,57 @@
 # 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
+
+- Rollout: controllers must run this interfaces release before any node sends `discardedCaptures`
+  or a `not-kept` loss. A receiver on 32.37.0 or earlier reads a batch by its exact schema and
+  refuses such a batch on every retry.
+- A node may now discard workload log captures it cannot deliver, so a crash-looping workload no
+  longer fills its RAM-backed runtime directory. A `not-kept` answer to
+  `reportRuntimeAssignmentLogs` is the node's permission to discard for that session: it may drop
+  every ended capture completely, and each one that ends later under the answer, and may drop a
+  running capture's output, stating it as the new `not-kept` loss (`TRuntimeAssignmentLogLossReason`)
+  where a later session that keeps logs resumes. While a controller is away or slow, a node keeps
+  at most `runtimeAssignmentLogContract.maximumEndedCaptures` (64) ended captures awaiting
+  acknowledgement, holding at most `maximumEndedCaptureBytes` (64 MiB) together; past either bound
+  it discards the oldest completely. Every capture discarded whole, under either rule, is counted
+  in the optional batch field `discardedCaptures`, carried by the next batch it creates; the count
+  is node-level evidence that a controller keeping logs records against the node and the session,
+  and a lost acknowledgement can repeat it.
+- A log `sequence` number, once sent, is never sent again with other content. When `not-kept` lets
+  a node drop a batch it sent that is still unacknowledged, the capture's next batch takes a higher
+  number and opens with a `not-kept` loss, so a controller tells the node's discard from its own
+  loss by the batch after the gap.
+- `runtimeConfigContract.maximumLogBufferedBytes` (64 MiB) publishes the largest
+  `logs.maximumBufferedBytes`; `runtimeAssignmentLogContract.maximumEndedCaptureBytes` is the same
+  bound from the same source.
+
+### Maintenance
+
+- Release tooling currency: pnpm 12.6.0; `@git.zone/*` are already at their latest releases and
+  `@types/node` stays at 26.6.2. The 23 lockfile entries a mirror had rewritten to `sha1` integrity are restored to the
+  npmjs `sha512` integrity, each checked against its npmjs shasum first.
+
 ## 2026-09-29 - 32.37.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '32.37.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":"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"}

package/dist_ts/data/runtimeassignmentlogs.d.ts

@@ -30,17 +30,21 @@ export interface IRuntimeAssignmentLogLine {
  * - `capture-restart`: the node's capture restarted without its buffer, for example after a reboot
  *   emptied its disposable capture directory; how much was lost is unknown;
  * - `not-captured`: the container was started without output capture, so none of its output is
- *   available; how much there was is unknown.
+ *   available; how much there was is unknown;
+ * - `not-kept`: the node dropped this output while its controller kept no logs. Once a session
+ *   answered `not-kept`, the node may drop a running capture's output instead of holding it,
+ *   including a batch it sent that is still unacknowledged; a later session that keeps logs
+ *   receives the capture from where it stands, after this loss.
  */
-export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured';
+export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured' | 'not-kept';
 /**
  * Evidence of output that was lost, in the position of the stream where it was lost.
  *
  * `bytes` and `lines` count exactly what was dropped; both are `null` for `capture-restart` and
  * `not-captured`, whose extent the node cannot know, and both are stated for the other reasons.
  * A `line-cut` counts the cut bytes and no line, because the line itself was delivered; it names
- * the stream of that line. A `buffer-overflow` counts the dropped bytes and the whole lines among
- * them, and names a stream only when every dropped byte came from it.
+ * the stream of that line. A `buffer-overflow` or `not-kept` loss counts the dropped bytes and the
+ * whole lines among them, and names a stream only when every dropped byte came from it.
  */
 export interface IRuntimeAssignmentLogLoss {
     kind: 'lost';
@@ -57,10 +61,23 @@ export type TRuntimeAssignmentLogEntry = IRuntimeAssignmentLogLine | IRuntimeAss
  *
  * `captureId` names one capture of the attempt on its node: the node starts a new capture, with a
  * new id and `sequence` 1, whenever it cannot continue the previous one, and opens it with a
- * `capture-restart` loss. Within a capture `sequence` counts batches from 1 without gaps, and the
- * node sends the next batch only after the controller acknowledged the previous one, so a batch is
- * the one unit of retry. `final` states that no batch follows in this capture: the container is gone
- * and its output is drained. Only a final batch may be empty.
+ * `capture-restart` loss. Within a capture `sequence` counts batches from 1, and the node sends the
+ * next batch only after the controller acknowledged the previous one, so a batch is the one unit of
+ * retry. `final` states that no batch follows in this capture: the container is gone and its output
+ * is drained. Only a final batch may be empty.
+ *
+ * A sequence number, once sent, is never sent again with other content: a retry resends the batch
+ * unchanged, `discardedCaptures` included. Reusing a number would lose data silently, because a
+ * controller that stored the earlier batch while its acknowledgement was lost answers `replay` and
+ * drops the new content with its loss evidence. The node skips numbers only after dropping a
+ * running capture's batch it sent that is still unacknowledged, which only a `not-kept` answer
+ * permits: the next batch it
+ * sends of that capture takes a higher number it never sent and opens with a `not-kept` loss that
+ * counts what was dropped. Where the controller holds the dropped batch, because only its
+ * acknowledgement was lost, it sees no gap, and that loss also counts content it holds.
+ *
+ * `discardedCaptures` is node-level loss evidence, not part of this capture (see
+ * `runtimeAssignmentLogContract.maximumEndedCaptures`).
  */
 export interface IRuntimeAssignmentLogBatch {
     assignmentId: string;
@@ -69,6 +86,24 @@ export interface IRuntimeAssignmentLogBatch {
     sequence: number;
     entries: TRuntimeAssignmentLogEntry[];
     final: boolean;
+    /**
+     * How many ended captures the node discarded whole and unacknowledged since it last stated a
+     * count: past its ended-capture bound, or while a `not-kept` answer stood. The node states the
+     * count on the next batch it creates, of any capture, and counts afresh from there. The batch is
+     * then the unit of retry for the count: if the node discards that batch unacknowledged, the count
+     * passes on to the next batch, so a count whose acknowledgement was lost may reach the controller
+     * again inside a later count. It never names the discarded captures, because remembering them
+     * would grow without bound while the controller is away. Absent means none; stated, it is at
+     * least 1.
+     *
+     * The count belongs to the node, not to the assignment, attempt or capture of the batch that
+     * carries it. A controller that keeps logs records it against the node and the session the batch
+     * arrived on, once for each batch it accepts and never for a batch it answers `replay`, which it
+     * recorded when it accepted it. Counts are not idempotent: a lost acknowledgement can repeat a
+     * count, so their sum may exceed the captures discarded. A controller that keeps no logs does
+     * nothing with the count beyond answering `not-kept`; the node keeps it for a later session.
+     */
+    discardedCaptures?: number;
 }
 /** Pallet push over its current authenticated session. */
 export interface IReportRuntimeAssignmentLogsRequest {
@@ -81,12 +116,22 @@ export interface IReportRuntimeAssignmentLogsRequest {
  * - `accepted`: it holds the batch durably;
  * - `replay`: it already holds this batch and does not store it again;
  * - `not-kept`: it keeps no workload logs. It holds nothing, and the node sends no more batches on
- *   this session; a later session may be answered differently.
+ *   this session; a later session may be answered differently. The answer is the node's permission
+ *   to discard for that session: it may discard every ended capture completely, its content and
+ *   identity, and each capture that ends later while the answer stands, counting them in
+ *   `discardedCaptures`. A running capture stays within `logs.maximumBufferedBytes`, whose overflow
+ *   is a `buffer-overflow` loss, or the node drops its output, a sent and unacknowledged batch
+ *   included, and states a `not-kept` loss where delivery resumes.
  *
  * A controller answers every batch with one of these; it never leaves the method unhandled, so a
  * node can tell a controller that keeps no logs from a failure worth retrying. It never refuses a
- * batch for a gap in `sequence`: the node discards only what was acknowledged, so a missing batch
- * can only be the controller's own loss, which it records.
+ * batch for a gap in `sequence`. Every gap the node leaves by discarding carries evidence: the
+ * batch after numbers it skipped opens with a `not-kept` loss (see `IRuntimeAssignmentLogBatch`),
+ * and a capture it discarded whole is counted in `discardedCaptures`. A controller therefore reads
+ * a gap before a batch that opens with a `not-kept` loss as the node's discard, which that loss
+ * counts, and a gap before any other batch as its own loss, which it records. A capture whose
+ * final batch never arrives leaves no gap to read: it may still be running, and one discarded whole
+ * is counted but never named.
  */
 export type TRuntimeAssignmentLogsStatus = 'accepted' | 'replay' | 'not-kept';
 export interface IReportRuntimeAssignmentLogsResponse {
@@ -95,12 +140,37 @@ export interface IReportRuntimeAssignmentLogsResponse {
     captureId: string;
     sequence: number;
 }
+/**
+ * Rollout: a receiver on interfaces 32.37.0 or earlier reads a batch by its exact schema and
+ * refuses one that carries `discardedCaptures` or a `not-kept` loss, on every retry. A controller
+ * must therefore run a later release before any node sends either.
+ */
 export declare const runtimeAssignmentLogContract: Readonly<{
     readonly error: "Runtime assignment log contract rejected.";
     /** Pallet pushes; the controller persists metadata and payloads and acknowledges by sequence. */
     readonly delivery: "node-pushes-controller-acknowledges-each-batch";
-    /** A controller that keeps no logs answers `not-kept`, and the node stops for that session. */
+    /**
+     * A controller that keeps no logs answers `not-kept`, and the node stops for that session. It may
+     * then discard ended captures completely, counted in `discardedCaptures`, and drop running
+     * output, stated as a `not-kept` loss.
+     */
     readonly notKept: "node-stops-for-the-session";
+    /**
+     * The most ended captures a node keeps awaiting acknowledgement, while its controller is away or
+     * slow. An ended capture holds its buffer, cursor record and waiting batch in the node's RAM-backed
+     * runtime directory, and a crash-looping workload ends one per restart; 64 covers a burst of
+     * restarts across the node's workloads before any of them loses its tail. Past this bound, or past
+     * `maximumEndedCaptureBytes`, the node discards the oldest ended captures completely and counts
+     * them in the next batch's `discardedCaptures`.
+     */
+    readonly maximumEndedCaptures: 64;
+    /**
+     * The most bytes all ended captures awaiting acknowledgement hold together, measured as the node
+     * measures its `logs.maximumBufferedBytes` buffer. It equals the largest buffer a runtime config
+     * may set (`runtimeConfigContract.maximumLogBufferedBytes`), so one capture always fits whole, and
+     * it keeps the node's RAM-backed runtime directory from growing with the number of restarts.
+     */
+    readonly maximumEndedCaptureBytes: 67108864;
     /** The most entries in one batch. */
     readonly maximumEntriesPerBatch: 1024;
     /** The most UTF-8 bytes of `text` in one entry; a longer line travels as `partial` pieces. */

package/dist_ts/data/runtimeassignmentlogs.js

@@ -1,13 +1,38 @@
 import { snapshotRuntimeAssignment, validateRuntimeAssignment } from './runtimeassignment.js';
 import { snapshotRuntimeSessionBinding } from './runtimesession.js';
 import { captureNetwork, networkCounter, networkEqual, networkId, networkList, networkRecord, requireNetwork, } from '../private/networkcontract.js';
-import { isRuntimeLogPolicy } from '../private/runtimepolicy.js';
+import { isRuntimeLogPolicy, runtimePolicyLimits } from '../private/runtimepolicy.js';
+/**
+ * Rollout: a receiver on interfaces 32.37.0 or earlier reads a batch by its exact schema and
+ * refuses one that carries `discardedCaptures` or a `not-kept` loss, on every retry. A controller
+ * must therefore run a later release before any node sends either.
+ */
 export const runtimeAssignmentLogContract = Object.freeze({
     error: 'Runtime assignment log contract rejected.',
     /** Pallet pushes; the controller persists metadata and payloads and acknowledges by sequence. */
     delivery: 'node-pushes-controller-acknowledges-each-batch',
-    /** A controller that keeps no logs answers `not-kept`, and the node stops for that session. */
+    /**
+     * A controller that keeps no logs answers `not-kept`, and the node stops for that session. It may
+     * then discard ended captures completely, counted in `discardedCaptures`, and drop running
+     * output, stated as a `not-kept` loss.
+     */
     notKept: 'node-stops-for-the-session',
+    /**
+     * The most ended captures a node keeps awaiting acknowledgement, while its controller is away or
+     * slow. An ended capture holds its buffer, cursor record and waiting batch in the node's RAM-backed
+     * runtime directory, and a crash-looping workload ends one per restart; 64 covers a burst of
+     * restarts across the node's workloads before any of them loses its tail. Past this bound, or past
+     * `maximumEndedCaptureBytes`, the node discards the oldest ended captures completely and counts
+     * them in the next batch's `discardedCaptures`.
+     */
+    maximumEndedCaptures: 64,
+    /**
+     * The most bytes all ended captures awaiting acknowledgement hold together, measured as the node
+     * measures its `logs.maximumBufferedBytes` buffer. It equals the largest buffer a runtime config
+     * may set (`runtimeConfigContract.maximumLogBufferedBytes`), so one capture always fits whole, and
+     * it keeps the node's RAM-backed runtime directory from growing with the number of restarts.
+     */
+    maximumEndedCaptureBytes: runtimePolicyLimits.maximumLogBufferedBytes,
     /** The most entries in one batch. */
     maximumEntriesPerBatch: 1024,
     /** The most UTF-8 bytes of `text` in one entry; a longer line travels as `partial` pieces. */
@@ -27,7 +52,7 @@ catch {
 } };
 const encoder = new TextEncoder();
 const streams = ['stdout', 'stderr'];
-const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured'];
+const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured', 'not-kept'];
 const statuses = ['accepted', 'replay', 'not-kept'];
 const literalOf = (valueArg, allowedArg) => {
     requireNetwork(allowedArg.includes(valueArg));
@@ -74,12 +99,13 @@ const entryOf = (valueArg) => {
     return valueArg.kind === 'lost' ? lossOf(valueArg) : lineOf(valueArg);
 };
 const batchOf = (valueArg) => {
-    const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final']);
+    const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final'], ['discardedCaptures']);
     const entries = networkList(value.entries, runtimeAssignmentLogContract.maximumEntriesPerBatch, entryOf);
     requireNetwork(typeof value.final === 'boolean' && (entries.length > 0 || value.final));
     return {
         assignmentId: networkId(value.assignmentId), attemptId: networkId(value.attemptId),
         captureId: networkId(value.captureId), sequence: networkCounter(value.sequence), entries, final: value.final,
+        ...(Object.hasOwn(value, 'discardedCaptures') ? { discardedCaptures: networkCounter(value.discardedCaptures) } : {}),
     };
 };
 /** Detached exact-schema snapshot of one batch, bounded like a whole report. */
@@ -138,4 +164,4 @@ export const bindReportRuntimeAssignmentLogsResponse = (valueArg, requestArg) =>
         && response.sequence === batch.sequence);
     return response;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignmentlogs.js","sourceRoot":"","sources":["../../ts/data/runtimeassignmentlogs.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeassignmentlogs.js","sourceRoot":"","sources":["../../ts/data/runtimeassignmentlogs.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/runtimeconfig.d.ts

@@ -112,6 +112,7 @@ export declare const runtimeConfigContract: Readonly<{
     readonly maximumTargetPorts: 64;
     readonly maximumReadinessDurationMs: 3600000;
     readonly maximumLogRetentionMs: 31536000000;
+    readonly maximumLogBufferedBytes: 67108864;
 }>;
 /**
  * Detached exact-schema snapshot for synchronous persistence assertions. Digest

package/dist_ts/data/runtimeconfig.js

@@ -9,6 +9,7 @@ export const runtimeConfigContract = Object.freeze({
     maximumTargetPorts: 64,
     maximumReadinessDurationMs: runtimePolicyLimits.maximumReadinessDurationMs,
     maximumLogRetentionMs: runtimePolicyLimits.maximumLogRetentionMs,
+    maximumLogBufferedBytes: runtimePolicyLimits.maximumLogBufferedBytes,
 });
 const fail = (messageArg) => { throw new Error(messageArg); };
 const encoder = new TextEncoder();
@@ -212,4 +213,4 @@ export const bindRuntimeConfigToAssignment = async (configArg, assignmentArg) =>
         fail('runtime config lacks exact assignment platform evidence');
     return { config, assignment, platformEvidence };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeconfig.js","sourceRoot":"","sources":["../../ts/data/runtimeconfig.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtimeconfig.js","sourceRoot":"","sources":["../../ts/data/runtimeconfig.ts"],"names":[],"mappings":"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"}

package/dist_ts/private/runtimepolicy.d.ts

@@ -14,6 +14,8 @@ export declare const runtimePolicyLimits: Readonly<{
     readonly maximumIdentityNumber: number;
     readonly maximumReadinessDurationMs: 3600000;
     readonly maximumLogRetentionMs: 31536000000;
+    /** The largest `logs.maximumBufferedBytes`; a node's ended captures share the same bound. */
+    readonly maximumLogBufferedBytes: 67108864;
 }>;
 export type TRuntimePolicyFailure = (messageArg: string) => never;
 export declare const isBoundedInteger: (valueArg: unknown, minimumArg: number, maximumArg: number) => valueArg is number;

package/dist_ts/private/runtimepolicy.js

@@ -13,6 +13,8 @@ export const runtimePolicyLimits = Object.freeze({
     maximumIdentityNumber: 2 ** 31 - 1,
     maximumReadinessDurationMs: 3_600_000,
     maximumLogRetentionMs: 31_536_000_000,
+    /** The largest `logs.maximumBufferedBytes`; a node's ended captures share the same bound. */
+    maximumLogBufferedBytes: 67_108_864,
 });
 export const isBoundedInteger = (valueArg, minimumArg, maximumArg) => typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && !Object.is(valueArg, -0)
     && valueArg >= minimumArg && valueArg <= maximumArg;
@@ -29,7 +31,7 @@ export const isRuntimeMemoryBytes = (valueArg) => isBoundedInteger(valueArg, run
 export const isRuntimeIdentityNumber = (valueArg) => isBoundedInteger(valueArg, 0, runtimePolicyLimits.maximumIdentityNumber);
 export const isRuntimeLogPolicy = (valueArg) => isExactRecord(valueArg, ['maximumLineBytes', 'maximumBufferedBytes', 'retentionMs'])
     && isBoundedInteger(valueArg.maximumLineBytes, 1, 1_048_576)
-    && isBoundedInteger(valueArg.maximumBufferedBytes, 1, 67_108_864)
+    && isBoundedInteger(valueArg.maximumBufferedBytes, 1, runtimePolicyLimits.maximumLogBufferedBytes)
     && valueArg.maximumBufferedBytes >= valueArg.maximumLineBytes
     && isBoundedInteger(valueArg.retentionMs, 1, runtimePolicyLimits.maximumLogRetentionMs);
 const timingKeys = ['initialDelayMs', 'startupGraceMs', 'intervalMs', 'timeoutMs',
@@ -87,4 +89,4 @@ export const assertRuntimeReadiness = (valueArg, selectsTcpTargetArg, failArg) =
         previousCode = code;
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.37.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
@@ -1241,7 +1267,8 @@ pushes one `IRuntimeAssignmentLogBatch { assignmentId, attemptId, captureId, seq
 final }` from the node to its controller. Logs are the controller's to keep
 (`IRuntimeConfig.logs`); the node's capture files are disposable transport artifacts, so the node
 pushes and the controller persists. The node discards a batch only after the controller
-acknowledged it, and sends the next one only then.
+acknowledged it, and sends the next one only then. Two rules below let it discard more: a
+`not-kept` answer, and its bound on ended captures awaiting acknowledgement.
 
 - `entries` are in capture order. A `line` entry `{ stream, timestampNs, text, partial }` is one
   piece of one line: `text` holds no `\n`, invalid UTF-8 becomes U+FFFD, and a line longer than
@@ -1250,13 +1277,19 @@ acknowledged it, and sends the next one only then.
 - A `lost` entry `{ reason, stream, timestampNs, bytes, lines }` is evidence of output that did not
   arrive, placed where it was lost: `buffer-overflow` (the node's buffer reached
   `logs.maximumBufferedBytes` and it dropped the oldest bytes), `line-cut` (the rest of a line
-  beyond `maximumLineBytes`, right after that line's last piece), `capture-restart` and
-  `not-captured` (a container started without capture). The last two cannot know how much was
+  beyond `maximumLineBytes`, right after that line's last piece), `capture-restart`,
+  `not-captured` (a container started without capture) and `not-kept` (output the node dropped
+  while its controller kept no logs). `capture-restart` and `not-captured` cannot know how much was
   lost and state `bytes` and `lines` as `null`; the others count exactly.
-- `captureId` names one capture of the attempt. `sequence` counts that capture's batches from 1.
-  `final` states that the container is gone and its output drained; only a final batch may be
-  empty. A report is at most 1 024 entries and one mebibyte of canonical JSON, and timestamps are
-  nanoseconds since the Unix epoch as decimal digits.
+- `captureId` names one capture of the attempt. `sequence` counts that capture's batches from 1,
+  and a number once sent is never sent again with other content (below). `final` states that the
+  container is gone and its output drained; only a final batch may be empty. A report is at most 1 024
+  entries and one mebibyte of canonical JSON, and timestamps are nanoseconds since the Unix epoch
+  as decimal digits.
+- `discardedCaptures`, optional, is node-level loss evidence carried by whichever batch the node
+  creates next: how many ended captures it discarded whole, under its ended-capture bound or a
+  `not-kept` answer (below), since it last stated a count. It is absent for none and at least 1
+  when stated.
 
 The answer `{ status, assignmentId, captureId, sequence }` (`TRuntimeAssignmentLogsStatus`) is
 `accepted`, `replay` for a batch the controller already holds, or `not-kept` from a controller that
@@ -1264,8 +1297,50 @@ keeps no workload logs: it holds nothing, and the node sends no more batches on
 later session may be answered differently). A controller answers every batch with one of the
 three and never leaves the method unhandled, so a node tells a controller that keeps no logs from
 a failure worth retrying. A controller must therefore handle the method before a node that
-captures logs runs against it. The controller never refuses a batch for a gap in `sequence`: the
-node only discards what was acknowledged, so a gap is the controller's own loss, which it records.
+captures logs runs against it. Likewise, a receiver on interfaces 32.37.0 or earlier reads a batch
+by its exact schema and refuses one that carries `discardedCaptures` or a `not-kept` loss, on every
+retry: controllers must run a later interfaces release before any node sends either.
+
+A sequence number, once sent, is never sent again with other content; a retry resends the batch
+unchanged, its `discardedCaptures` included. Reuse would lose data silently: a controller that
+stored the batch while its acknowledgement was lost answers `replay` and drops the new content
+with its loss evidence. So when the node drops a running capture's batch it sent that is still
+unacknowledged, which only `not-kept` permits, the next batch it sends of that capture takes a higher number it never
+sent and opens with a `not-kept` loss that counts what was dropped. A controller that holds the
+dropped batch sees no gap, and that loss also counts content it holds.
+
+The controller never refuses a batch for a gap in `sequence`. Every gap the node leaves by
+discarding carries evidence: the batch after skipped numbers opens with a `not-kept` loss, and a
+capture discarded whole is counted in `discardedCaptures`. A gap before a batch that opens with a
+`not-kept` loss is therefore the node's discard, which that loss counts; a gap before any other
+batch is the controller's own loss, which it records. A capture whose final batch never arrives
+leaves no gap to read: it may still be running, and one discarded whole is counted, never named.
+
+`not-kept` is the node's permission to discard for the session that answered it. The node may
+discard every ended capture completely, content and identity, and each capture that ends later
+while the answer stands, counting them in `discardedCaptures`. A running capture stays within
+`logs.maximumBufferedBytes` (overflow is a `buffer-overflow` loss), or the node drops its output,
+a sent and unacknowledged batch included. A later session that keeps logs receives each running
+capture from where it stands, after a `not-kept` loss that counts what was dropped.
+
+While a controller is away or slow, ended captures wait for their final batch to be acknowledged,
+and a crash-looping workload ends one per restart. A node therefore keeps at most
+`runtimeAssignmentLogContract.maximumEndedCaptures` (64) ended captures awaiting acknowledgement,
+holding at most `maximumEndedCaptureBytes` (64 MiB, the largest `logs.maximumBufferedBytes` a
+config may set, `runtimeConfigContract.maximumLogBufferedBytes`, so one capture always fits)
+together. Past either bound it discards the oldest
+ended captures completely and counts them in the next batch's `discardedCaptures`. It does not name
+them: remembering them would grow without bound while the controller is away. The batch is the
+unit of retry for the count: a batch the node discards unacknowledged passes its count on to the
+next batch, so a count whose acknowledgement was lost may arrive again inside a later one.
+
+The count belongs to the node, not to the assignment, attempt or capture of the batch that carries
+it. A controller that keeps logs records it against the node and the session the batch arrived on,
+once for each batch it accepts and never for a batch it answers `replay`. Counts are not
+idempotent: a lost acknowledgement can repeat a count, so their sum may exceed the captures
+discarded. A controller that keeps no logs does nothing with the count beyond answering
+`not-kept`; the node keeps it for a later session.
+
 `bindReportRuntimeAssignmentLogsRequest(request, assignment, logPolicy, trustedSession)` checks the
 session, that the assignment is this node's and carries the batch's attempt, and every line's
 joined length against the policy. `bindReportRuntimeAssignmentLogsResponse(response, request)`

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '32.37.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(); }
 };

package/ts/data/runtimeassignmentlogs.ts

@@ -6,7 +6,7 @@ import { snapshotRuntimeSessionBinding } from './runtimesession.js';
 import {
   captureNetwork, networkCounter, networkEqual, networkId, networkList, networkRecord, requireNetwork,
 } from '../private/networkcontract.js';
-import { isRuntimeLogPolicy } from '../private/runtimepolicy.js';
+import { isRuntimeLogPolicy, runtimePolicyLimits } from '../private/runtimepolicy.js';
 
 /** The container output a log line was written to. */
 export type TRuntimeAssignmentLogStream = 'stdout' | 'stderr';
@@ -39,9 +39,14 @@ export interface IRuntimeAssignmentLogLine {
  * - `capture-restart`: the node's capture restarted without its buffer, for example after a reboot
  *   emptied its disposable capture directory; how much was lost is unknown;
  * - `not-captured`: the container was started without output capture, so none of its output is
- *   available; how much there was is unknown.
+ *   available; how much there was is unknown;
+ * - `not-kept`: the node dropped this output while its controller kept no logs. Once a session
+ *   answered `not-kept`, the node may drop a running capture's output instead of holding it,
+ *   including a batch it sent that is still unacknowledged; a later session that keeps logs
+ *   receives the capture from where it stands, after this loss.
  */
-export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured';
+export type TRuntimeAssignmentLogLossReason =
+  | 'buffer-overflow' | 'line-cut' | 'capture-restart' | 'not-captured' | 'not-kept';
 
 /**
  * Evidence of output that was lost, in the position of the stream where it was lost.
@@ -49,8 +54,8 @@ export type TRuntimeAssignmentLogLossReason = 'buffer-overflow' | 'line-cut' | '
  * `bytes` and `lines` count exactly what was dropped; both are `null` for `capture-restart` and
  * `not-captured`, whose extent the node cannot know, and both are stated for the other reasons.
  * A `line-cut` counts the cut bytes and no line, because the line itself was delivered; it names
- * the stream of that line. A `buffer-overflow` counts the dropped bytes and the whole lines among
- * them, and names a stream only when every dropped byte came from it.
+ * the stream of that line. A `buffer-overflow` or `not-kept` loss counts the dropped bytes and the
+ * whole lines among them, and names a stream only when every dropped byte came from it.
  */
 export interface IRuntimeAssignmentLogLoss {
   kind: 'lost';
@@ -69,10 +74,23 @@ export type TRuntimeAssignmentLogEntry = IRuntimeAssignmentLogLine | IRuntimeAss
  *
  * `captureId` names one capture of the attempt on its node: the node starts a new capture, with a
  * new id and `sequence` 1, whenever it cannot continue the previous one, and opens it with a
- * `capture-restart` loss. Within a capture `sequence` counts batches from 1 without gaps, and the
- * node sends the next batch only after the controller acknowledged the previous one, so a batch is
- * the one unit of retry. `final` states that no batch follows in this capture: the container is gone
- * and its output is drained. Only a final batch may be empty.
+ * `capture-restart` loss. Within a capture `sequence` counts batches from 1, and the node sends the
+ * next batch only after the controller acknowledged the previous one, so a batch is the one unit of
+ * retry. `final` states that no batch follows in this capture: the container is gone and its output
+ * is drained. Only a final batch may be empty.
+ *
+ * A sequence number, once sent, is never sent again with other content: a retry resends the batch
+ * unchanged, `discardedCaptures` included. Reusing a number would lose data silently, because a
+ * controller that stored the earlier batch while its acknowledgement was lost answers `replay` and
+ * drops the new content with its loss evidence. The node skips numbers only after dropping a
+ * running capture's batch it sent that is still unacknowledged, which only a `not-kept` answer
+ * permits: the next batch it
+ * sends of that capture takes a higher number it never sent and opens with a `not-kept` loss that
+ * counts what was dropped. Where the controller holds the dropped batch, because only its
+ * acknowledgement was lost, it sees no gap, and that loss also counts content it holds.
+ *
+ * `discardedCaptures` is node-level loss evidence, not part of this capture (see
+ * `runtimeAssignmentLogContract.maximumEndedCaptures`).
  */
 export interface IRuntimeAssignmentLogBatch {
   assignmentId: string;
@@ -81,6 +99,24 @@ export interface IRuntimeAssignmentLogBatch {
   sequence: number;
   entries: TRuntimeAssignmentLogEntry[];
   final: boolean;
+  /**
+   * How many ended captures the node discarded whole and unacknowledged since it last stated a
+   * count: past its ended-capture bound, or while a `not-kept` answer stood. The node states the
+   * count on the next batch it creates, of any capture, and counts afresh from there. The batch is
+   * then the unit of retry for the count: if the node discards that batch unacknowledged, the count
+   * passes on to the next batch, so a count whose acknowledgement was lost may reach the controller
+   * again inside a later count. It never names the discarded captures, because remembering them
+   * would grow without bound while the controller is away. Absent means none; stated, it is at
+   * least 1.
+   *
+   * The count belongs to the node, not to the assignment, attempt or capture of the batch that
+   * carries it. A controller that keeps logs records it against the node and the session the batch
+   * arrived on, once for each batch it accepts and never for a batch it answers `replay`, which it
+   * recorded when it accepted it. Counts are not idempotent: a lost acknowledgement can repeat a
+   * count, so their sum may exceed the captures discarded. A controller that keeps no logs does
+   * nothing with the count beyond answering `not-kept`; the node keeps it for a later session.
+   */
+  discardedCaptures?: number;
 }
 
 /** Pallet push over its current authenticated session. */
@@ -95,12 +131,22 @@ export interface IReportRuntimeAssignmentLogsRequest {
  * - `accepted`: it holds the batch durably;
  * - `replay`: it already holds this batch and does not store it again;
  * - `not-kept`: it keeps no workload logs. It holds nothing, and the node sends no more batches on
- *   this session; a later session may be answered differently.
+ *   this session; a later session may be answered differently. The answer is the node's permission
+ *   to discard for that session: it may discard every ended capture completely, its content and
+ *   identity, and each capture that ends later while the answer stands, counting them in
+ *   `discardedCaptures`. A running capture stays within `logs.maximumBufferedBytes`, whose overflow
+ *   is a `buffer-overflow` loss, or the node drops its output, a sent and unacknowledged batch
+ *   included, and states a `not-kept` loss where delivery resumes.
  *
  * A controller answers every batch with one of these; it never leaves the method unhandled, so a
  * node can tell a controller that keeps no logs from a failure worth retrying. It never refuses a
- * batch for a gap in `sequence`: the node discards only what was acknowledged, so a missing batch
- * can only be the controller's own loss, which it records.
+ * batch for a gap in `sequence`. Every gap the node leaves by discarding carries evidence: the
+ * batch after numbers it skipped opens with a `not-kept` loss (see `IRuntimeAssignmentLogBatch`),
+ * and a capture it discarded whole is counted in `discardedCaptures`. A controller therefore reads
+ * a gap before a batch that opens with a `not-kept` loss as the node's discard, which that loss
+ * counts, and a gap before any other batch as its own loss, which it records. A capture whose
+ * final batch never arrives leaves no gap to read: it may still be running, and one discarded whole
+ * is counted but never named.
  */
 export type TRuntimeAssignmentLogsStatus = 'accepted' | 'replay' | 'not-kept';
 
@@ -111,12 +157,37 @@ export interface IReportRuntimeAssignmentLogsResponse {
   sequence: number;
 }
 
+/**
+ * Rollout: a receiver on interfaces 32.37.0 or earlier reads a batch by its exact schema and
+ * refuses one that carries `discardedCaptures` or a `not-kept` loss, on every retry. A controller
+ * must therefore run a later release before any node sends either.
+ */
 export const runtimeAssignmentLogContract = Object.freeze({
   error: 'Runtime assignment log contract rejected.',
   /** Pallet pushes; the controller persists metadata and payloads and acknowledges by sequence. */
   delivery: 'node-pushes-controller-acknowledges-each-batch',
-  /** A controller that keeps no logs answers `not-kept`, and the node stops for that session. */
+  /**
+   * A controller that keeps no logs answers `not-kept`, and the node stops for that session. It may
+   * then discard ended captures completely, counted in `discardedCaptures`, and drop running
+   * output, stated as a `not-kept` loss.
+   */
   notKept: 'node-stops-for-the-session',
+  /**
+   * The most ended captures a node keeps awaiting acknowledgement, while its controller is away or
+   * slow. An ended capture holds its buffer, cursor record and waiting batch in the node's RAM-backed
+   * runtime directory, and a crash-looping workload ends one per restart; 64 covers a burst of
+   * restarts across the node's workloads before any of them loses its tail. Past this bound, or past
+   * `maximumEndedCaptureBytes`, the node discards the oldest ended captures completely and counts
+   * them in the next batch's `discardedCaptures`.
+   */
+  maximumEndedCaptures: 64,
+  /**
+   * The most bytes all ended captures awaiting acknowledgement hold together, measured as the node
+   * measures its `logs.maximumBufferedBytes` buffer. It equals the largest buffer a runtime config
+   * may set (`runtimeConfigContract.maximumLogBufferedBytes`), so one capture always fits whole, and
+   * it keeps the node's RAM-backed runtime directory from growing with the number of restarts.
+   */
+  maximumEndedCaptureBytes: runtimePolicyLimits.maximumLogBufferedBytes,
   /** The most entries in one batch. */
   maximumEntriesPerBatch: 1024,
   /** The most UTF-8 bytes of `text` in one entry; a longer line travels as `partial` pieces. */
@@ -132,7 +203,7 @@ const fail = (): never => { throw new Error(runtimeAssignmentLogContract.error);
 const safe = <T>(operationArg: () => T): T => { try { return operationArg(); } catch { return fail(); } };
 const encoder = new TextEncoder();
 const streams = ['stdout', 'stderr'] as const;
-const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured'] as const;
+const lossReasons = ['buffer-overflow', 'line-cut', 'capture-restart', 'not-captured', 'not-kept'] as const;
 const statuses = ['accepted', 'replay', 'not-kept'] as const;
 
 const literalOf = <TLiteral extends string>(valueArg: unknown, allowedArg: readonly TLiteral[]): TLiteral => {
@@ -184,12 +255,15 @@ const entryOf = (valueArg: unknown): TRuntimeAssignmentLogEntry => {
 };
 
 const batchOf = (valueArg: unknown): IRuntimeAssignmentLogBatch => {
-  const value = networkRecord(valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final']);
+  const value = networkRecord(
+    valueArg, ['assignmentId', 'attemptId', 'captureId', 'sequence', 'entries', 'final'], ['discardedCaptures'],
+  );
   const entries = networkList(value.entries, runtimeAssignmentLogContract.maximumEntriesPerBatch, entryOf);
   requireNetwork(typeof value.final === 'boolean' && (entries.length > 0 || value.final));
   return {
     assignmentId: networkId(value.assignmentId), attemptId: networkId(value.attemptId),
     captureId: networkId(value.captureId), sequence: networkCounter(value.sequence), entries, final: value.final,
+    ...(Object.hasOwn(value, 'discardedCaptures') ? { discardedCaptures: networkCounter(value.discardedCaptures) } : {}),
   };
 };
 

package/ts/data/runtimeconfig.ts

@@ -133,6 +133,7 @@ export const runtimeConfigContract = Object.freeze({
   maximumTargetPorts: 64,
   maximumReadinessDurationMs: runtimePolicyLimits.maximumReadinessDurationMs,
   maximumLogRetentionMs: runtimePolicyLimits.maximumLogRetentionMs,
+  maximumLogBufferedBytes: runtimePolicyLimits.maximumLogBufferedBytes,
 } as const);
 
 const fail: (messageArg: string) => never = (messageArg) => { throw new Error(messageArg); };

package/ts/private/runtimepolicy.ts

@@ -15,6 +15,8 @@ export const runtimePolicyLimits = Object.freeze({
   maximumIdentityNumber: 2 ** 31 - 1,
   maximumReadinessDurationMs: 3_600_000,
   maximumLogRetentionMs: 31_536_000_000,
+  /** The largest `logs.maximumBufferedBytes`; a node's ended captures share the same bound. */
+  maximumLogBufferedBytes: 67_108_864,
 } as const);
 
 export type TRuntimePolicyFailure = (messageArg: string) => never;
@@ -43,7 +45,7 @@ export const isRuntimeIdentityNumber = (valueArg: unknown): valueArg is number =
 export const isRuntimeLogPolicy = (valueArg: unknown): valueArg is IRuntimeConfigLogPolicy =>
   isExactRecord(valueArg, ['maximumLineBytes', 'maximumBufferedBytes', 'retentionMs'])
   && isBoundedInteger(valueArg.maximumLineBytes, 1, 1_048_576)
-  && isBoundedInteger(valueArg.maximumBufferedBytes, 1, 67_108_864)
+  && isBoundedInteger(valueArg.maximumBufferedBytes, 1, runtimePolicyLimits.maximumLogBufferedBytes)
   && valueArg.maximumBufferedBytes >= valueArg.maximumLineBytes
   && isBoundedInteger(valueArg.retentionMs, 1, runtimePolicyLimits.maximumLogRetentionMs);