@zlink-systems/framework 0.30.1 → 0.30.2

package/src/runtime/host/location-runtime-owner.ts

@@ -228,10 +228,6 @@ export class ZLinkLocationRuntimeOwner {
       this.options.registration.locations.options,
       this.currentEvents
     );
-    if (runtime.ownerLeaseUsable) {
-      await spotNodeRuntime.startLocationAutoConnect();
-      await channelRuntime.startLocationAutoConnect();
-    }
     return runtime;
   }
 
@@ -252,7 +248,7 @@ export class ZLinkLocationRuntimeOwner {
     const locations = this.options.registration.locations;
     if (locations.useInMemoryStores) {
       const provider = new ZLinkInMemoryProviderLocationStore();
-      const store = new ZLinkLocationStoreRepository(provider);
+      const store = new ZLinkLocationStoreRepository(provider, undefined, this.options.metrics);
       return {
         locationStore: store,
         authorityStore: store,
@@ -267,7 +263,7 @@ export class ZLinkLocationRuntimeOwner {
     }
     const provider = locations.storeInstance;
     if (provider !== undefined) {
-      const store = new ZLinkLocationStoreRepository(provider);
+      const store = new ZLinkLocationStoreRepository(provider, undefined, this.options.metrics);
       return {
         locationStore: store,
         authorityStore: store,

package/src/runtime/host/mesh-router-resolver.ts

@@ -13,14 +13,22 @@ export class MeshRouterResolver {
     );
   }
 
+  /**
+   * Runs on every node-direct send: a direct scan of the registered manual
+   * peers, without temporary arrays or a predicate closure per call.
+   */
   classifyManualNodeTarget(meshName: string, targetNodeRid: RoutingId): boolean | undefined {
     const router = this.registration.spotNodes.get(meshName)?.router;
     if (router === undefined) return undefined;
-    const manualConnections = router.manualConnections ?? [];
-    const manualPeers = router.manualPeerConnections ?? [];
-    if (manualConnections.length === 0 && manualPeers.length === 0) return undefined;
-    if (manualPeers.some((peer) => routingIdsEqual(peer.peerRid, targetNodeRid))) return true;
-    return manualConnections.length === 0 ? false : undefined;
+    const manualPeers = router.manualPeerConnections;
+    if (manualPeers !== undefined) {
+      for (const peer of manualPeers) {
+        if (routingIdsEqual(peer.peerRid, targetNodeRid)) return true;
+      }
+    }
+    const manualConnectionCount = router.manualConnections?.length ?? 0;
+    if (manualConnectionCount === 0 && (manualPeers?.length ?? 0) === 0) return undefined;
+    return manualConnectionCount === 0 ? false : undefined;
   }
 
   defaultRouterChannelId(): string | undefined {

package/src/runtime/host/remote-bound-session-relay.ts

@@ -26,18 +26,15 @@ import {
   ZLinkRemoteBoundSessionFenceError
 } from '../actors/bound-session-wire';
 import { encodeRemoteActorPacketTarget } from '../actors/actor-packet-relay-wire';
-import { decodeRoutingId as decodeWireRoutingId, routingIdsEqual } from '../routing-id';
+import { routingIdsEqual } from '../routing-id';
 import type { MeshRouterResolver } from './mesh-router-resolver';
 import {
-  encodeSessionRelocationRoute,
-  encodeSessionRelocationSeal,
   serviceSessionRelocationIdentityKey,
   type ServiceSessionRelocationRoute,
   type ServiceSessionRelocationSeal,
   type ServiceSessionRelocationSealed
 } from '../foundation/service-stateful-wire-codec';
 import { ServiceWireProtocolError } from '../foundation/service-wire-m6a-codec';
-import { BoundedReplayMap } from './bounded-replay-map';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
@@ -58,29 +55,12 @@ export interface ZLinkRemoteBoundSessionRelayOptions {
   readonly reportOwnershipRefreshError?: (actorId: string, error: unknown) => void;
 }
 
-const SERVICE_CONTROL_TERMINAL_CAPACITY = 4096;
-
 interface ActiveServiceWireSessionRelocation {
   readonly actorId: string;
-  readonly sealFingerprint: string;
   readonly sealPromise: Promise<ServiceSessionRelocationSealed>;
-  sealed?: ServiceSessionRelocationSealed;
   sealTimer?: ReturnType<typeof setTimeout>;
-  sealController?: AbortController;
   sealAbortCleanup?: () => void;
   terminal?: boolean;
-  routeRequestFingerprint?: string;
-  routeFingerprint?: string;
-  routePromise?: Promise<void>;
-}
-
-interface TerminalServiceWireSessionRelocation {
-  readonly actorId: string;
-  readonly sealFingerprint: string;
-  readonly sealed: ServiceSessionRelocationSealed;
-  /** Absent only when the Session seal timed out before command 44 arrived. */
-  readonly routeRequestFingerprint?: string;
-  readonly routeFingerprint?: string;
 }
 
 type RemoteBoundSessionSend = ReturnType<typeof decodeRemoteBoundSessionSendPayload>;
@@ -91,10 +71,6 @@ export class ZLinkRemoteBoundSessionRelay {
     string,
     ActiveServiceWireSessionRelocation
   >();
-  private readonly terminalServiceWireRelocations = new BoundedReplayMap<
-    string,
-    TerminalServiceWireSessionRelocation
-  >(SERVICE_CONTROL_TERMINAL_CAPACITY);
 
   constructor(private readonly options: ZLinkRemoteBoundSessionRelayOptions) {}
 
@@ -255,86 +231,42 @@ export class ZLinkRemoteBoundSessionRelay {
 
   async receiveServiceWireSessionRelocationSeal(
     value: ServiceSessionRelocationSeal,
-    signal?: AbortSignal
-  ): Promise<ServiceSessionRelocationSealed> {
+    signal?: AbortSignal,
+    onInstalled?: () => void
+  ): Promise<ServiceSessionRelocationSealed | undefined> {
+    const runtime = this.options.streamBindingRuntime();
+    const owner = actorSessionBindingRuntimeOwner(runtime);
+    const sealController = new AbortController();
+    const sealSignal =
+      signal === undefined
+        ? sealController.signal
+        : AbortSignal.any([signal, sealController.signal]);
+    const prepared = await owner.prepareSessionRelocationSeal(value, sealSignal);
+    if (prepared === undefined) return undefined;
+    if (prepared.response.sealResult === 'bindingAbsent') return prepared.response;
     const key = serviceWireBarrierKey(value);
-    const fingerprint = encodeSessionRelocationSeal(value).toString('base64');
-    const terminal = this.terminalServiceWireRelocations.get(key);
-    if (terminal !== undefined) {
-      if (terminal.sealFingerprint !== fingerprint) {
-        throw new ServiceWireProtocolError(
-          `Session relocation '${key}' repeated command 42 with different bytes.`
-        );
-      }
-      this.terminalServiceWireRelocations.touch(key);
-      return terminal.sealed;
-    }
-    const active = this.activeServiceWireRelocations.get(key);
-    if (active !== undefined) {
-      if (active.sealFingerprint !== fingerprint) {
-        throw new ServiceWireProtocolError(
-          `Session relocation '${key}' repeated command 42 with different bytes.`
-        );
-      }
-      return await active.sealPromise;
-    }
+    const existing = this.activeServiceWireRelocations.get(key);
+    if (existing !== undefined) return await existing.sealPromise;
     const actorId = value.actor.actor.actorId;
-
-    // Register the identity before the first asynchronous owner operation.
-    // Concurrent identical commands join this promise; different bytes for
-    // the same identity fail before they can install another seal.
-    let state!: ActiveServiceWireSessionRelocation;
-    const sealController = new AbortController();
-    const sealPromise = Promise.resolve().then(async () => {
-      await this.validateServiceWireSessionRoute(value);
-      await actorSessionBindingRuntimeOwner(this.options.streamBindingRuntime()).sealRelocation(
-        {
-          actorId,
-          actorGeneration: value.actor.actor.generation,
-          bindingGeneration: value.session.bindingGeneration,
-          sessionIdentity: value.session.sessionRid,
-          actorNodeRid: value.actor.actor.nodeRid,
-          actorNodeGeneration: value.actor.targetNodeGeneration,
-          sealId: key
-        },
-        {
-          objectGeneration: value.actor.actor.generation,
-          bindingGeneration: value.session.bindingGeneration
-        },
-        sealController.signal
-      );
-      return {
-        relocation: value.relocation,
-        coordinator: value.coordinator,
-        actor: value.actor,
-        session: value.session
-      } satisfies ServiceSessionRelocationSealed;
-    });
-    state = {
+    const state: ActiveServiceWireSessionRelocation = {
       actorId,
-      sealFingerprint: fingerprint,
-      sealPromise,
-      sealController
+      sealPromise: prepared.ready.then(() => prepared.response)
     };
     this.activeServiceWireRelocations.set(key, state);
+    onInstalled?.();
     const expire = async (error: unknown): Promise<void> => {
-      if (state.terminal === true || state.routePromise !== undefined) return;
+      if (
+        state.terminal === true ||
+        (await owner.relocationSnapshot(actorId, key))?.phase !== 'sealed'
+      )
+        return;
       state.terminal = true;
       sealController.abort(error);
       if (this.activeServiceWireRelocations.get(key) === state) {
         this.activeServiceWireRelocations.delete(key);
       }
-      if (state.sealed !== undefined) {
-        this.terminalServiceWireRelocations.remember(key, {
-          actorId,
-          sealFingerprint: state.sealFingerprint,
-          sealed: state.sealed
-        });
-      }
-      const owner = actorSessionBindingRuntimeOwner(this.options.streamBindingRuntime());
-      await owner.clearRelocation(actorId, error);
-      void this.options
-        .streamBindingRuntime()
+      await owner.clearRelocation(actorId, error, key);
+      void runtime
         .closeSessionBinding(actorId, value.session)
         .catch((disconnectError) =>
           this.options.reportOwnershipRefreshError?.(actorId, disconnectError)
@@ -360,26 +292,20 @@ export class ZLinkRemoteBoundSessionRelay {
       else signal.addEventListener('abort', onAbort, { once: true });
     }
     try {
-      const sealed = await sealPromise;
-      state.sealed = sealed;
-      return sealed;
+      return await state.sealPromise;
     } catch (error) {
       clearTimeout(state.sealTimer);
       state.sealAbortCleanup?.();
       if (this.activeServiceWireRelocations.get(key) === state) {
         this.activeServiceWireRelocations.delete(key);
       }
-      if (state.terminal !== true) {
-        const owner = actorSessionBindingRuntimeOwner(this.options.streamBindingRuntime());
-        if ((await owner.relocationSnapshot(actorId, key)) !== undefined) {
-          await owner.clearRelocation(actorId, error);
-          void this.options
-            .streamBindingRuntime()
-            .closeSessionBinding(actorId, value.session)
-            .catch((disconnectError) =>
-              this.options.reportOwnershipRefreshError?.(actorId, disconnectError)
-            );
-        }
+      if (state.terminal !== true && (await owner.relocationSnapshot(actorId, key)) !== undefined) {
+        await owner.clearRelocation(actorId, error, key);
+        void runtime
+          .closeSessionBinding(actorId, value.session)
+          .catch((disconnectError) =>
+            this.options.reportOwnershipRefreshError?.(actorId, disconnectError)
+          );
       }
       throw sealController.signal.aborted ? sealController.signal.reason : error;
     }
@@ -389,108 +315,50 @@ export class ZLinkRemoteBoundSessionRelay {
     value: ServiceSessionRelocationRoute
   ): Promise<void> {
     const key = serviceWireBarrierKey(value);
-    const routeRequestFingerprint = encodeSessionRelocationRoute(value).toString('base64');
-    const fingerprint = routeRequestFingerprint;
-    const terminal = this.terminalServiceWireRelocations.get(key);
-    if (terminal !== undefined) {
-      if (terminal.routeFingerprint === undefined) {
-        // The Session owner already closed this binding at the seal deadline.
-        // A late command 44 is terminal and cannot reactivate the route.
-        this.terminalServiceWireRelocations.touch(key);
-        this.warnLateSessionRouteUpdate(value);
-        return;
-      }
-      if (terminal.routeFingerprint !== fingerprint) {
-        throw new ServiceWireProtocolError(
-          `Session relocation '${key}' repeated command 44 with different bytes.`
-        );
-      }
-      this.terminalServiceWireRelocations.touch(key);
-      this.warnLateSessionRouteUpdate(value);
-      return;
-    }
+    const runtime = this.options.streamBindingRuntime();
+    const owner = actorSessionBindingRuntimeOwner(runtime);
     const state = this.activeServiceWireRelocations.get(key);
-    if (state === undefined) {
-      this.warnLateSessionRouteUpdate(value);
-      return;
-    }
-    if (
-      state.routeRequestFingerprint !== undefined &&
-      state.routeRequestFingerprint !== routeRequestFingerprint
-    ) {
-      throw new ServiceWireProtocolError(
-        `Session relocation '${key}' repeated command 44 with different bytes.`
-      );
-    }
-    if (state.routeFingerprint !== undefined) {
-      if (state.routeFingerprint !== fingerprint || state.routePromise === undefined) {
-        throw new ServiceWireProtocolError(
-          `Session relocation '${key}' repeated command 44 with different bytes.`
+    const accepted = await owner.acceptSessionRelocationRoute(value, async () => {
+      if (state === undefined) {
+        throw new ZLinkRemoteBoundSessionFenceError(
+          `Session relocation '${key}' has no active seal.`
         );
       }
-      this.warnLateSessionRouteUpdate(value);
-      await state.routePromise;
-      return;
-    }
-    state.routeRequestFingerprint = routeRequestFingerprint;
-    state.routeFingerprint = fingerprint;
-    if (state.sealTimer !== undefined) clearTimeout(state.sealTimer);
-    state.sealAbortCleanup?.();
-    const routePromise = state.sealPromise.then(async (sealed) => {
-      validateSessionRelocationRouteAgainstSeal(value, sealed);
-      await this.applyServiceWireSessionRelocationRoute(key, value);
-    });
-    state.routePromise = routePromise;
-    try {
-      await routePromise;
-      this.terminalServiceWireRelocations.remember(key, {
-        actorId: state.actorId,
-        sealFingerprint: state.sealFingerprint,
-        sealed: state.sealed ?? (await state.sealPromise),
-        routeRequestFingerprint,
-        routeFingerprint: fingerprint
-      });
-      if (this.activeServiceWireRelocations.get(key) === state) {
-        this.activeServiceWireRelocations.delete(key);
-      }
-      state.terminal = true;
-    } catch (error) {
-      // Command 44 is one-way. Once an exact update wins the timeout race,
-      // an apply failure cannot be repaired by waiting for an ACK-driven
-      // retry. Close the physical Session and terminalize this identity so a
-      // late duplicate cannot reactivate the binding or its held messages.
-      state.terminal = true;
-      if (this.activeServiceWireRelocations.get(key) === state) {
-        this.activeServiceWireRelocations.delete(key);
+      if (state.sealTimer !== undefined) clearTimeout(state.sealTimer);
+      state.sealAbortCleanup?.();
+      try {
+        const sealed = await state.sealPromise;
+        validateSessionRelocationRouteAgainstSeal(value, sealed);
+        await this.applyServiceWireSessionRelocationRoute(key, value);
+      } catch (error) {
+        // The binding owner chose this command. A failed one-way apply closes
+        // its physical Session; conflicting duplicates never enter this callback.
+        await owner.clearRelocation(state.actorId, error, key);
+        await runtime
+          .closeSessionBinding(state.actorId, value.session)
+          .catch((disconnectError) =>
+            this.options.reportOwnershipRefreshError?.(state.actorId, disconnectError)
+          );
+        throw error;
+      } finally {
+        state.terminal = true;
+        if (this.activeServiceWireRelocations.get(key) === state) {
+          this.activeServiceWireRelocations.delete(key);
+        }
       }
-      const sealed = state.sealed ?? (await state.sealPromise);
-      this.terminalServiceWireRelocations.remember(key, {
-        actorId: state.actorId,
-        sealFingerprint: state.sealFingerprint,
-        sealed,
-        routeRequestFingerprint,
-        routeFingerprint: fingerprint
-      });
-      actorSessionBindingRuntimeOwner(this.options.streamBindingRuntime()).clearRelocation(
-        state.actorId,
-        error
-      );
-      await this.options
-        .streamBindingRuntime()
-        .closeSessionBinding(state.actorId, value.session)
-        .catch((disconnectError) =>
-          this.options.reportOwnershipRefreshError?.(state.actorId, disconnectError)
-        );
-      throw error;
-    }
+    });
+    if (!accepted) this.warnLateSessionRouteUpdate(value);
   }
 
-  clearServiceWireSessionRelocations(): void {
+  async clearServiceWireSessionRelocations(): Promise<void> {
     for (const state of this.activeServiceWireRelocations.values()) {
       if (state.sealTimer !== undefined) clearTimeout(state.sealTimer);
+      state.sealAbortCleanup?.();
     }
     this.activeServiceWireRelocations.clear();
-    this.terminalServiceWireRelocations.clear();
+    await actorSessionBindingRuntimeOwnerIfRegistered(
+      this.options.streamBindingRuntime()
+    )?.clearSessionRelocationResults();
   }
 
   private warnLateSessionRouteUpdate(value: ServiceSessionRelocationRoute): void {
@@ -502,16 +370,12 @@ export class ZLinkRemoteBoundSessionRelay {
     value: ServiceSessionRelocationRoute
   ): Promise<void> {
     const runtime = this.options.streamBindingRuntime();
-    const owner = actorSessionBindingRuntimeOwner(runtime);
-    const fingerprint = encodeSessionRelocationRoute(value).toString('base64');
     if (value.route.action === 'abort') {
-      await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
-        if (!(await runtime.abortActorRouteSeal(value.actor.actorId, key))) {
-          throw new ZLinkRemoteBoundSessionFenceError(
-            `Actor '${value.actor.actorId}' command 44 abort lost its Session seal.`
-          );
-        }
-      });
+      if (!(await runtime.abortActorRouteSeal(value.actor.actorId, key))) {
+        throw new ZLinkRemoteBoundSessionFenceError(
+          `Actor '${value.actor.actorId}' command 44 abort lost its Session seal.`
+        );
+      }
     } else {
       const committedRoute = value.route;
       const current = (await runtime.find(value.actor.actorId))?.ref;
@@ -524,48 +388,25 @@ export class ZLinkRemoteBoundSessionRelay {
         actorId: value.actor.actorId,
         objectGeneration: value.actor.generation,
         meshName: current.meshName,
-        nodeRid: decodeWireRoutingId(committedRoute.targetNodeRid, undefined),
+        nodeRid: committedRoute.targetNodeRid,
         bindingGeneration: value.session.bindingGeneration,
         ownershipGeneration: committedRoute.targetAuthorityOwnerGeneration,
         ownerNodeGeneration: committedRoute.targetNodeGeneration,
         ownerLeaseGeneration: committedRoute.targetOwnerLeaseGeneration
       } as ActorRef;
-      await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
-        await runtime.commitActorRoute(targetActorRef, undefined, {
-          confirmRemoteSessionBinding: 'send',
-          releaseSeal: { sealId: key }
-        });
-        const currentGeneration = this.actorOwnershipGenerations.get(value.actor.actorId);
-        if (
-          currentGeneration === undefined ||
-          currentGeneration < committedRoute.targetAuthorityOwnerGeneration
-        ) {
-          this.actorOwnershipGenerations.set(
-            value.actor.actorId,
-            committedRoute.targetAuthorityOwnerGeneration
-          );
-        }
+      await runtime.commitActorRoute(targetActorRef, undefined, {
+        releaseSeal: { sealId: key }
       });
-    }
-    await owner.observeRelocationTerminal(value.actor.actorId, key, fingerprint);
-  }
-
-  private async validateServiceWireSessionRoute(
-    value: ServiceSessionRelocationSeal
-  ): Promise<void> {
-    const current = await this.options
-      .streamBindingRuntime()
-      .sessionRouteFence(value.actor.actor.actorId);
-    if (
-      current === undefined ||
-      current.actor.objectGeneration !== value.actor.actor.generation ||
-      !routingIdsEqual(current.actor.nodeRid, value.actor.actor.nodeRid) ||
-      current.sessionRid.toString() !== value.session.sessionRid ||
-      current.bindingGeneration !== value.session.bindingGeneration
-    ) {
-      throw new ZLinkRemoteBoundSessionFenceError(
-        `Actor '${value.actor.actor.actorId}' command 42 was fenced by its exact Session route.`
-      );
+      const currentGeneration = this.actorOwnershipGenerations.get(value.actor.actorId);
+      if (
+        currentGeneration === undefined ||
+        currentGeneration < committedRoute.targetAuthorityOwnerGeneration
+      ) {
+        this.actorOwnershipGenerations.set(
+          value.actor.actorId,
+          committedRoute.targetAuthorityOwnerGeneration
+        );
+      }
     }
   }
 
@@ -603,9 +444,6 @@ export class ZLinkRemoteBoundSessionRelay {
         this.activeServiceWireRelocations.delete(key);
       }
     }
-    for (const [key, value] of this.terminalServiceWireRelocations) {
-      if (value.actorId === actorId) this.terminalServiceWireRelocations.delete(key);
-    }
   }
 
   async sendActorResponse(

package/src/runtime/host/route-mesh-runtime.ts

@@ -42,7 +42,7 @@ const DEFAULT_ROUTE_MESH_DRAIN_TIMEOUT_MS = 30_000;
 const MAX_ROUTE_MESH_OBSERVATION_WAIT_MS = 1000;
 const PLACEMENT_OBSERVATION_INTERVAL_MS = 100;
 
-type ZLinkDrainForceReason =
+export type ZLinkDrainForceReason =
   'deadline_exceeded' | 'drain_state_publish_failed' | 'owner_cleanup_failed' | 'teardown_failed';
 
 type ZLinkMeshDrainResult =
@@ -74,7 +74,11 @@ export interface ZLinkRouteMeshRuntimeCoordinatorOptions {
   ) => Promise<void>;
   readonly shutdownResources?: (meshName: string, signal: AbortSignal) => Promise<void>;
   readonly cleanupHostResources: (signal: AbortSignal) => Promise<void>;
-  readonly forceStopResources: (meshName: string) => Promise<void>;
+  readonly forceStopResources: (
+    meshName: string,
+    reason: ZLinkDrainForceReason,
+    signal: AbortSignal
+  ) => Promise<void>;
 }
 
 export interface ZLinkLocalPlacementCounts {
@@ -465,7 +469,9 @@ export class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshRuntime {
           : deadline.signal.aborted
             ? 'deadline_exceeded'
             : classified;
-      await this.options.forceStopResources(meshName).catch(() => undefined);
+      await this.options
+        .forceStopResources(meshName, reason, deadline.signal)
+        .catch(() => undefined);
       result = { kind: 'forceStopped', reason };
       this.transition(meshName, state, ZLinkTopologyState.Failed);
     } finally {
@@ -526,7 +532,7 @@ export class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshRuntime {
             : classified;
       await Promise.all(
         entries.map(([meshName]) =>
-          this.options.forceStopResources(meshName).catch(() => undefined)
+          this.options.forceStopResources(meshName, reason, deadline.signal).catch(() => undefined)
         )
       );
       result = { kind: 'forceStopped', reason };
@@ -585,7 +591,7 @@ export class ZLinkRouteMeshRuntimeCoordinator implements ZLinkRouteMeshRuntime {
             : classified;
       await Promise.all(
         entries.map(([meshName]) =>
-          this.options.forceStopResources(meshName).catch(() => undefined)
+          this.options.forceStopResources(meshName, reason, signal).catch(() => undefined)
         )
       );
       result = { kind: 'forceStopped', reason, error };

package/src/runtime/host/runtime-shutdown.ts

@@ -5,7 +5,7 @@ import type { ZLinkLocationRuntime } from '../locations';
 import type { ZLinkSpotNodeRuntimeManager } from '../spots';
 import type { ZLinkStreamRuntimeManager } from '../streams';
 import type { ZLinkLocationRuntimeStopSnapshot } from './location-runtime-owner';
-import { isAbortError } from '../abort';
+import { awaitWithAbort, isAbortError } from '../abort';
 
 interface ZLinkRuntimeOwnedStore {
   dispose?(): void | Promise<void>;
@@ -29,7 +29,10 @@ export interface ZLinkRuntimeStopParts {
   readonly streamRuntime?: ZLinkStreamRuntimeManager;
   readonly spotNodeRuntime?: ZLinkSpotNodeRuntimeManager;
   readonly channelRuntime?: ZLinkChannelRuntimeManager;
-  readonly serviceRelocation?: { dispose(): Promise<void> };
+  readonly serviceRelocation?: {
+    drainActorJoinSources?(): Promise<void>;
+    dispose(): Promise<void>;
+  };
   readonly ownedStores?: readonly ZLinkRuntimeOwnedStore[];
 }
 
@@ -48,12 +51,20 @@ export async function rollbackRuntimeStart(parts: ZLinkRuntimeStartRollbackParts
 export async function stopRuntimeParts(parts: ZLinkRuntimeStopParts): Promise<void> {
   const state = parts.state;
   const errors: unknown[] = [];
+  await runShutdownStep(errors, () =>
+    awaitWithAbort(
+      Promise.resolve(parts.serviceRelocation?.drainActorJoinSources?.()),
+      parts.shutdownSignal
+    )
+  );
   await runShutdownStep(errors, () => parts.streamRuntime?.dispose());
   await runShutdownStep(errors, () =>
-    parts.spotNodeRuntime?.dispose(undefined, parts.cleanupDeadline)
+    parts.spotNodeRuntime?.dispose(parts.shutdownSignal, parts.cleanupDeadline)
   );
   await runShutdownStep(errors, () => parts.channelRuntime?.dispose());
-  await runShutdownStep(errors, () => parts.serviceRelocation?.dispose());
+  await runShutdownStep(errors, () =>
+    awaitWithAbort(Promise.resolve(parts.serviceRelocation?.dispose()), parts.shutdownSignal)
+  );
   await runShutdownStep(errors, () => parts.locationSnapshot.lifecycle?.dispose());
   await runShutdownStep(errors, () => parts.locationSnapshot.runtime?.stop(parts.shutdownSignal));
   await Promise.allSettled(state.listenerTasks);