@zlink-systems/framework 0.25.0 → 0.26.0

package/src/runtime/channels/channel-socket-registry.ts

@@ -1,3 +1,4 @@
+import { ZLinkListenerRecords } from '../foundation/listener-records';
 import {
   ZLinkFrameworkRuntimeState,
   type RoutingId,
@@ -85,7 +86,6 @@ interface ClientServerPhysicalConnection {
   readonly aliases: Set<string>;
   readonly callbacksByAlias: Map<string, ZLinkClientServerConnectionCallbacks>;
   physicalConnectionId: symbol;
-  terminationRequested: boolean;
   readyConnectionId?: string;
   admittedDescriptor?: ClientServerDiscoveryDescriptor;
   nextProbeAt?: number;
@@ -170,14 +170,19 @@ export class ZLinkChannelSocketRegistry {
   >();
   private readonly fanoutTopologyHandlers = new Map<string, Set<() => void>>();
 
+  private readonly listenerRecords: ZLinkListenerRecords;
+
   constructor(
     private readonly registration: ZLinkFrameworkRegistration,
     private readonly adapter: ZLinkChannelBackendAdapter,
     private readonly context: ZLinkBackendContext,
     private readonly monitoringAdapter?: ZLinkMonitoringBackendAdapter,
     private readonly oneWayFailureSink?: (error: unknown) => void,
-    private readonly applicationJobQueue?: ApplicationJobQueue
-  ) {}
+    private readonly applicationJobQueue?: ApplicationJobQueue,
+    listenerRecords?: ZLinkListenerRecords
+  ) {
+    this.listenerRecords = listenerRecords ?? new ZLinkListenerRecords();
+  }
 
   async dispose(): Promise<void> {
     const clientServerConnections = [...new Set(this.clientServerConnections.values())];
@@ -306,14 +311,18 @@ export 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: ZLinkFrameworkRuntimeState.Serving,
         securityIdentity: 'default',
@@ -326,22 +335,21 @@ export class ZLinkChannelSocketRegistry {
   }
 
   clientServerServerIdentity(channelName: string): ZLinkClientServerServerSocketIdentity {
-    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 ZLinkConfigurationException(`Channel server '${channelName}' is not registered.`);
     }
-    const boundEndpoint = router.lastEndpoint ?? channel.server.bind;
-    if (boundEndpoint === undefined || boundEndpoint.length === 0) {
-      throw new ZLinkConfigurationException(
-        `Channel server '${channelName}' did not report its bound endpoint.`
-      );
-    }
-    return {
-      ...identity,
-      endpoint: advertisedEndpoint(boundEndpoint, channel.server.advertiseHost)
-    };
+    return { ...identity, endpoint };
+  }
+
+  fanoutPublisherEndpoint(channelName: string): string | undefined {
+    return this.listenerRecords.endpoint('fanout', channelName);
+  }
+
+  private recordListener(kind: 'clientServer' | 'fanout', name: string, endpoint: string): void {
+    this.listenerRecords.record(kind, name, endpoint);
   }
 
   clientServerServerSocket(channelName: string): ZLinkBackendRouterSocket {
@@ -417,8 +425,7 @@ export 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();
@@ -436,7 +443,7 @@ export class ZLinkChannelSocketRegistry {
         const routingId = event.routingId === undefined ? undefined : String(event.routingId);
         if (event.nativeEvent === ZLinkSocketNativeEventType.ConnectionReady) {
           // This single-endpoint DEALER also receives its disconnected ready-count snapshot.
-          if (event.value === 0n || connection.terminationRequested) return;
+          if (event.value === 0n) return;
           connection.physicalConnectionId = Symbol(connectionId);
           connection.admissionAttempt = undefined;
           for (const currentCallbacks of [...connection.callbacksByAlias.values()]) {
@@ -451,26 +458,9 @@ export class ZLinkChannelSocketRegistry {
           event.nativeEvent === ZLinkSocketNativeEventType.HandshakeFailedProtocol ||
           event.nativeEvent === ZLinkSocketNativeEventType.HandshakeFailedAuth
         ) {
-          if (
-            connection.terminationRequested &&
-            (event.remoteAddr !== connection.endpoint ||
-              (event.nativeEvent !== ZLinkSocketNativeEventType.Disconnected &&
-                event.nativeEvent !== 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);
@@ -790,10 +780,6 @@ export class ZLinkChannelSocketRegistry {
     );
   }
 
-  hasKnownClientServerTargets(channelName: string): boolean {
-    return this.clientServerDiscovery.clientServerDescriptors(channelName).length > 0;
-  }
-
   fanoutActiveTargets(channelName: string) {
     return this.clientServerDiscovery.fanoutEndpoints(channelName);
   }
@@ -929,7 +915,7 @@ export class ZLinkChannelSocketRegistry {
       this.drainClientServerControl(connectionId, connection);
       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) continue;
@@ -1298,7 +1284,6 @@ export class ZLinkChannelSocketRegistry {
     connectionId: string,
     connection: ClientServerPhysicalConnection
   ): void {
-    if (connection.terminationRequested) return;
     for (;;) {
       if (!connection.readablePoller.wait(0)) return;
       const received = connection.dealer.recv(1);
@@ -1331,7 +1316,7 @@ export class ZLinkChannelSocketRegistry {
         }
         this.applyClientServerDescriptorUpdate(connectionId, connection, record.admission);
       } catch (error) {
-        this.requestClientServerEndpointTermination(connectionId, connection);
+        this.restartClientServerAdmission(connectionId, connection);
         this.oneWayFailureSink?.(error);
         return;
       } finally {
@@ -1340,19 +1325,39 @@ export class ZLinkChannelSocketRegistry {
     }
   }
 
-  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(
     connectionId: string,
-    connection: ClientServerPhysicalConnection
+    connection: ClientServerPhysicalConnection,
+    routingId: string | undefined,
+    endpoint: string
   ): void {
-    if (connection.terminationRequested) return;
-    connection.terminationRequested = true;
     connection.physicalConnectionId = Symbol(connectionId);
     connection.admissionAttempt = undefined;
-    this.removeReadyConnection(connectionId);
-    try {
-      connection.dealer.disconnect(connection.endpoint);
-    } catch (error) {
-      this.oneWayFailureSink?.(error);
+    if (connection.readyConnectionId !== undefined) {
+      this.removeReadyConnection(connection.readyConnectionId);
+    }
+    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.
+   */
+  private restartClientServerAdmission(
+    connectionId: string,
+    connection: ClientServerPhysicalConnection
+  ): void {
+    this.endClientServerAdmission(connectionId, connection, undefined, connection.endpoint);
+    for (const callbacks of [...connection.callbacksByAlias.values()]) {
+      callbacks.onTransportReady('', connection.endpoint);
     }
   }
 
@@ -1612,6 +1617,13 @@ export class ZLinkChannelSocketRegistry {
     applyFanoutPublisherSocketOptions(publisher, channel);
     publisher.bind(channel.publisher.bind);
     this.publishers.set(channelName, publisher);
+    const endpoint = 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
@@ -1620,20 +1632,6 @@ export class ZLinkChannelSocketRegistry {
     return publisher;
   }
 
-  fanoutPublisherEndpoint(channelName: string): string | undefined {
-    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: string): ZLinkBackendRouterSocket {
     const existing = this.routeRouters.get(routerChannelId);
     if (existing !== undefined) {

package/src/runtime/channels/channel-transports.ts

@@ -15,7 +15,6 @@ import {
 import type { ZLinkBackendMeshNode, ZLinkBackendSpot } from '../backend/contracts';
 import type { ZLinkFrameworkInternalErrorKind as ZLinkFrameworkInternalErrorKindType } from '../framework-errors-internal';
 import { ZLinkFrameworkException } from '../../contracts';
-import type { ZLinkFanoutListenerStatus } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
 import { ZLinkConfigurationException } from '../configuration';
@@ -73,7 +72,6 @@ export interface ZLinkChannelClientTransport {
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>
   ): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
-  getFanoutListenerStatus?(channelName: string): ZLinkFanoutListenerStatus;
 }
 
 export type ZLinkChannelClientTransportSource =
@@ -187,7 +185,6 @@ interface ZLinkChannelTransportRuntime {
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>
   ): Promise<ZLinkSubmitResult>;
-  getFanoutListenerStatus(channelName: string): ZLinkFanoutListenerStatus;
   canRouteChannel(routerChannelId: string): boolean;
   canRoutePacketChannel(routerChannelId: string): boolean;
   routeSubmit(

package/src/runtime/channels/fanout-location-runtime.ts

@@ -12,7 +12,7 @@ import {
   type ZLinkLocationOptionOverrides
 } from '../../contracts/Locations/Options';
 import type { ZLinkFrameworkRegistration } from '../configuration';
-import { buildAdvertisedEndpoint, ZLinkConfigurationException } from '../configuration';
+import { ZLinkConfigurationException } from '../configuration';
 import type { ZLinkLocationRuntime, ZLinkLocationRuntimeStores } from '../locations';
 import type { ZLinkBackendSubscriberSocket } from '../backend/contracts';
 import { ZLinkChannelSocketRegistry } from './channel-socket-registry';
@@ -142,11 +142,9 @@ export class ZLinkFanoutLocationRuntime {
     const owner = this.requireOwnerToken();
     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 ZLinkConfigurationException(
           `Fanout publisher '${channelName}' did not report a bound endpoint.`
@@ -412,16 +410,6 @@ export class ZLinkFanoutLocationRuntime {
   }
 }
 
-function advertisedEndpoint(boundEndpoint: string, advertiseHost: string | undefined): string {
-  const result = buildAdvertisedEndpoint(boundEndpoint, advertiseHost);
-  if (result === undefined) {
-    throw new ZLinkConfigurationException(
-      `Fanout publisher bound endpoint '${boundEndpoint}' cannot be advertised.`
-    );
-  }
-  return result;
-}
-
 function fanoutConnectionId(descriptor: ZLinkFanoutPublisherDescriptor): string {
   return (
     `${descriptor.channelName}\0${String(descriptor.publisherRid)}\0` +

package/src/runtime/execution/index.ts

@@ -66,17 +66,15 @@ export class ZLinkSpotSerialTurn {
     readonly yieldAllowed: boolean
   ) {}
 
-  bindExecutionClaim(claim: ZLinkExecutionBarrierClaim | undefined): void {
-    if (this.executionClaim !== undefined) {
-      throw new Error('ZLink Spot serial turn already owns an execution claim.');
-    }
-    this.executionClaim = claim;
-  }
-
   get isSuspended(): boolean {
     return this.suspendSignaled;
   }
 
+  /** False when a seal that does not drain yielded turns won before this resume. */
+  resumeExecutionClaim(): boolean {
+    return this.executionClaim?.resume() ?? true;
+  }
+
   releaseBoundExecutionClaim(): void {
     this.executionClaim?.release();
     this.executionClaim = undefined;
@@ -96,6 +94,14 @@ export class ZLinkSpotSerialTurn {
     this.owner = owner;
   }
 
+  /** Settles when the whole turn ends by any path, including yielded continuations. */
+  get completion(): Promise<void> {
+    return (this.owner ?? Promise.resolve()).then(
+      () => undefined,
+      () => undefined
+    );
+  }
+
   blockFrameworkOperations(): void {
     this.frameworkOperationsBlocked = true;
   }
@@ -150,7 +156,7 @@ export class ZLinkSpotSerialTurn {
       return;
     }
     this.suspendSignaled = true;
-    this.releaseBoundExecutionClaim();
+    this.executionClaim?.suspend();
     this.suspendedResolve?.();
   }
 
@@ -235,10 +241,19 @@ export function isCurrentZLinkSpotSerialTurn(executor: ZLinkSpotSerialTurnExecut
 
 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;
 }
 
 interface ZLinkExecutionBarrierWaiter {
@@ -254,11 +269,16 @@ interface ZLinkExecutionBarrierWaiter {
 export class ZLinkExecutionBarrier {
   private generation = 0n;
   private activeClaims = 0;
+  private suspendedClaims = 0;
   private currentSeal: ZLinkExecutionBarrierSeal | undefined;
   private readonly admissionWaiters: ZLinkExecutionBarrierWaiter[] = [];
   private readonly quiescenceWaiters = new Set<() => void>();
   private committed = false;
 
+  get isSealed(): boolean {
+    return this.currentSeal !== undefined || this.committed;
+  }
+
   async enter(): Promise<ZLinkExecutionBarrierClaim> {
     if (this.committed) {
       throw createInternalFrameworkException(
@@ -274,19 +294,7 @@ export 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(): ZLinkExecutionBarrierClaim | undefined {
-    if (this.committed || this.currentSeal !== undefined) {
-      return undefined;
-    }
-    return this.createClaim();
-  }
-
-  seal(): ZLinkExecutionBarrierSeal {
+  seal(drainsYieldedTurns = false): ZLinkExecutionBarrierSeal {
     if (this.committed) {
       throw createInternalFrameworkException(
         ZLinkFrameworkInternalErrorKind.SpotMoving,
@@ -296,17 +304,19 @@ export class ZLinkExecutionBarrier {
     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: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void> {
     this.requireCurrent(seal);
-    if (this.activeClaims === 0) return;
+    if (this.isQuiescent(seal)) return;
     if (signal?.aborted === true) throw signal.reason;
     await new Promise<void>((resolve, reject) => {
       const complete = () => {
+        if (!this.isQuiescent(seal)) return;
+        this.quiescenceWaiters.delete(complete);
         signal?.removeEventListener('abort', abort);
         resolve();
       };
@@ -345,18 +355,46 @@ export class ZLinkExecutionBarrier {
     return this.currentSeal?.generation === seal.generation;
   }
 
+  private isQuiescent(seal: ZLinkExecutionBarrierSeal): boolean {
+    return this.activeClaims === 0 && (!seal.drainsYieldedTurns || this.suspendedClaims === 0);
+  }
+
+  private notifyQuiescence(): void {
+    for (const waiter of [...this.quiescenceWaiters]) waiter();
+  }
+
   private createClaim(): ZLinkExecutionBarrierClaim {
     this.activeClaims++;
-    let released = false;
+    let state: 'active' | 'suspended' | 'released' = 'active';
+    const release = () => {
+      if (state === 'released') return;
+      if (state === 'active') this.activeClaims--;
+      else this.suspendedClaims--;
+      state = 'released';
+      this.notifyQuiescence();
+    };
     return {
-      release: () => {
-        if (released) return;
-        released = true;
+      release,
+      suspend: () => {
+        if (state !== 'active') return;
+        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/src/runtime/execution/serial-execution-queue.ts

@@ -38,6 +38,7 @@ export interface ZLinkSerialWorkPreparation {
 
 type SerialWorkRecord<T> = Omit<ZLinkSerialWorkRecord<T>, 'acceptedSequence'> & {
   acceptedSequence: bigint;
+  readonly operationEnvelope: boolean;
   readonly preparation?: ZLinkSerialWorkPreparation;
   preparationState: 'idle' | 'pending' | 'canceling' | 'ready' | 'failed';
   preparationController?: AbortController;
@@ -55,6 +56,7 @@ interface ZLinkSerialAdmissionLane {
 export class ZLinkSerialExecutionQueue {
   private readonly application: ZLinkSerialAdmissionLane;
   private readonly lifecycle: ZLinkSerialAdmissionLane;
+  private activeLifecycle?: ZLinkSerialWorkRecord<unknown>;
   private readonly ownerTimeBudget: number;
   private readonly lifecycleBurstLimit: number;
   private nextAcceptedSequence = 1n;
@@ -138,23 +140,17 @@ export class ZLinkSerialExecutionQueue {
     return this.admit(operation, options, context);
   }
 
-  snapshot(): {
-    readonly applicationMessages: number;
-    readonly applicationBytes: number;
-    readonly lifecycleMessages: number;
-    readonly lifecycleBytes: number;
-  } {
-    return {
-      applicationMessages: this.application.records.length,
-      applicationBytes: 0,
-      lifecycleMessages: this.lifecycle.records.length,
-      lifecycleBytes: 0
-    };
+  /** Holds lifecycle FIFO through an operation result while its application turns can run. */
+  submitLifecycleOperation<T>(operation: () => Promise<T> | T): Promise<T> {
+    return this.admit(operation, { lane: 'lifecycle' }, undefined, undefined, true);
   }
 
   get hasPendingWork(): boolean {
     return (
-      this.draining || this.application.records.length > 0 || this.lifecycle.records.length > 0
+      this.draining ||
+      this.activeLifecycle !== undefined ||
+      this.application.records.length > 0 ||
+      this.lifecycle.records.length > 0
     );
   }
 
@@ -165,15 +161,21 @@ export class ZLinkSerialExecutionQueue {
 
   /** Stops new submissions while allowing the accepted FIFO to finish. */
   close(): Promise<void> {
-    this.closed = true;
+    this.closeAdmission();
     return this.whenIdle();
   }
 
+  /** Stops admission within the lifecycle operation that owns this queue's close. */
+  closeAdmission(): void {
+    this.closed = true;
+  }
+
   private admit<T>(
     operation: () => Promise<T> | T,
     options: ZLinkSerialWorkOptions,
     context?: unknown,
-    preparation?: ZLinkSerialWorkPreparation
+    preparation?: ZLinkSerialWorkPreparation,
+    operationEnvelope = false
   ): Promise<T> {
     if (this.closed) throw new Error('The serial execution queue is closed.');
     const lane = options.lane ?? 'application';
@@ -189,6 +191,14 @@ export class ZLinkSerialExecutionQueue {
     const release = (): void => {
       if (released) return;
       released = true;
+      if (this.activeLifecycle === record) {
+        this.activeLifecycle = undefined;
+        if (this.application.records.length > 0 || this.lifecycle.records.length > 0) {
+          this.scheduleDrain();
+        } else if (!this.draining) {
+          this.resolveIdleWaiters();
+        }
+      }
     };
     const resolve = (value: T): void => {
       if (settled) return;
@@ -204,6 +214,7 @@ export class ZLinkSerialExecutionQueue {
       acceptedSequence: 0n,
       lane,
       operation,
+      operationEnvelope,
       context,
       preparation,
       preparationState: preparation === undefined ? 'ready' : 'idle',
@@ -275,7 +286,25 @@ export class ZLinkSerialExecutionQueue {
         }
         this.claimStartedAt ??= performance.now();
         try {
-          await this.executeRecord(record);
+          if (record.operationEnvelope) {
+            try {
+              const outcome = record.operation();
+              void Promise.resolve(outcome).then(
+                (value) => {
+                  record.resolve(value);
+                  record.release();
+                },
+                (error) => {
+                  record.reject(error);
+                  record.release();
+                }
+              );
+            } catch (error) {
+              record.fail(error);
+            }
+          } else {
+            await this.executeRecord(record);
+          }
         } catch (error) {
           record.fail(error);
         } finally {
@@ -291,11 +320,12 @@ export class ZLinkSerialExecutionQueue {
       this.claimStartedAt = undefined;
       if (
         !waitingForPreparation &&
-        (this.application.records.length > 0 || this.lifecycle.records.length > 0)
+        (this.application.records.length > 0 ||
+          (this.activeLifecycle === undefined && this.lifecycle.records.length > 0))
       ) {
         this.scheduleDrain();
       } else {
-        if (this.application.records.length === 0 && this.lifecycle.records.length === 0) {
+        if (!this.hasPendingWork) {
           this.resolveIdleWaiters();
         }
       }
@@ -309,7 +339,7 @@ export class ZLinkSerialExecutionQueue {
       }
     | undefined {
     const applicationReady = this.application.records.length > 0;
-    const lifecycleReady = this.lifecycle.records.length > 0;
+    const lifecycleReady = this.activeLifecycle === undefined && this.lifecycle.records.length > 0;
     if (!applicationReady && !lifecycleReady) return undefined;
     if (!applicationReady) {
       return { lane: 'lifecycle', record: this.lifecycle.records[0]! };
@@ -339,7 +369,9 @@ export class ZLinkSerialExecutionQueue {
     if (this.application.records.length > 0 && this.lifecycleStreak >= this.lifecycleBurstLimit) {
       this.lifecycleDebt = true;
     }
-    return this.lifecycle.records.shift()!;
+    const record = this.lifecycle.records.shift()!;
+    this.activeLifecycle = record;
+    return record;
   }
 
   private takeApplication(): ZLinkSerialWorkRecord<unknown> {

package/src/runtime/foundation/listener-records.ts

@@ -0,0 +1,21 @@
+import type { ZLinkListenerKind } from '../../contracts/RouteMesh/RuntimeTopology';
+
+/**
+ * Bound listener records of one runtime generation (spec 04 §3.1). A listener writes its
+ * record when it finishes binding. The listener status query reads only this object.
+ */
+export class ZLinkListenerRecords {
+  private readonly endpoints = new Map<string, string>();
+
+  record(kind: ZLinkListenerKind, name: string, endpoint: string): void {
+    this.endpoints.set(`${kind}:${name}`, endpoint);
+  }
+
+  clear(): void {
+    this.endpoints.clear();
+  }
+
+  endpoint(kind: ZLinkListenerKind, name: string): string | undefined {
+    return this.endpoints.get(`${kind}:${name}`);
+  }
+}