@zlink-systems/framework 0.25.0 → 0.26.0

package/dist/runtime/channels/channel-runtime-manager.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { RoutingId } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
@@ -27,11 +28,6 @@ export declare class ZLinkChannelRuntimeManager {
     fanoutTopology(channelName: string): {
         descriptors: readonly import("../foundation").FanoutPublisherDescriptor[];
     };
-    getFanoutListenerStatus(channelName: string): {
-        channelName: string;
-        endpoint: string;
-        observedAt: Date;
-    };
     observeClientServerTopology(channelName: string, changed: () => void): () => void;
     observeFanoutTopology(channelName: string, changed: () => void): () => void;
     configureLocationAutoConnect(runtime: ZLinkLocationRuntime, stores: ZLinkLocationRuntimeStores, options: ZLinkLocationOptionOverrides, events?: ZLinkLocationEventSink): void;
@@ -65,6 +61,7 @@ export declare class ZLinkChannelRuntimeManager {
     dispose(signal?: AbortSignal): Promise<void>;
 }
 export interface ZLinkChannelRuntimeManagerOptions {
+    readonly listenerRecords?: ZLinkListenerRecords;
     readonly internalRouteSendHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeSendHandler>;
     readonly internalRouteRequestHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeRequestHandler>;
     readonly monitoringAdapter?: ZLinkMonitoringBackendAdapter;

package/dist/runtime/channels/channel-runtime-manager.js

@@ -18,7 +18,7 @@ class ZLinkChannelRuntimeManager {
         this.registration = registration;
         const applicationJobQueue = options.applicationJobQueue ??
             new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)());
-        this.sockets = new channel_socket_registry_1.ZLinkChannelSocketRegistry(registration, adapter, context, options.monitoringAdapter, options.oneWayFailureSink, applicationJobQueue);
+        this.sockets = new channel_socket_registry_1.ZLinkChannelSocketRegistry(registration, adapter, context, options.monitoringAdapter, options.oneWayFailureSink, applicationJobQueue, options.listenerRecords);
         const codecs = {
             serializers: registration.messageSerializers
         };
@@ -65,17 +65,6 @@ class ZLinkChannelRuntimeManager {
     fanoutTopology(channelName) {
         return { descriptors: this.sockets.fanoutActiveTargets(channelName) };
     }
-    getFanoutListenerStatus(channelName) {
-        const endpoint = this.sockets.fanoutPublisherEndpoint(channelName);
-        if (endpoint === undefined) {
-            throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' has not reported a bound listener.`);
-        }
-        return {
-            channelName,
-            endpoint,
-            observedAt: new Date()
-        };
-    }
     observeClientServerTopology(channelName, changed) {
         const monitor = this.sockets.clientServerMonitoringSource(channelName);
         monitor.onEvent(changed);

package/dist/runtime/channels/channel-socket-registry.d.ts

@@ -1,3 +1,4 @@
+import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { type ZLinkClientServerServerDescriptor, type ZLinkFanoutPublisherDescriptor } from '../../contracts';
 import { type ZLinkFrameworkRegistration } from '../configuration';
 import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
@@ -48,11 +49,14 @@ export declare class ZLinkChannelSocketRegistry {
     private readonly clientServerMonitorHandlers;
     private readonly fanoutMonitorHandlers;
     private readonly fanoutTopologyHandlers;
-    constructor(registration: ZLinkFrameworkRegistration, adapter: ZLinkChannelBackendAdapter, context: ZLinkBackendContext, monitoringAdapter?: ZLinkMonitoringBackendAdapter | undefined, oneWayFailureSink?: ((error: unknown) => void) | undefined, applicationJobQueue?: ApplicationJobQueue | undefined);
+    private readonly listenerRecords;
+    constructor(registration: ZLinkFrameworkRegistration, adapter: ZLinkChannelBackendAdapter, context: ZLinkBackendContext, monitoringAdapter?: ZLinkMonitoringBackendAdapter | undefined, oneWayFailureSink?: ((error: unknown) => void) | undefined, applicationJobQueue?: ApplicationJobQueue | undefined, listenerRecords?: ZLinkListenerRecords);
     dispose(): Promise<void>;
     clientDealer(channelName: string): ZLinkBackendDealerSocket;
     channelRouter(channelName: string): ZLinkBackendRouterSocket;
     clientServerServerIdentity(channelName: string): ZLinkClientServerServerSocketIdentity;
+    fanoutPublisherEndpoint(channelName: string): string | undefined;
+    private recordListener;
     clientServerServerSocket(channelName: string): ZLinkBackendRouterSocket;
     clientServerServerWeight(channelName: string): number;
     setClientServerServerWeight(channelName: string, weight: number): void;
@@ -90,7 +94,6 @@ export declare class ZLinkChannelSocketRegistry {
     startLocalClientServerConnections(): void;
     clientServerMonitoringSource(channelName: string): ZLinkBackendSocketMonitor;
     clientServerActiveTargets(channelName: string): readonly Pick<ClientServerDiscoveryDescriptor, 'serverRoutingId' | 'weight' | 'state'>[];
-    hasKnownClientServerTargets(channelName: string): boolean;
     fanoutActiveTargets(channelName: string): readonly import("../foundation/service-discovery-registry").FanoutPublisherDescriptor[];
     admitFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, connectionId: string): boolean;
     removeFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, connectionId: string): boolean;
@@ -130,7 +133,18 @@ export declare class ZLinkChannelSocketRegistry {
     private openConfiguredClientServerConnection;
     private admitConfiguredClientServerConnection;
     private drainClientServerControl;
-    private requestClientServerEndpointTermination;
+    /**
+     * Ends the current logical admission of this connection: later replies of
+     * the fenced attempt no longer apply and its ready target is withdrawn.
+     */
+    private endClientServerAdmission;
+    /**
+     * A peer deadline or an invalid pushed control ends only the current logical
+     * admission. The connect intent stays with Core, which owns the endpoint
+     * reconnect (transport liveness §6); the service handshake starts again on
+     * the existing admission path.
+     */
+    private restartClientServerAdmission;
     private applyClientServerDescriptorUpdate;
     private ensureClientServerLivenessTimer;
     private drainSocketMonitors;
@@ -143,7 +157,6 @@ export declare class ZLinkChannelSocketRegistry {
     private pushClientServerDescriptorUpdate;
     private allocateClientServerProbeId;
     publisher(channelName: string): ZLinkBackendPublisherSocket;
-    fanoutPublisherEndpoint(channelName: string): string | undefined;
     routeRouter(routerChannelId: string): ZLinkBackendRouterSocket;
     routeMeshSocket(routerChannelId: string): ZLinkBackendRouterSocket;
     routeMeshWeight(routerChannelId: string): number;

package/dist/runtime/channels/channel-socket-registry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelSocketRegistry = void 0;
+const listener_records_1 = require("../foundation/listener-records");
 const contracts_1 = require("../../contracts");
 const internal_event_contracts_1 = require("../diagnostics/internal-event-contracts");
 const configuration_1 = require("../configuration");
@@ -51,13 +52,15 @@ class ZLinkChannelSocketRegistry {
     clientServerMonitorHandlers = new Map();
     fanoutMonitorHandlers = new Map();
     fanoutTopologyHandlers = new Map();
-    constructor(registration, adapter, context, monitoringAdapter, oneWayFailureSink, applicationJobQueue) {
+    listenerRecords;
+    constructor(registration, adapter, context, monitoringAdapter, oneWayFailureSink, applicationJobQueue, listenerRecords) {
         this.registration = registration;
         this.adapter = adapter;
         this.context = context;
         this.monitoringAdapter = monitoringAdapter;
         this.oneWayFailureSink = oneWayFailureSink;
         this.applicationJobQueue = applicationJobQueue;
+        this.listenerRecords = listenerRecords ?? new listener_records_1.ZLinkListenerRecords();
     }
     async dispose() {
         const clientServerConnections = [...new Set(this.clientServerConnections.values())];
@@ -177,14 +180,15 @@ class ZLinkChannelSocketRegistry {
             });
         }
         this.channelRouters.set(channelName, router);
+        const endpoint = advertisedEndpoint(router.lastEndpoint ?? channel.server.bind, channel.server.advertiseHost);
+        this.recordListener('clientServer', channelName, endpoint);
         if (!this.clientServerServerDescriptors.has(channelName)) {
-            const boundEndpoint = router.lastEndpoint ?? channel.server.bind;
             this.clientServerServerDescriptors.set(channelName, {
                 channelName,
                 serverRid: identity.serverRid,
                 lifecycleGeneration: identity.lifecycleGeneration,
                 descriptorRevision: 1n,
-                endpoint: advertisedEndpoint(boundEndpoint, channel.server.advertiseHost),
+                endpoint,
                 weight: publicWeight,
                 state: contracts_1.ZLinkFrameworkRuntimeState.Serving,
                 securityIdentity: 'default',
@@ -196,20 +200,19 @@ class ZLinkChannelSocketRegistry {
         return router;
     }
     clientServerServerIdentity(channelName) {
-        const router = this.channelRouter(channelName);
+        this.channelRouter(channelName);
         const identity = this.clientServerIdentities.get(channelName);
-        const channel = this.registration.channels.get(channelName);
-        if (identity === undefined || channel?.server === undefined) {
+        const endpoint = this.listenerRecords.endpoint('clientServer', channelName);
+        if (identity === undefined || endpoint === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`Channel server '${channelName}' is not registered.`);
         }
-        const boundEndpoint = router.lastEndpoint ?? channel.server.bind;
-        if (boundEndpoint === undefined || boundEndpoint.length === 0) {
-            throw new configuration_1.ZLinkConfigurationException(`Channel server '${channelName}' did not report its bound endpoint.`);
-        }
-        return {
-            ...identity,
-            endpoint: advertisedEndpoint(boundEndpoint, channel.server.advertiseHost)
-        };
+        return { ...identity, endpoint };
+    }
+    fanoutPublisherEndpoint(channelName) {
+        return this.listenerRecords.endpoint('fanout', channelName);
+    }
+    recordListener(kind, name, endpoint) {
+        this.listenerRecords.record(kind, name, endpoint);
     }
     clientServerServerSocket(channelName) {
         return this.channelRouter(channelName);
@@ -275,8 +278,7 @@ class ZLinkChannelSocketRegistry {
             monitor,
             aliases: new Set([connectionId]),
             callbacksByAlias: new Map([[connectionId, callbacks]]),
-            physicalConnectionId: Symbol(connectionId),
-            terminationRequested: false
+            physicalConnectionId: Symbol(connectionId)
         };
         this.clientServerConnections.set(connectionId, connection);
         this.ensureClientServerLivenessTimer();
@@ -290,7 +292,7 @@ class ZLinkChannelSocketRegistry {
                 const routingId = event.routingId === undefined ? undefined : String(event.routingId);
                 if (event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.ConnectionReady) {
                     // This single-endpoint DEALER also receives its disconnected ready-count snapshot.
-                    if (event.value === 0n || connection.terminationRequested)
+                    if (event.value === 0n)
                         return;
                     connection.physicalConnectionId = Symbol(connectionId);
                     connection.admissionAttempt = undefined;
@@ -304,24 +306,9 @@ class ZLinkChannelSocketRegistry {
                     event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedNoDetail ||
                     event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedProtocol ||
                     event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedAuth) {
-                    if (connection.terminationRequested &&
-                        (event.remoteAddr !== connection.endpoint ||
-                            (event.nativeEvent !== internal_event_contracts_1.ZLinkSocketNativeEventType.Disconnected &&
-                                event.nativeEvent !== internal_event_contracts_1.ZLinkSocketNativeEventType.Closed)))
-                        return;
-                    connection.physicalConnectionId = Symbol(connectionId);
-                    connection.admissionAttempt = undefined;
-                    if (connection.readyConnectionId !== undefined) {
-                        this.removeReadyConnection(connection.readyConnectionId);
-                    }
-                    for (const currentCallbacks of [...connection.callbacksByAlias.values()]) {
-                        currentCallbacks.onTerminated(routingId, event.remoteAddr);
-                    }
-                    if (connection.terminationRequested) {
-                        connection.terminationRequested = false;
-                        // Explicit disconnect removes intent; restore it once after this endpoint closes.
-                        connection.dealer.connect(connection.endpoint);
-                    }
+                    // Core owns the endpoint reconnect (transport liveness §6); the
+                    // connect intent stays and the next READY starts a new admission.
+                    this.endClientServerAdmission(connectionId, connection, routingId, event.remoteAddr);
                 }
             });
             dealer.connect(endpoint);
@@ -588,9 +575,6 @@ class ZLinkChannelSocketRegistry {
                 ? 1
                 : 0);
     }
-    hasKnownClientServerTargets(channelName) {
-        return this.clientServerDiscovery.clientServerDescriptors(channelName).length > 0;
-    }
     fanoutActiveTargets(channelName) {
         return this.clientServerDiscovery.fanoutEndpoints(channelName);
     }
@@ -689,7 +673,7 @@ class ZLinkChannelSocketRegistry {
             if (connection.deadlineAt === undefined)
                 continue;
             if (nowMs >= connection.deadlineAt) {
-                this.requestClientServerEndpointTermination(connectionId, connection);
+                this.restartClientServerAdmission(connectionId, connection);
                 continue;
             }
             if (connection.nextProbeAt === undefined || nowMs < connection.nextProbeAt)
@@ -993,8 +977,6 @@ class ZLinkChannelSocketRegistry {
         }
     }
     drainClientServerControl(connectionId, connection) {
-        if (connection.terminationRequested)
-            return;
         for (;;) {
             if (!connection.readablePoller.wait(0))
                 return;
@@ -1025,7 +1007,7 @@ class ZLinkChannelSocketRegistry {
                 this.applyClientServerDescriptorUpdate(connectionId, connection, record.admission);
             }
             catch (error) {
-                this.requestClientServerEndpointTermination(connectionId, connection);
+                this.restartClientServerAdmission(connectionId, connection);
                 this.oneWayFailureSink?.(error);
                 return;
             }
@@ -1034,18 +1016,30 @@ class ZLinkChannelSocketRegistry {
             }
         }
     }
-    requestClientServerEndpointTermination(connectionId, connection) {
-        if (connection.terminationRequested)
-            return;
-        connection.terminationRequested = true;
+    /**
+     * Ends the current logical admission of this connection: later replies of
+     * the fenced attempt no longer apply and its ready target is withdrawn.
+     */
+    endClientServerAdmission(connectionId, connection, routingId, endpoint) {
         connection.physicalConnectionId = Symbol(connectionId);
         connection.admissionAttempt = undefined;
-        this.removeReadyConnection(connectionId);
-        try {
-            connection.dealer.disconnect(connection.endpoint);
+        if (connection.readyConnectionId !== undefined) {
+            this.removeReadyConnection(connection.readyConnectionId);
         }
-        catch (error) {
-            this.oneWayFailureSink?.(error);
+        for (const callbacks of [...connection.callbacksByAlias.values()]) {
+            callbacks.onTerminated(routingId, endpoint);
+        }
+    }
+    /**
+     * A peer deadline or an invalid pushed control ends only the current logical
+     * admission. The connect intent stays with Core, which owns the endpoint
+     * reconnect (transport liveness §6); the service handshake starts again on
+     * the existing admission path.
+     */
+    restartClientServerAdmission(connectionId, connection) {
+        this.endClientServerAdmission(connectionId, connection, undefined, connection.endpoint);
+        for (const callbacks of [...connection.callbacksByAlias.values()]) {
+            callbacks.onTransportReady('', connection.endpoint);
         }
     }
     applyClientServerDescriptorUpdate(connectionId, connection, admission) {
@@ -1223,21 +1217,14 @@ class ZLinkChannelSocketRegistry {
         applyFanoutPublisherSocketOptions(publisher, channel);
         publisher.bind(channel.publisher.bind);
         this.publishers.set(channelName, publisher);
+        const endpoint = (0, configuration_1.buildAdvertisedEndpoint)(publisher.lastEndpoint ?? channel.publisher.bind, channel.publisher.advertiseHost);
+        if (endpoint !== undefined && endpoint.length > 0) {
+            this.recordListener('fanout', channelName, endpoint);
+        }
         this.fanoutPublisherNextBeacon.set(channelName, performance.now() + CLIENT_SERVER_PROBE_INTERVAL_MS);
         this.ensureClientServerLivenessTimer();
         return publisher;
     }
-    fanoutPublisherEndpoint(channelName) {
-        const channel = this.registration.channels.get(channelName);
-        const publisher = this.publishers.get(channelName);
-        const boundEndpoint = publisher?.lastEndpoint;
-        if (channel?.publisher === undefined ||
-            boundEndpoint === undefined ||
-            boundEndpoint.length === 0) {
-            return undefined;
-        }
-        return advertisedEndpoint(boundEndpoint, channel.publisher.advertiseHost);
-    }
     routeRouter(routerChannelId) {
         const existing = this.routeRouters.get(routerChannelId);
         if (existing !== undefined) {

package/dist/runtime/channels/channel-transports.d.ts

@@ -1,7 +1,6 @@
 import { type ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-values';
 import type { ZLinkBackendMeshNode, ZLinkBackendSpot } from '../backend/contracts';
 import { ZLinkFrameworkException } from '../../contracts';
-import type { ZLinkFanoutListenerStatus } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -13,7 +12,6 @@ export interface ZLinkChannelClientTransport {
     request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     tryPublish?(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
-    getFanoutListenerStatus?(channelName: string): ZLinkFanoutListenerStatus;
 }
 export type ZLinkChannelClientTransportSource = ZLinkChannelClientTransport | (() => ZLinkChannelClientTransport | undefined);
 export interface ZLinkSpotPublisherClientTransport {
@@ -43,7 +41,6 @@ interface ZLinkChannelTransportRuntime {
     request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    getFanoutListenerStatus(channelName: string): ZLinkFanoutListenerStatus;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
     routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;

package/dist/runtime/channels/fanout-location-runtime.js

@@ -101,8 +101,9 @@ class ZLinkFanoutLocationRuntime {
         for (const [channelName, channel] of this.registration.channels) {
             if (channel.publisher === undefined)
                 continue;
-            const publisher = this.sockets.publisher(channelName);
-            const endpoint = advertisedEndpoint(publisher.lastEndpoint ?? channel.publisher.bind ?? '', channel.publisher.advertiseHost);
+            // Opening the publisher binds it and fixes its advertised endpoint.
+            this.sockets.publisher(channelName);
+            const endpoint = this.sockets.fanoutPublisherEndpoint(channelName) ?? '';
             if (endpoint.length === 0) {
                 throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' did not report a bound endpoint.`);
             }
@@ -316,13 +317,6 @@ class ZLinkFanoutLocationRuntime {
     }
 }
 exports.ZLinkFanoutLocationRuntime = ZLinkFanoutLocationRuntime;
-function advertisedEndpoint(boundEndpoint, advertiseHost) {
-    const result = (0, configuration_1.buildAdvertisedEndpoint)(boundEndpoint, advertiseHost);
-    if (result === undefined) {
-        throw new configuration_1.ZLinkConfigurationException(`Fanout publisher bound endpoint '${boundEndpoint}' cannot be advertised.`);
-    }
-    return result;
-}
 function fanoutConnectionId(descriptor) {
     return (`${descriptor.channelName}\0${String(descriptor.publisherRid)}\0` +
         descriptor.lifecycleGeneration.toString());

package/dist/runtime/execution/index.d.ts

@@ -23,11 +23,14 @@ export declare class ZLinkSpotSerialTurn {
     private owner;
     private frameworkOperationsBlocked;
     constructor(postResume: (turn: ZLinkSpotSerialTurn, resume: () => void, reject: (reason: unknown) => void) => boolean, executionClaim: ZLinkExecutionBarrierClaim | undefined, yieldAllowed: boolean);
-    bindExecutionClaim(claim: ZLinkExecutionBarrierClaim | undefined): void;
     get isSuspended(): boolean;
+    /** False when a seal that does not drain yielded turns won before this resume. */
+    resumeExecutionClaim(): boolean;
     releaseBoundExecutionClaim(): void;
     get suspended(): Promise<void>;
     bindOwner(owner: Promise<unknown>): void;
+    /** Settles when the whole turn ends by any path, including yielded continuations. */
+    get completion(): Promise<void>;
     blockFrameworkOperations(): void;
     ensureFrameworkOperationAllowed(): void;
     resetSuspension(): void;
@@ -51,9 +54,18 @@ export declare function captureZLinkExecutionTurn(): ZLinkCapturedExecutionTurn
 export declare function isCurrentZLinkSpotSerialTurn(executor: ZLinkSpotSerialTurnExecutorLike): boolean;
 export interface ZLinkExecutionBarrierSeal {
     readonly generation: bigint;
+    /**
+     * A Spot Close seal waits for yielded turns accepted before it and lets them
+     * resume (Spot address messaging §7 step 2); a relocation seal does not, and
+     * their continuation fails (execution gate §4).
+     */
+    readonly drainsYieldedTurns: boolean;
 }
 export interface ZLinkExecutionBarrierClaim {
     release(): void;
+    /** The turn yielded; it no longer runs until resume() admits it again. */
+    suspend(): void;
+    resume(): boolean;
 }
 /**
  * Seals application-lane admission and waits for every active Promise turn to
@@ -63,22 +75,20 @@ export interface ZLinkExecutionBarrierClaim {
 export declare class ZLinkExecutionBarrier {
     private generation;
     private activeClaims;
+    private suspendedClaims;
     private currentSeal;
     private readonly admissionWaiters;
     private readonly quiescenceWaiters;
     private committed;
+    get isSealed(): boolean;
     enter(): Promise<ZLinkExecutionBarrierClaim>;
-    /**
-     * Re-enters a previously yielded application turn only while admission is
-     * open. A continuation must fail instead of waiting behind a relocation
-     * seal that already won the turn-boundary race.
-     */
-    tryEnter(): ZLinkExecutionBarrierClaim | undefined;
-    seal(): ZLinkExecutionBarrierSeal;
+    seal(drainsYieldedTurns?: boolean): ZLinkExecutionBarrierSeal;
     waitForQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
     abort(seal: ZLinkExecutionBarrierSeal): boolean;
     commit(seal: ZLinkExecutionBarrierSeal): boolean;
     isCurrent(seal: ZLinkExecutionBarrierSeal): boolean;
+    private isQuiescent;
+    private notifyQuiescence;
     private createClaim;
     private requireCurrent;
 }

package/dist/runtime/execution/index.js

@@ -43,15 +43,13 @@ class ZLinkSpotSerialTurn {
         this.executionClaim = executionClaim;
         this.yieldAllowed = yieldAllowed;
     }
-    bindExecutionClaim(claim) {
-        if (this.executionClaim !== undefined) {
-            throw new Error('ZLink Spot serial turn already owns an execution claim.');
-        }
-        this.executionClaim = claim;
-    }
     get isSuspended() {
         return this.suspendSignaled;
     }
+    /** False when a seal that does not drain yielded turns won before this resume. */
+    resumeExecutionClaim() {
+        return this.executionClaim?.resume() ?? true;
+    }
     releaseBoundExecutionClaim() {
         this.executionClaim?.release();
         this.executionClaim = undefined;
@@ -68,6 +66,10 @@ class ZLinkSpotSerialTurn {
     bindOwner(owner) {
         this.owner = owner;
     }
+    /** Settles when the whole turn ends by any path, including yielded continuations. */
+    get completion() {
+        return (this.owner ?? Promise.resolve()).then(() => undefined, () => undefined);
+    }
     blockFrameworkOperations() {
         this.frameworkOperationsBlocked = true;
     }
@@ -109,7 +111,7 @@ class ZLinkSpotSerialTurn {
             return;
         }
         this.suspendSignaled = true;
-        this.releaseBoundExecutionClaim();
+        this.executionClaim?.suspend();
         this.suspendedResolve?.();
     }
     awaitResumePermit() {
@@ -175,10 +177,14 @@ function isCurrentZLinkSpotSerialTurn(executor) {
 class ZLinkExecutionBarrier {
     generation = 0n;
     activeClaims = 0;
+    suspendedClaims = 0;
     currentSeal;
     admissionWaiters = [];
     quiescenceWaiters = new Set();
     committed = false;
+    get isSealed() {
+        return this.currentSeal !== undefined || this.committed;
+    }
     async enter() {
         if (this.committed) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
@@ -190,36 +196,28 @@ class ZLinkExecutionBarrier {
         }
         return this.createClaim();
     }
-    /**
-     * Re-enters a previously yielded application turn only while admission is
-     * open. A continuation must fail instead of waiting behind a relocation
-     * seal that already won the turn-boundary race.
-     */
-    tryEnter() {
-        if (this.committed || this.currentSeal !== undefined) {
-            return undefined;
-        }
-        return this.createClaim();
-    }
-    seal() {
+    seal(drainsYieldedTurns = false) {
         if (this.committed) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
         }
         if (this.currentSeal !== undefined) {
             throw new Error('ZLink execution barrier is already sealed.');
         }
-        const seal = Object.freeze({ generation: ++this.generation });
+        const seal = Object.freeze({ generation: ++this.generation, drainsYieldedTurns });
         this.currentSeal = seal;
         return seal;
     }
     async waitForQuiescence(seal, signal) {
         this.requireCurrent(seal);
-        if (this.activeClaims === 0)
+        if (this.isQuiescent(seal))
             return;
         if (signal?.aborted === true)
             throw signal.reason;
         await new Promise((resolve, reject) => {
             const complete = () => {
+                if (!this.isQuiescent(seal))
+                    return;
+                this.quiescenceWaiters.delete(complete);
                 signal?.removeEventListener('abort', abort);
                 resolve();
             };
@@ -255,20 +253,48 @@ class ZLinkExecutionBarrier {
     isCurrent(seal) {
         return this.currentSeal?.generation === seal.generation;
     }
+    isQuiescent(seal) {
+        return this.activeClaims === 0 && (!seal.drainsYieldedTurns || this.suspendedClaims === 0);
+    }
+    notifyQuiescence() {
+        for (const waiter of [...this.quiescenceWaiters])
+            waiter();
+    }
     createClaim() {
         this.activeClaims++;
-        let released = false;
+        let state = 'active';
+        const release = () => {
+            if (state === 'released')
+                return;
+            if (state === 'active')
+                this.activeClaims--;
+            else
+                this.suspendedClaims--;
+            state = 'released';
+            this.notifyQuiescence();
+        };
         return {
-            release: () => {
-                if (released)
+            release,
+            suspend: () => {
+                if (state !== 'active')
                     return;
-                released = true;
+                state = 'suspended';
                 this.activeClaims--;
-                if (this.activeClaims === 0) {
-                    for (const waiter of this.quiescenceWaiters)
-                        waiter();
-                    this.quiescenceWaiters.clear();
+                this.suspendedClaims++;
+                this.notifyQuiescence();
+            },
+            resume: () => {
+                if (state !== 'suspended')
+                    return state === 'active';
+                if (this.committed ||
+                    (this.currentSeal !== undefined && !this.currentSeal.drainsYieldedTurns)) {
+                    release();
+                    return false;
                 }
+                state = 'active';
+                this.suspendedClaims--;
+                this.activeClaims++;
+                return true;
             }
         };
     }

package/dist/runtime/execution/serial-execution-queue.d.ts

@@ -34,6 +34,7 @@ export declare class ZLinkSerialExecutionQueue {
     private readonly executeRecord;
     private readonly application;
     private readonly lifecycle;
+    private activeLifecycle?;
     private readonly ownerTimeBudget;
     private readonly lifecycleBurstLimit;
     private nextAcceptedSequence;
@@ -56,16 +57,14 @@ export declare class ZLinkSerialExecutionQueue {
      * It remains held through handler terminal completion.
      */
     submitPreAdmitted<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
-    snapshot(): {
-        readonly applicationMessages: number;
-        readonly applicationBytes: number;
-        readonly lifecycleMessages: number;
-        readonly lifecycleBytes: number;
-    };
+    /** Holds lifecycle FIFO through an operation result while its application turns can run. */
+    submitLifecycleOperation<T>(operation: () => Promise<T> | T): Promise<T>;
     get hasPendingWork(): boolean;
     whenIdle(): Promise<void>;
     /** Stops new submissions while allowing the accepted FIFO to finish. */
     close(): Promise<void>;
+    /** Stops admission within the lifecycle operation that owns this queue's close. */
+    closeAdmission(): void;
     private admit;
     private scheduleDrain;
     private drain;