@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/diagnostics/topology-runtime-projections.js

@@ -7,39 +7,121 @@ const runtime_observation_queue_1 = require("./runtime-observation-queue");
 const runtime_state_projections_1 = require("../foundation/runtime-state-projections");
 var runtime_observation_queue_2 = require("./runtime-observation-queue");
 Object.defineProperty(exports, "RuntimeEventQueue", { enumerable: true, get: function () { return runtime_observation_queue_2.RuntimeEventQueue; } });
+class TopologyStatusSources {
+    read;
+    subscribe;
+    equivalent;
+    sources = new Map();
+    constructor(read, subscribe, equivalent) {
+        this.read = read;
+        this.subscribe = subscribe;
+        this.equivalent = equivalent;
+    }
+    snapshot(channelName) {
+        let source = this.sources.get(channelName);
+        const current = source?.lastSnapshot;
+        if (current !== undefined && (0, runtime_state_projections_1.topologyObservationIsTerminal)(current.state))
+            return current;
+        const snapshot = this.read(channelName, current?.sequence ?? 0n);
+        if (source === undefined) {
+            source = { observers: new Set() };
+            this.sources.set(channelName, source);
+        }
+        const published = this.publish(channelName, source, snapshot);
+        if (source.stop === undefined && !(0, runtime_state_projections_1.topologyObservationIsTerminal)(published.state)) {
+            source.stop = this.subscribe(channelName, () => this.snapshot(channelName));
+        }
+        return published;
+    }
+    observe(channelName, capacity, signal) {
+        const queue = new runtime_observation_queue_1.RuntimeEventQueue(capacity, signal);
+        const snapshot = this.snapshot(channelName);
+        const current = this.sources.get(channelName);
+        current.observers.add(queue);
+        queue.onClose(() => {
+            current.observers.delete(queue);
+        });
+        this.deliver(queue, snapshot, channelName);
+        return queue;
+    }
+    hostStateChanged() {
+        for (const channelName of this.sources.keys())
+            this.snapshot(channelName);
+    }
+    stopObservers() {
+        for (const [channelName, source] of this.sources) {
+            if (source.lastSnapshot === undefined ||
+                (0, runtime_state_projections_1.topologyObservationIsTerminal)(source.lastSnapshot.state))
+                continue;
+            this.publish(channelName, source, {
+                ...source.lastSnapshot,
+                state: contracts_1.ZLinkTopologyState.Stopped,
+                isReady: false
+            });
+        }
+    }
+    publish(channelName, source, snapshot) {
+        const previous = source.lastSnapshot;
+        if (previous !== undefined && this.equivalent(previous, snapshot))
+            return previous;
+        source.lastSnapshot = {
+            ...snapshot,
+            sequence: (previous?.sequence ?? 0n) + 1n,
+            observedAt: new Date()
+        };
+        for (const queue of source.observers)
+            this.deliver(queue, source.lastSnapshot, channelName);
+        if ((0, runtime_state_projections_1.topologyObservationIsTerminal)(source.lastSnapshot.state)) {
+            source.stop?.();
+            source.stop = undefined;
+        }
+        return source.lastSnapshot;
+    }
+    deliver(queue, snapshot, channelName) {
+        if ((0, runtime_state_projections_1.topologyObservationIsTerminal)(snapshot.state))
+            queue.seal(snapshot, channelName);
+        else
+            queue.push(snapshot, channelName);
+    }
+}
+function sameTopologyState(left, right) {
+    return left.state === right.state && left.isReady === right.isReady;
+}
+function samePeer(left, right) {
+    return (left.nodeRid === right.nodeRid &&
+        left.state === right.state &&
+        left.unavailableReason === right.unavailableReason);
+}
+function sameClientServerStatus(left, right) {
+    return (sameTopologyState(left, right) &&
+        left.localRole === right.localRole &&
+        left.readyTargetCount === right.readyTargetCount &&
+        left.targets.length === right.targets.length &&
+        left.targets.every((target, index) => samePeer(target, right.targets[index]) && target.weight === right.targets[index].weight));
+}
+function sameFanoutStatus(left, right) {
+    return (sameTopologyState(left, right) &&
+        left.readyPublisherCount === right.readyPublisherCount &&
+        left.publishers.length === right.publishers.length &&
+        left.publishers.every((publisher, index) => samePeer(publisher, right.publishers[index])));
+}
 class ZLinkClientServerRuntimeProjection {
     runtime;
     hostState;
-    sequence = 0n;
-    hostObservers = new Set();
+    sources = new TopologyStatusSources((channelName, sequence) => this.snapshotCore(channelName, sequence), (channelName, changed) => this.requireRuntime().observeClientServerTopology(channelName, changed), sameClientServerStatus);
     constructor(runtime, hostState = () => contracts_1.ZLinkFrameworkRuntimeState.Serving) {
         this.runtime = runtime;
         this.hostState = hostState;
     }
     snapshot(channelName) {
-        return this.snapshotCore(channelName);
+        return this.sources.snapshot(channelName);
     }
-    snapshotCore(channelName) {
+    snapshotCore(channelName, sequence) {
         const topology = this.requireRuntime().clientServerTopology(channelName);
         if (topology.localRole === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`ClientServer channel '${channelName}' is not registered.`);
         }
-        const targets = topology.descriptors.map((descriptor) => ({
-            nodeRid: descriptor.serverRoutingId,
-            weight: descriptor.weight,
-            state: descriptor.state === 'serving'
-                ? contracts_1.ZLinkPeerState.Ready
-                : descriptor.state === 'retiring'
-                    ? contracts_1.ZLinkPeerState.Draining
-                    : descriptor.state === 'preparing'
-                        ? contracts_1.ZLinkPeerState.Connecting
-                        : contracts_1.ZLinkPeerState.NotConnected,
-            unavailableReason: descriptor.state === 'serving' && descriptor.weight > 0
-                ? undefined
-                : descriptor.state === 'retiring'
-                    ? contracts_1.ZLinkTopologyReason.Draining
-                    : contracts_1.ZLinkTopologyReason.NoReadyTarget
-        }));
+        const targets = topology.descriptors.map((descriptor) => peerStatusForAvailability(descriptor, contracts_1.ZLinkTopologyReason.NoReadyTarget));
         const readyTargetCount = targets.filter((target) => target.state === contracts_1.ZLinkPeerState.Ready && target.weight > 0).length;
         const hostState = this.hostState();
         const isReady = (0, runtime_state_projections_1.topologyRuntimeIsReady)(hostState, readyTargetCount);
@@ -50,74 +132,21 @@ class ZLinkClientServerRuntimeProjection {
             isReady,
             readyTargetCount,
             targets,
-            sequence: this.sequence,
+            sequence,
             observedAt: new Date()
         };
     }
     observe(channelName, capacity = runtime_observation_queue_1.ZLINK_DEFAULT_TERMINAL_OBSERVATION_CAPACITY, signal) {
-        const runtime = this.requireRuntime();
-        const queue = new runtime_observation_queue_1.RuntimeEventQueue(capacity, signal);
-        let lastSnapshot = this.snapshotCore(channelName);
-        const stop = runtime.observeClientServerTopology(channelName, () => {
-            this.sequence += 1n;
-            lastSnapshot = this.snapshotCore(channelName);
-            queue.push(lastSnapshot, channelName);
-        });
-        const hostObserver = {
-            changed: () => {
-                this.sequence += 1n;
-                lastSnapshot = this.snapshotCore(channelName);
-                queue.push(lastSnapshot, channelName);
-            },
-            stop: () => {
-                this.sequence += 1n;
-                let current = lastSnapshot;
-                try {
-                    current = this.snapshotCore(channelName);
-                    lastSnapshot = current;
-                }
-                catch {
-                    // The last complete projection remains valid after native teardown.
-                }
-                queue.seal({
-                    ...current,
-                    state: contracts_1.ZLinkTopologyState.Stopped,
-                    isReady: false,
-                    sequence: this.sequence,
-                    observedAt: new Date()
-                }, channelName);
-            }
-        };
-        this.hostObservers.add(hostObserver);
-        queue.onClose(() => {
-            stop();
-            this.hostObservers.delete(hostObserver);
-        });
-        return queue;
+        return this.sources.observe(channelName, capacity, signal);
     }
     hostStateChanged() {
-        for (const observer of this.hostObservers) {
-            try {
-                observer.changed();
-            }
-            catch {
-                // Monitoring projection failures do not change host lifecycle results.
-            }
-        }
+        this.sources.hostStateChanged();
     }
     stopObservers() {
-        for (const observer of [...this.hostObservers]) {
-            try {
-                observer.stop();
-            }
-            catch {
-                // The observer is still removed when its terminal snapshot fails.
-            }
-        }
-        this.hostObservers.clear();
+        this.sources.stopObservers();
     }
     isReady(channelName) {
-        return this.snapshotCore(channelName).isReady;
+        return this.snapshot(channelName).isReady;
     }
     requireRuntime() {
         const runtime = this.runtime();
@@ -130,33 +159,18 @@ exports.ZLinkClientServerRuntimeProjection = ZLinkClientServerRuntimeProjection;
 class ZLinkFanoutRuntimeProjection {
     runtime;
     hostState;
-    sequence = 0n;
-    hostObservers = new Set();
+    sources = new TopologyStatusSources((channelName, sequence) => this.snapshotCore(channelName, sequence), (channelName, changed) => this.requireRuntime().observeFanoutTopology(channelName, changed), sameFanoutStatus);
     constructor(runtime, hostState = () => contracts_1.ZLinkFrameworkRuntimeState.Serving) {
         this.runtime = runtime;
         this.hostState = hostState;
     }
     snapshot(channelName) {
-        return this.snapshotCore(channelName);
+        return this.sources.snapshot(channelName);
     }
-    snapshotCore(channelName) {
+    snapshotCore(channelName, sequence) {
         const publishers = this.requireRuntime()
             .fanoutTopology(channelName)
-            .descriptors.map((descriptor) => ({
-            nodeRid: descriptor.publisherRoutingId,
-            state: descriptor.state === 'serving'
-                ? contracts_1.ZLinkPeerState.Ready
-                : descriptor.state === 'retiring'
-                    ? contracts_1.ZLinkPeerState.Draining
-                    : descriptor.state === 'preparing'
-                        ? contracts_1.ZLinkPeerState.Connecting
-                        : contracts_1.ZLinkPeerState.NotConnected,
-            unavailableReason: descriptor.state === 'serving'
-                ? undefined
-                : descriptor.state === 'retiring'
-                    ? contracts_1.ZLinkTopologyReason.Draining
-                    : contracts_1.ZLinkTopologyReason.NoReadyTarget
-        }));
+            .descriptors.map((descriptor) => peerStatusForAvailability(descriptor, contracts_1.ZLinkTopologyReason.NoReadyPeer));
         const readyPublisherCount = publishers.filter((publisher) => publisher.state === contracts_1.ZLinkPeerState.Ready).length;
         const hostState = this.hostState();
         const hostReady = (0, runtime_state_projections_1.runtimeStateIsReady)(hostState);
@@ -170,71 +184,18 @@ class ZLinkFanoutRuntimeProjection {
             isReady: (0, runtime_state_projections_1.topologyRuntimeIsReady)(hostState, readyPublisherCount),
             readyPublisherCount,
             publishers,
-            sequence: this.sequence,
+            sequence,
             observedAt: new Date()
         };
     }
     observe(channelName, capacity = runtime_observation_queue_1.ZLINK_DEFAULT_TERMINAL_OBSERVATION_CAPACITY, signal) {
-        const runtime = this.requireRuntime();
-        const queue = new runtime_observation_queue_1.RuntimeEventQueue(capacity, signal);
-        let lastSnapshot = this.snapshotCore(channelName);
-        const stop = runtime.observeFanoutTopology(channelName, () => {
-            this.sequence += 1n;
-            lastSnapshot = this.snapshotCore(channelName);
-            queue.push(lastSnapshot, channelName);
-        });
-        const hostObserver = {
-            changed: () => {
-                this.sequence += 1n;
-                lastSnapshot = this.snapshotCore(channelName);
-                queue.push(lastSnapshot, channelName);
-            },
-            stop: () => {
-                this.sequence += 1n;
-                let current = lastSnapshot;
-                try {
-                    current = this.snapshotCore(channelName);
-                    lastSnapshot = current;
-                }
-                catch {
-                    // The last complete projection remains valid after native teardown.
-                }
-                queue.seal({
-                    ...current,
-                    state: contracts_1.ZLinkTopologyState.Stopped,
-                    isReady: false,
-                    sequence: this.sequence,
-                    observedAt: new Date()
-                }, channelName);
-            }
-        };
-        this.hostObservers.add(hostObserver);
-        queue.onClose(() => {
-            stop();
-            this.hostObservers.delete(hostObserver);
-        });
-        return queue;
+        return this.sources.observe(channelName, capacity, signal);
     }
     hostStateChanged() {
-        for (const observer of this.hostObservers) {
-            try {
-                observer.changed();
-            }
-            catch {
-                // Monitoring projection failures do not change host lifecycle results.
-            }
-        }
+        this.sources.hostStateChanged();
     }
     stopObservers() {
-        for (const observer of [...this.hostObservers]) {
-            try {
-                observer.stop();
-            }
-            catch {
-                // The observer is still removed when its terminal snapshot fails.
-            }
-        }
-        this.hostObservers.clear();
+        this.sources.stopObservers();
     }
     requireRuntime() {
         const runtime = this.runtime();
@@ -244,6 +205,26 @@ class ZLinkFanoutRuntimeProjection {
     }
 }
 exports.ZLinkFanoutRuntimeProjection = ZLinkFanoutRuntimeProjection;
+function peerStatusForAvailability(descriptor, noReadyReason) {
+    let state = contracts_1.ZLinkPeerState.NotConnected;
+    let unavailableReason = noReadyReason;
+    switch (descriptor.state) {
+        case 'retiring':
+            state = contracts_1.ZLinkPeerState.Draining;
+            unavailableReason = contracts_1.ZLinkTopologyReason.Draining;
+            break;
+        case 'serving':
+            state = contracts_1.ZLinkPeerState.Ready;
+            unavailableReason = undefined;
+            break;
+        case 'preparing':
+            state = contracts_1.ZLinkPeerState.Connecting;
+            break;
+    }
+    return 'serverRoutingId' in descriptor
+        ? { nodeRid: descriptor.serverRoutingId, weight: descriptor.weight, state, unavailableReason }
+        : { nodeRid: descriptor.publisherRoutingId, state, unavailableReason };
+}
 function topologyStateForHost(state) {
     switch (state) {
         case contracts_1.ZLinkFrameworkRuntimeState.Preparing:

package/dist/runtime/disposal.d.ts

@@ -0,0 +1,5 @@
+export declare class RuntimeDisposal {
+    private task?;
+    get started(): boolean;
+    run(close: () => Promise<void>): Promise<void>;
+}

package/dist/runtime/disposal.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeDisposal = void 0;
+class RuntimeDisposal {
+    task;
+    get started() {
+        return this.task !== undefined;
+    }
+    run(close) {
+        if (this.task != null)
+            return this.task;
+        const task = Promise.resolve()
+            .then(close)
+            .catch((error) => {
+            this.task = null;
+            throw error;
+        });
+        this.task = task;
+        return task;
+    }
+}
+exports.RuntimeDisposal = RuntimeDisposal;

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,13 @@ export declare function captureZLinkExecutionTurn(): ZLinkCapturedExecutionTurn
 export declare function isCurrentZLinkSpotSerialTurn(executor: ZLinkSpotSerialTurnExecutorLike): boolean;
 export interface ZLinkExecutionBarrierSeal {
     readonly generation: bigint;
+    readonly kind: 'close' | 'relocation';
 }
 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 +70,28 @@ export interface ZLinkExecutionBarrierClaim {
 export declare class ZLinkExecutionBarrier {
     private generation;
     private activeClaims;
+    private suspendedClaims;
+    /** Claims whose turn has started and yielded at least once, until released. */
+    private yieldedTurnClaims;
     private currentSeal;
     private readonly admissionWaiters;
     private readonly quiescenceWaiters;
-    private committed;
-    enter(): Promise<ZLinkExecutionBarrierClaim>;
+    private committedSeal?;
+    get isSealed(): boolean;
+    get isCloseSealed(): boolean;
+    enter(): ZLinkExecutionBarrierClaim | Promise<ZLinkExecutionBarrierClaim>;
+    seal(kind?: ZLinkExecutionBarrierSeal['kind']): ZLinkExecutionBarrierSeal;
+    waitForQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
     /**
-     * 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.
+     * Spot messaging §7 step 1: a Close that keeps admission open still lets every
+     * already-started (yielded) turn finish in its generation before cleanup.
      */
-    tryEnter(): ZLinkExecutionBarrierClaim | undefined;
-    seal(): ZLinkExecutionBarrierSeal;
-    waitForQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
+    waitForStartedTurns(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,51 +177,57 @@ function isCurrentZLinkSpotSerialTurn(executor) {
 class ZLinkExecutionBarrier {
     generation = 0n;
     activeClaims = 0;
+    suspendedClaims = 0;
+    /** Claims whose turn has started and yielded at least once, until released. */
+    yieldedTurnClaims = 0;
     currentSeal;
     admissionWaiters = [];
     quiescenceWaiters = new Set();
-    committed = false;
-    async enter() {
-        if (this.committed) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
+    committedSeal;
+    get isSealed() {
+        return this.currentSeal !== undefined || this.committedSeal !== undefined;
+    }
+    get isCloseSealed() {
+        return (this.currentSeal ?? this.committedSeal)?.kind === 'close';
+    }
+    enter() {
+        if (this.committedSeal !== undefined) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(this.committedSeal.kind === 'close'
+                ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected
+                : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
         }
         if (this.currentSeal !== undefined) {
-            return await new Promise((resolve, reject) => {
+            if (this.currentSeal.kind === 'close') {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, 'ZLink execution barrier is sealed for Close.');
+            }
+            return new Promise((resolve, reject) => {
                 this.admissionWaiters.push({ resolve, reject });
             });
         }
         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() {
-        if (this.committed) {
+    seal(kind = 'relocation') {
+        if (this.committedSeal !== undefined) {
             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, kind });
         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();
             };
@@ -232,6 +240,31 @@ class ZLinkExecutionBarrier {
         });
         this.requireCurrent(seal);
     }
+    /**
+     * Spot messaging §7 step 1: a Close that keeps admission open still lets every
+     * already-started (yielded) turn finish in its generation before cleanup.
+     */
+    async waitForStartedTurns(signal) {
+        if (this.yieldedTurnClaims === 0)
+            return;
+        if (signal?.aborted === true)
+            throw signal.reason;
+        await new Promise((resolve, reject) => {
+            const complete = () => {
+                if (this.yieldedTurnClaims !== 0)
+                    return;
+                this.quiescenceWaiters.delete(complete);
+                signal?.removeEventListener('abort', abort);
+                resolve();
+            };
+            const abort = () => {
+                this.quiescenceWaiters.delete(complete);
+                reject(signal?.reason);
+            };
+            this.quiescenceWaiters.add(complete);
+            signal?.addEventListener('abort', abort, { once: true });
+        });
+    }
     abort(seal) {
         if (!this.isCurrent(seal))
             return false;
@@ -245,8 +278,10 @@ class ZLinkExecutionBarrier {
         if (!this.isCurrent(seal))
             return false;
         this.currentSeal = undefined;
-        this.committed = true;
-        const error = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
+        this.committedSeal = seal;
+        const error = (0, framework_errors_internal_1.createInternalFrameworkException)(seal.kind === 'close'
+            ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected
+            : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
         for (const waiter of this.admissionWaiters)
             waiter.reject(error);
         this.admissionWaiters.length = 0;
@@ -255,20 +290,55 @@ class ZLinkExecutionBarrier {
     isCurrent(seal) {
         return this.currentSeal?.generation === seal.generation;
     }
+    isQuiescent(seal) {
+        return this.activeClaims === 0 && (seal.kind !== 'close' || this.suspendedClaims === 0);
+    }
+    notifyQuiescence() {
+        for (const waiter of [...this.quiescenceWaiters])
+            waiter();
+    }
     createClaim() {
         this.activeClaims++;
-        let released = false;
+        let state = 'active';
+        let yielded = false;
+        const release = () => {
+            if (state === 'released')
+                return;
+            if (state === 'active')
+                this.activeClaims--;
+            else
+                this.suspendedClaims--;
+            if (yielded)
+                this.yieldedTurnClaims--;
+            state = 'released';
+            this.notifyQuiescence();
+        };
         return {
-            release: () => {
-                if (released)
+            release,
+            suspend: () => {
+                if (state !== 'active')
                     return;
-                released = true;
+                state = 'suspended';
+                if (!yielded) {
+                    yielded = true;
+                    this.yieldedTurnClaims++;
+                }
                 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.committedSeal !== undefined ||
+                    (this.currentSeal !== undefined && this.currentSeal.kind !== 'close')) {
+                    release();
+                    return false;
                 }
+                state = 'active';
+                this.suspendedClaims--;
+                this.activeClaims++;
+                return true;
             }
         };
     }