@zlink-systems/framework 0.26.0 → 0.28.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

@@ -54,12 +54,7 @@ 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;
+    readonly kind: 'close' | 'relocation';
 }
 export interface ZLinkExecutionBarrierClaim {
     release(): void;
@@ -76,14 +71,22 @@ 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;
+    private committedSeal?;
     get isSealed(): boolean;
-    enter(): Promise<ZLinkExecutionBarrierClaim>;
-    seal(drainsYieldedTurns?: boolean): ZLinkExecutionBarrierSeal;
+    get isCloseSealed(): boolean;
+    enter(): ZLinkExecutionBarrierClaim | Promise<ZLinkExecutionBarrierClaim>;
+    seal(kind?: ZLinkExecutionBarrierSeal['kind']): ZLinkExecutionBarrierSeal;
     waitForQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
+    /**
+     * Spot messaging §7 step 1: a Close that keeps admission open still lets every
+     * already-started (yielded) turn finish in its generation before cleanup.
+     */
+    waitForStartedTurns(signal?: AbortSignal): Promise<void>;
     abort(seal: ZLinkExecutionBarrierSeal): boolean;
     commit(seal: ZLinkExecutionBarrierSeal): boolean;
     isCurrent(seal: ZLinkExecutionBarrierSeal): boolean;

package/dist/runtime/execution/index.js

@@ -178,32 +178,42 @@ 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;
+    committedSeal;
     get isSealed() {
-        return this.currentSeal !== undefined || this.committed;
+        return this.currentSeal !== undefined || this.committedSeal !== undefined;
     }
-    async enter() {
-        if (this.committed) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
+    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();
     }
-    seal(drainsYieldedTurns = false) {
-        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, drainsYieldedTurns });
+        const seal = Object.freeze({ generation: ++this.generation, kind });
         this.currentSeal = seal;
         return seal;
     }
@@ -230,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;
@@ -243,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;
@@ -254,7 +291,7 @@ class ZLinkExecutionBarrier {
         return this.currentSeal?.generation === seal.generation;
     }
     isQuiescent(seal) {
-        return this.activeClaims === 0 && (!seal.drainsYieldedTurns || this.suspendedClaims === 0);
+        return this.activeClaims === 0 && (seal.kind !== 'close' || this.suspendedClaims === 0);
     }
     notifyQuiescence() {
         for (const waiter of [...this.quiescenceWaiters])
@@ -263,6 +300,7 @@ class ZLinkExecutionBarrier {
     createClaim() {
         this.activeClaims++;
         let state = 'active';
+        let yielded = false;
         const release = () => {
             if (state === 'released')
                 return;
@@ -270,6 +308,8 @@ class ZLinkExecutionBarrier {
                 this.activeClaims--;
             else
                 this.suspendedClaims--;
+            if (yielded)
+                this.yieldedTurnClaims--;
             state = 'released';
             this.notifyQuiescence();
         };
@@ -279,6 +319,10 @@ class ZLinkExecutionBarrier {
                 if (state !== 'active')
                     return;
                 state = 'suspended';
+                if (!yielded) {
+                    yielded = true;
+                    this.yieldedTurnClaims++;
+                }
                 this.activeClaims--;
                 this.suspendedClaims++;
                 this.notifyQuiescence();
@@ -286,8 +330,8 @@ class ZLinkExecutionBarrier {
             resume: () => {
                 if (state !== 'suspended')
                     return state === 'active';
-                if (this.committed ||
-                    (this.currentSeal !== undefined && !this.currentSeal.drainsYieldedTurns)) {
+                if (this.committedSeal !== undefined ||
+                    (this.currentSeal !== undefined && this.currentSeal.kind !== 'close')) {
                     release();
                     return false;
                 }

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

@@ -13,7 +13,7 @@ export declare const ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS: Required<ZLinkSeria
 export interface ZLinkSerialWorkRecord<T> {
     readonly acceptedSequence: bigint;
     readonly lane: ZLinkSerialWorkLane;
-    readonly operation: () => Promise<T> | T;
+    operation: () => Promise<T> | T;
     readonly context?: unknown;
     resolve(value: T): void;
     reject(reason: unknown): void;
@@ -21,6 +21,10 @@ export interface ZLinkSerialWorkRecord<T> {
     release(): void;
     fail(reason: unknown): void;
 }
+/** The active lifecycle owner decides which existing application records can run. */
+export interface ZLinkSerialLifecycleContext {
+    canExecuteApplication(record: ZLinkSerialWorkRecord<unknown>): boolean;
+}
 /** Readiness work that must complete without claiming the serial owner. */
 export interface ZLinkSerialWorkPreparation {
     prepare(signal: AbortSignal): Promise<void>;
@@ -58,13 +62,15 @@ export declare class ZLinkSerialExecutionQueue {
      */
     submitPreAdmitted<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
     /** Holds lifecycle FIFO through an operation result while its application turns can run. */
-    submitLifecycleOperation<T>(operation: () => Promise<T> | T): Promise<T>;
+    submitLifecycleOperation<T>(operation: () => Promise<T> | T, context?: ZLinkSerialLifecycleContext): Promise<T>;
+    visitPendingApplication(visitor: (record: ZLinkSerialWorkRecord<unknown>) => void): void;
     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;
+    get admissionClosed(): boolean;
     private admit;
     private scheduleDrain;
     private drain;