@zlink-systems/framework 0.30.1 → 0.30.2

package/src/runtime/foundation/raw-service-mesh-runtime.ts

@@ -15,7 +15,12 @@ import { submitToRequestResult } from '../messaging/submission-result';
 import { RequestResult, SubmitResult, isZLinkBackendResultError } from '../backend/runtime-values';
 import { enumWireRejectReason } from '../protocol/service_wire_codec.generated';
 import { SERVICE_WIRE_PREFIX_SIZE } from './service-wire-binary-primitives';
-import { OperationRegistry, type PendingOperation } from './operation-registry';
+import {
+  OperationRegistry,
+  OperationTimeoutError,
+  type OperationObserver,
+  type PendingOperation
+} from './operation-registry';
 import { ServiceLivenessRegistry, type ServiceLivenessTick } from './service-liveness-registry';
 import { ServiceMailbox, type ServiceMailboxRecord } from './service-mailbox';
 import {
@@ -68,6 +73,19 @@ export interface RawServiceRequestResult {
   readonly payload?: ServiceApplicationPayload;
 }
 
+/** Receives observed request terminals; the context is the caller's operation kind. */
+export type RawServiceRequestObserver = OperationObserver<RawServiceRequestResult, number>;
+
+/**
+ * A registered request. An observed remote request has no Promise; its
+ * terminal reaches the observer. Local and Promise-contract requests carry
+ * the Promise.
+ */
+export interface RawServiceObservedRequest {
+  readonly id: bigint;
+  readonly promise?: Promise<RawServiceRequestResult>;
+}
+
 type RawServiceChannelTargetSelection =
   | { readonly kind: 'selected'; readonly peer: AdmittedServicePeer }
   | {
@@ -85,6 +103,8 @@ type RawServiceChannelTargetSelection =
 type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
 
 export interface RawServiceIngressRecord {
+  /** Source identity recorded once by the first accepting owner (Location runtime §9.3). */
+  requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
   readonly onAdmitted?: () => void;
   readonly command: number;
   readonly flags: number;
@@ -160,7 +180,7 @@ export class RawServiceMeshRuntime {
   readonly mailbox: ServiceMailbox;
   readonly liveness: ServiceLivenessRegistry;
 
-  private readonly operations: OperationRegistry<RawServiceRequestResult>;
+  private readonly operations: OperationRegistry<RawServiceRequestResult, number>;
   private readonly expectedPeers = new Map<
     string,
     {
@@ -339,10 +359,12 @@ export class RawServiceMeshRuntime {
       if (router.disconnectRid !== undefined) {
         router.disconnectRid(nodeRoutingId);
       } else {
-        router.disconnect(endpoint);
+        try {
+          router.disconnect(endpoint);
+        } catch (error) {
+          if (!isAlreadyDisconnectedError(error)) throw error;
+        }
       }
-    } catch (error) {
-      if (!isAlreadyDisconnectedError(error)) throw error;
     } finally {
       if (current !== undefined) this.removePeer(current);
       this.topology.forgetNotRequired(nodeRoutingId);
@@ -399,6 +421,35 @@ export class RawServiceMeshRuntime {
     };
   }
 
+  async waitForPeerRoute(
+    nodeRoutingId: string,
+    lifecycleGeneration: bigint,
+    deadlineUnixMs: bigint,
+    signal?: AbortSignal
+  ): Promise<void> {
+    const remaining = deadlineUnixMs - BigInt(Date.now());
+    if (remaining <= 0n) throw new OperationTimeoutError(0n);
+    const pending = this.operations.register(Number(remaining));
+    const check = () => {
+      if (this.isPeerRouteReady(nodeRoutingId, lifecycleGeneration)) {
+        this.operations.complete(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+      }
+    };
+    const unsubscribe = this.observePeerRouteChanged((rid) => {
+      if (rid === nodeRoutingId) check();
+    });
+    const abort = () => this.operations.fail(pending.id, signal?.reason);
+    signal?.addEventListener('abort', abort, { once: true });
+    try {
+      if (signal?.aborted === true) abort();
+      else check();
+      await pending.promise;
+    } finally {
+      unsubscribe();
+      signal?.removeEventListener('abort', abort);
+    }
+  }
+
   get requestStopSignal(): AbortSignal {
     return this.applicationJobStop.signal;
   }
@@ -426,38 +477,39 @@ export class RawServiceMeshRuntime {
     for (const listener of this.peerConnectionIntentRemoved) listener(nodeRoutingId);
   }
 
-  announcePeer(nodeRoutingId: string): Promise<boolean> {
+  announcePeer(nodeRoutingId: string): boolean {
+    if (this.closed) return false;
     const generation = this.selectedRoutes.get(nodeRoutingId);
-    if (generation === undefined) return Promise.resolve(false);
-    const current = () => {
-      const admission = this.topology.routeAdmission(nodeRoutingId);
-      return (
-        this.selectedRoutes.get(nodeRoutingId) === generation &&
-        !(
-          admission?.connectionId === routeConnectionId(generation) &&
-          admission.remoteAdmitReceived === true
-        ) &&
-        this.peerAdmissionSealed?.() !== true
-      );
-    };
+    if (generation === undefined) return false;
     const key = controlSendKey(nodeRoutingId, M6aServiceWireCommand.hello);
-    if (!current()) {
+    if (!this.isPeerAnnouncementCurrent(nodeRoutingId, generation)) {
       this.controlSends.delete(key);
-      return Promise.resolve(false);
+      return false;
     }
+    const current = () => this.isPeerAnnouncementCurrent(nodeRoutingId, generation);
     const existing = this.controlSends.get(key);
     const hello =
       existing?.current?.() === true
         ? existing.hello!
         : encodeRouteMeshAdmission(M6aServiceWireCommand.hello, this.topology.localDescriptor());
-    return Promise.resolve(
-      this.startControlSend(
-        nodeRoutingId,
-        M6aServiceWireCommand.hello,
-        () => this.submitControl(nodeRoutingId, [hello]),
-        current,
-        hello
-      )
+    return this.startControlSend(
+      nodeRoutingId,
+      M6aServiceWireCommand.hello,
+      () => this.submitControl(nodeRoutingId, [hello]),
+      current,
+      hello
+    );
+  }
+
+  private isPeerAnnouncementCurrent(nodeRoutingId: string, generation: bigint): boolean {
+    const admission = this.topology.routeAdmission(nodeRoutingId);
+    return (
+      this.selectedRoutes.get(nodeRoutingId) === generation &&
+      !(
+        admission?.connectionId === routeConnectionId(generation) &&
+        admission.remoteAdmitReceived === true
+      ) &&
+      this.peerAdmissionSealed?.() !== true
     );
   }
 
@@ -562,8 +614,32 @@ export class RawServiceMeshRuntime {
     payload: ServiceApplicationPayloadInput,
     timeoutMs: number,
     onAdmitted?: () => void
-  ): PendingOperation<RawServiceRequestResult> {
-    return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs, undefined, onAdmitted);
+  ): PendingOperation<RawServiceRequestResult>;
+  requestToNode(
+    targetNodeRoutingId: string,
+    payload: ServiceApplicationPayloadInput,
+    timeoutMs: number,
+    onAdmitted: (() => void) | undefined,
+    observer: RawServiceRequestObserver,
+    operationKind: number
+  ): RawServiceObservedRequest;
+  requestToNode(
+    targetNodeRoutingId: string,
+    payload: ServiceApplicationPayloadInput,
+    timeoutMs: number,
+    onAdmitted?: () => void,
+    observer?: RawServiceRequestObserver,
+    operationKind?: number
+  ): RawServiceObservedRequest {
+    return this.requestToTarget(
+      targetNodeRoutingId,
+      payload,
+      timeoutMs,
+      undefined,
+      onAdmitted,
+      observer,
+      operationKind
+    );
   }
 
   requestToChannel(
@@ -571,11 +647,27 @@ export class RawServiceMeshRuntime {
     payload: ServiceApplicationPayloadInput,
     timeoutMs: number,
     onAdmitted?: () => void
-  ): PendingOperation<RawServiceRequestResult> {
+  ): PendingOperation<RawServiceRequestResult>;
+  requestToChannel(
+    channelName: string,
+    payload: ServiceApplicationPayloadInput,
+    timeoutMs: number,
+    onAdmitted: (() => void) | undefined,
+    observer: RawServiceRequestObserver,
+    operationKind: number
+  ): RawServiceObservedRequest;
+  requestToChannel(
+    channelName: string,
+    payload: ServiceApplicationPayloadInput,
+    timeoutMs: number,
+    onAdmitted?: () => void,
+    observer?: RawServiceRequestObserver,
+    operationKind?: number
+  ): RawServiceObservedRequest {
     const selection = this.selectChannelTarget(channelName);
     if (selection.kind !== 'selected') {
-      const pending = this.operations.register(timeoutMs);
-      this.operations.complete(pending.id, selection.requestResult);
+      const pending = this.registerRequest(timeoutMs, observer, operationKind);
+      this.completeRequest(pending, selection.requestResult);
       return pending;
     }
     return this.requestToTarget(
@@ -583,10 +675,45 @@ export class RawServiceMeshRuntime {
       payload,
       timeoutMs,
       channelName,
-      onAdmitted
+      onAdmitted,
+      observer,
+      operationKind
     );
   }
 
+  /**
+   * One pending entry per request: an observed request reports its terminal
+   * to the caller's observer; any other request keeps the Promise contract.
+   */
+  private registerRequest(
+    timeoutMs: number,
+    observer: RawServiceRequestObserver | undefined,
+    operationKind: number | undefined
+  ): RawServiceObservedRequest {
+    return observer === undefined
+      ? this.operations.register(timeoutMs)
+      : { id: this.operations.registerObserved(timeoutMs, observer, operationKind) };
+  }
+
+  /**
+   * An observed caller learns the operation id only when the request call
+   * returns, so a terminal decided inside that call is delivered after it.
+   */
+  private completeRequest(
+    pending: RawServiceObservedRequest,
+    result: RawServiceRequestResult
+  ): void {
+    if (pending.promise === undefined)
+      queueMicrotask(() => this.operations.complete(pending.id, result));
+    else this.operations.complete(pending.id, result);
+  }
+
+  private failRequest(pending: RawServiceObservedRequest, error: unknown): void {
+    if (pending.promise === undefined)
+      queueMicrotask(() => this.operations.fail(pending.id, error));
+    else this.operations.fail(pending.id, error);
+  }
+
   private selectChannelTarget(channelName: string): RawServiceChannelTargetSelection {
     const selected = this.topology.selectChannel(channelName, (peer) =>
       this.isPeerRouteReady(peer.descriptor.nodeRoutingId)
@@ -1043,6 +1170,7 @@ export class RawServiceMeshRuntime {
       ]);
     } else if (header.command === M6aServiceWireCommand.admit) {
       this.controlSends.delete(helloKey);
+      this.refreshAdmissionPending(nowMs);
       if (result === 'notRequired') {
         this.retireNotRequiredExpectedPeer(received.sourceRid, descriptor.advertisedEndpoint);
       } else if (
@@ -1126,12 +1254,7 @@ export class RawServiceMeshRuntime {
       if (
         header.flags !== 0 ||
         received.parts.length !== 2 ||
-        ![
-          M6aServiceWireCommand.nodeSend,
-          M6aServiceWireCommand.nodeRequest,
-          M6aServiceWireCommand.channelSend,
-          M6aServiceWireCommand.channelRequest
-        ].includes(header.command as never)
+        !isApplicationEnvelopeCommand(header.command)
       ) {
         return 'protocolError';
       }
@@ -1170,9 +1293,9 @@ export class RawServiceMeshRuntime {
       parts: received.parts,
       sourceRoutingId: received.sourceRid,
       sourceRoute: received.sourceRoute,
-      ...(received.reply === undefined ? {} : { reply: received.reply }),
+      reply: received.reply,
       requestSequence: received.requestSeq,
-      ...(correlation === undefined ? {} : { correlation }),
+      correlation,
       applicationJob
     });
     if (accepted) return 'application';
@@ -1200,10 +1323,42 @@ export class RawServiceMeshRuntime {
     return this.operations.size;
   }
 
+  cancelPendingOperations(reason: unknown): void {
+    this.operations.failAll(reason);
+  }
+
+  /**
+   * The next management deadline of this node (spec 08 §4.2): request expiry,
+   * liveness probe or timeout, or an owned HELLO exchange still awaiting
+   * ADMIT, which keeps the existing announce cadence.
+   */
+  nextMaintenanceDeadlineMs(nowMs: number): number {
+    this.refreshAdmissionPending(nowMs);
+    return Math.min(this.operations.nextDeadlineMs(), this.liveness.nextDeadlineMs());
+  }
+
+  private refreshAdmissionPending(nowMs: number): void {
+    let pending = false;
+    if (!this.closed && this.controlSends.size !== 0) {
+      for (const nodeRoutingId of this.selectedRoutes.keys()) {
+        const exchange = this.controlSends.get(
+          controlSendKey(nodeRoutingId, M6aServiceWireCommand.hello)
+        );
+        if (exchange?.current?.() === true) {
+          pending = true;
+          break;
+        }
+      }
+    }
+    this.liveness.setAdmissionPending(pending, nowMs);
+  }
+
   tickLiveness(nowMs = performance.now()): ServiceLivenessTick {
+    const admissionDue = this.liveness.tickAdmission(nowMs);
     const result = this.liveness.tick(nowMs);
     this.requireStarted();
-    for (const nodeRoutingId of this.selectedRoutes.keys()) void this.announcePeer(nodeRoutingId);
+    if (admissionDue)
+      for (const nodeRoutingId of this.selectedRoutes.keys()) void this.announcePeer(nodeRoutingId);
     for (const probe of result.probes) {
       const parts = [
         livenessCodec.encodeLivenessRecord({
@@ -1257,6 +1412,7 @@ export class RawServiceMeshRuntime {
     for (const nodeRoutingId of selected) this.notifyPeerRouteChanged(nodeRoutingId);
     // A new selected route admits only through a new handshake.
     for (const nodeRoutingId of selected) await this.announcePeer(nodeRoutingId);
+    this.refreshAdmissionPending(performance.now());
     return changes;
   }
 
@@ -1289,15 +1445,16 @@ export class RawServiceMeshRuntime {
     payload: ServiceApplicationPayloadInput,
     timeoutMs: number,
     channelName?: string,
-    onAdmitted?: () => void
-  ): PendingOperation<RawServiceRequestResult> {
+    onAdmitted?: () => void,
+    observer?: RawServiceRequestObserver,
+    operationKind?: number
+  ): RawServiceObservedRequest {
     const correlation = this.nextCorrelation++;
     const header =
       channelName === undefined
         ? encodeNodeRequestHeader(correlation)
         : encodeChannelRequestHeader(correlation, channelName);
     const encodedPayload = this.applicationFrame(payload);
-    const pending = this.operations.register(timeoutMs);
     let selectedTargetNodeRoutingId = targetNodeRoutingId;
     if (
       selectedTargetNodeRoutingId !== this.descriptor.nodeRoutingId &&
@@ -1325,6 +1482,9 @@ export class RawServiceMeshRuntime {
       }
     }
     if (selectedTargetNodeRoutingId === this.descriptor.nodeRoutingId) {
+      // The local admission path aborts its capacity wait on the terminal
+      // Promise, so a local request always keeps the Promise entry.
+      const pending = this.operations.register(timeoutMs);
       const parts = [header, encodedPayload];
       const capacityStop = new AbortController();
       void pending.promise.finally(() => capacityStop.abort()).catch(() => undefined);
@@ -1369,12 +1529,13 @@ export class RawServiceMeshRuntime {
       })().catch((error) => this.operations.fail(pending.id, error));
       return pending;
     }
+    const pending = this.registerRequest(timeoutMs, observer, operationKind);
     const selectedPeer = this.topology.admittedPeer(selectedTargetNodeRoutingId);
     if (selectedPeer === undefined) {
       // Logical target selection is the requester's decision: an RID that is
       // not an admitted peer is not a target. Whether an admitted target's
       // route can carry the request is Core's REQUEST result.
-      this.operations.complete(pending.id, {
+      this.completeRequest(pending, {
         terminalResult: RequestResult.NotFound,
         failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
       });
@@ -1391,7 +1552,7 @@ export class RawServiceMeshRuntime {
         onAdmitted
       );
     } catch (error) {
-      this.operations.fail(pending.id, error);
+      this.failRequest(pending, error);
       return pending;
     }
     void request.then(
@@ -1568,6 +1729,8 @@ export class RawServiceMeshRuntime {
     hello?: Uint8Array
   ): boolean {
     const key = controlSendKey(target, command);
+    if (command === M6aServiceWireCommand.hello)
+      this.liveness.setAdmissionPending(true, performance.now());
     const existing = this.controlSends.get(key);
     if (
       existing !== undefined &&
@@ -1607,16 +1770,19 @@ export class RawServiceMeshRuntime {
       () => {},
       (error) => {
         completeSend();
-        if (this.infrastructureTaskRunner === undefined) this.reportInfrastructureFailure(error);
+        this.reportInfrastructureFailure(error);
       }
     );
-    this.infrastructureTaskRunner?.runDetached('RouteMesh control SEND', async () => {
-      await task;
-    });
     return true;
   }
 
-  private reportInfrastructureFailure(error: unknown): void {
+  reportInfrastructureFailure(error: unknown): void {
+    if (this.infrastructureTaskRunner !== undefined) {
+      this.infrastructureTaskRunner.runDetached('RouteMesh infrastructure', async () => {
+        throw error;
+      });
+      return;
+    }
     this.infrastructureFailure = {
       error:
         this.infrastructureFailure === undefined
@@ -1662,7 +1828,7 @@ export class RawServiceMeshRuntime {
 }
 
 function controlSendKey(target: string, command: number): string {
-  return JSON.stringify([target, command]);
+  return `${command}:${target}`;
 }
 
 function routeConnectionId(generation: bigint): string {
@@ -1674,20 +1840,31 @@ function routeConnectionId(generation: bigint): string {
  * not application NodeSend(16) envelopes. Keep this list closed: a bare
  * record outside the frozen control vocabulary remains a protocol error.
  */
+const BARE_INFRASTRUCTURE_CONTROLS: ReadonlySet<number> = new Set<number>([
+  ServiceWireCommand.relocationReady,
+  ServiceWireCommand.relocationData,
+  ServiceWireCommand.replyRelay,
+  ServiceWireCommand.relocationCutover,
+  ServiceWireCommand.relocationPrepare,
+  ServiceWireCommand.sessionRelocationSeal,
+  ServiceWireCommand.sessionRelocationSealed,
+  ServiceWireCommand.sessionRelocationRoute,
+  ServiceWireCommand.replyRelayAck,
+  ServiceWireCommand.relocationState,
+  ServiceWireCommand.relocationFailed
+]);
+
 function isBareInfrastructureControl(command: number): boolean {
-  return [
-    ServiceWireCommand.relocationReady,
-    ServiceWireCommand.relocationData,
-    ServiceWireCommand.replyRelay,
-    ServiceWireCommand.relocationCutover,
-    ServiceWireCommand.relocationPrepare,
-    ServiceWireCommand.sessionRelocationSeal,
-    ServiceWireCommand.sessionRelocationSealed,
-    ServiceWireCommand.sessionRelocationRoute,
-    ServiceWireCommand.replyRelayAck,
-    ServiceWireCommand.relocationState,
-    ServiceWireCommand.relocationFailed
-  ].includes(command as never);
+  return BARE_INFRASTRUCTURE_CONTROLS.has(command);
+}
+
+function isApplicationEnvelopeCommand(command: number): boolean {
+  return (
+    command === M6aServiceWireCommand.nodeSend ||
+    command === M6aServiceWireCommand.nodeRequest ||
+    command === M6aServiceWireCommand.channelSend ||
+    command === M6aServiceWireCommand.channelRequest
+  );
 }
 
 function protocolCommand(parts: readonly Uint8Array[]): { readonly command?: number } {

package/src/runtime/foundation/service-liveness-registry.ts

@@ -54,9 +54,20 @@ export class ServiceLivenessConnection {
 }
 
 /** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
+const NO_LIVENESS_WORK: ServiceLivenessTick = Object.freeze({
+  probes: Object.freeze([]) as readonly ServiceProbe[],
+  timedOutNodes: Object.freeze([]) as readonly string[]
+});
+
 export class ServiceLivenessRegistry {
   private readonly peers = new Map<string, ServiceLivenessConnection>();
   private nextProbeId = 1n;
+  /**
+   * The earliest probe or timeout among admitted peers. Received traffic only
+   * extends a peer's deadline, so this stays a lower bound between ticks.
+   */
+  private nextDueMs = Number.POSITIVE_INFINITY;
+  private admissionActivityMs?: number;
 
   constructor(
     private readonly probeIntervalMs = DEFAULT_SERVICE_PROBE_INTERVAL_MS,
@@ -89,9 +100,33 @@ export class ServiceLivenessRegistry {
       this.peerTimeoutMs
     );
     this.peers.set(nodeRoutingId, admitted);
+    this.nextDueMs = Math.min(this.nextDueMs, admitted.nextProbeMs, admitted.deadlineMs);
     return admitted;
   }
 
+  /** When the next tick has probe or timeout work (spec 08 §4.2 management deadline). */
+  nextDeadlineMs(): number {
+    return Math.min(this.nextDueMs, this.nextAdmissionDeadlineMs());
+  }
+
+  /** Pending admission shares the existing liveness management cadence (MeshNode §7.1). */
+  setAdmissionPending(pending: boolean, nowMs: number): void {
+    if (pending) this.admissionActivityMs ??= nowMs;
+    else this.admissionActivityMs = undefined;
+  }
+
+  private nextAdmissionDeadlineMs(): number {
+    return this.admissionActivityMs === undefined
+      ? Number.POSITIVE_INFINITY
+      : this.admissionActivityMs + this.probeIntervalMs;
+  }
+
+  tickAdmission(nowMs: number): boolean {
+    if (nowMs < this.nextAdmissionDeadlineMs()) return false;
+    this.admissionActivityMs = nowMs;
+    return true;
+  }
+
   recordReceived(connection: ServiceLivenessConnection, nowMs: number): void {
     connection.recordReceived(nowMs);
   }
@@ -127,8 +162,10 @@ export class ServiceLivenessRegistry {
   }
 
   tick(nowMs: number): ServiceLivenessTick {
+    if (nowMs < this.nextDeadlineMs()) return NO_LIVENESS_WORK;
     const probes: ServiceProbe[] = [];
     const timedOutNodes: string[] = [];
+    let nextDueMs = Number.POSITIVE_INFINITY;
     for (const [nodeRoutingId, peer] of this.peers) {
       if (peer.isExpired(nowMs)) {
         timedOutNodes.push(nodeRoutingId);
@@ -138,7 +175,9 @@ export class ServiceLivenessRegistry {
       const probeId = peer.tryGetProbe(nowMs, this.allocateProbeId);
       if (probeId !== undefined)
         probes.push({ nodeRoutingId, connectionId: peer.connectionId, probeId });
+      nextDueMs = Math.min(nextDueMs, peer.nextProbeMs, peer.deadlineMs);
     }
+    this.nextDueMs = nextDueMs;
     timedOutNodes.sort();
     return { probes, timedOutNodes };
   }

package/src/runtime/foundation/service-mailbox.ts

@@ -1,13 +1,21 @@
 import type { ApplicationJobRecordLease } from '../application-jobs/application-ingress-record-owner';
 import type { ReceiveRecord } from './service-runtime-contracts';
+import type { RawServiceIngressRecord } from './raw-service-mesh-runtime';
 
 export type ServiceMailboxDomain = 'application' | 'infrastructure';
 
+export interface ServiceMailboxDispatchOwner {
+  prepareDispatch(record: ServiceMailboxRecord, signal: AbortSignal): boolean | Promise<boolean>;
+}
+
 export interface ServiceMailboxRecord {
+  readonly sourcePreparationOwner?: ServiceMailboxDispatchOwner;
+  readonly ingress?: RawServiceIngressRecord;
   readonly owner: string;
   readonly domain: ServiceMailboxDomain;
   parts: readonly Uint8Array[];
   readonly sourceRoutingId?: string;
+  readonly requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
   readonly sourceRoute?: Uint8Array;
   readonly requestSequence?: bigint;
   readonly reply?: (parts: readonly Uint8Array[]) => void;

package/src/runtime/foundation/service-maintenance-runtime.ts

@@ -1,7 +1,4 @@
-import { AsyncResource } from 'node:async_hooks';
-import { ZLinkStateLane } from '../execution/state-lane';
-
-const detachedStateLaneResource = new AsyncResource('zlink:service-maintenance-runtime');
+import { startOutsideStateLane, ZLinkStateLane } from '../execution/state-lane';
 
 export type ServiceMaintenanceKind = 'retire' | 'shutdown';
 export type ServiceMaintenanceState =
@@ -248,7 +245,3 @@ export class ServiceMaintenanceRuntime {
     for (const observer of publication.observers) observer(publication.snapshot);
   }
 }
-
-function startOutsideStateLane<T>(work: () => T): T {
-  return detachedStateLaneResource.runInAsyncScope(work);
-}