@zlink-systems/framework 0.30.1 → 0.30.2

package/src/runtime/spots/spot-actor-membership.ts

@@ -219,21 +219,6 @@ export class ZLinkSpotActorMembership {
     );
   }
 
-  async restoreActorAfterFailedTransfer(
-    spotId: RoutingId,
-    actor: ZLinkActor,
-    signal?: AbortSignal
-  ): Promise<void> {
-    throwIfAborted(signal);
-    const activation = this.requireActivation(spotId);
-    await this.runLifecycleOperation(activation, () =>
-      activation.serial.execute(async () => {
-        activation.cancelActorTransfer(actor.context.actorId);
-        await activation.spot.onJoinedActor(actor);
-      })
-    );
-  }
-
   async beginActorTransfer(spotId: RoutingId, actorId: string): Promise<void> {
     const activation = this.requireActivation(spotId);
     await this.runLifecycleOperation(activation, () =>

package/src/runtime/spots/spot-actor-packet-dispatch.ts

@@ -1,3 +1,7 @@
+import { actorMessageFollowContext } from '../actors/actor-message-follow-context';
+import { DefaultZLinkActorContext } from '../actors/actor-context';
+import { decodeSessionDisconnected } from '../actors/session-disconnected-wire';
+import { routingIdsEqual } from '../routing-id';
 import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import {
   ZLinkFrameworkInternalErrorKind,
@@ -12,7 +16,13 @@ import type {
   ZLinkSpot
 } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import { ZLinkFrameworkException, zlinkMessageMetadata } from '../../contracts';
+import {
+  ZLinkFrameworkException,
+  ZLinkFrameworkErrorKind,
+  ZLinkMessage,
+  ZLinkEncodedPayload,
+  zlinkMessageMetadata
+} from '../../contracts';
 import {
   ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
@@ -45,6 +55,10 @@ import { zlinkMetadataByteLength, zlinkSerialWorkOptions } from '../execution/se
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import { releaseApplicationJobPermitBeforeHandler } from '../application-jobs/application-job-queue-scope';
 
+const emptyDisconnectedReply = ZLinkMessage.fromEncoded(
+  ZLinkEncodedPayload.fromOwned(Buffer.alloc(0))
+);
+
 export interface ZLinkActorResponseOptions {
   readonly metadata: ReadonlyMap<string, string>;
   readonly compressPayload: boolean;
@@ -204,11 +218,13 @@ export class ZLinkSpotActorPacketDispatch {
             ? ZLinkDispatchErrorAction.ReplyError
             : ZLinkDispatchErrorAction.Drop;
         this.trace(ZLinkMessageFlowOutcome.Received, actorId, header, messageKind);
-        if (
-          this.options.actorLeft?.(actorId) === true &&
-          header.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET
-        ) {
-          return undefined;
+        const disconnected = header.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET;
+        const disconnectedReply =
+          disconnected && header.kind === ZLinkStreamMessageKind.Request
+            ? emptyDisconnectedReply
+            : undefined;
+        if (this.options.actorLeft?.(actorId) === true && disconnected) {
+          return disconnectedReply;
         }
         const routed = await this.options.routeBeforeLocal?.(delivery);
         if (routed?.handled === true) {
@@ -229,9 +245,34 @@ export class ZLinkSpotActorPacketDispatch {
             requestTerminal
           );
         }
-        if (header.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
+        if (disconnected) {
+          const identity = decodeSessionDisconnected(messageToBytes(parts[1]));
+          if (identity === undefined) {
+            if (this.options.dispatchErrors?.captureEnabled() === true)
+              this.reportInvalidFrame(
+                actorId,
+                messageKind,
+                new ZLinkFrameworkException(
+                  ZLinkFrameworkErrorKind.ProtocolError,
+                  'ProtocolError: malformed Session disconnect identity.'
+                ),
+                'warning'
+              );
+            return disconnectedReply;
+          }
+          const current =
+            actor.context instanceof DefaultZLinkActorContext
+              ? actor.context.currentSessionBinding
+              : undefined;
+          if (
+            current !== undefined &&
+            (!routingIdsEqual(current.sessionNodeRid, identity.sessionOwnerNodeRid) ||
+              current.sessionOwnerNodeGeneration !== identity.sessionOwnerNodeGeneration ||
+              current.bindingGeneration !== identity.bindingGeneration)
+          )
+            return disconnectedReply;
           await this.options.onDisconnectActor(actor);
-          return undefined;
+          return disconnectedReply;
         }
         const decodePayload = this.createPayloadDecoder(parts[1], header);
         return this.dispatchActorPacket(
@@ -303,7 +344,9 @@ export class ZLinkSpotActorPacketDispatch {
       return undefined;
     }
     const missingActorError = createInternalFrameworkException(
-      ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound,
+      actorMessageFollowContext(fallbackActorRef) === undefined
+        ? ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound
+        : ZLinkFrameworkInternalErrorKind.ActorLocationStale,
       `SPOT actor is not registered locally: ${actorId}`
     );
     if (
@@ -603,7 +646,8 @@ export class ZLinkSpotActorPacketDispatch {
   private reportInvalidFrame(
     actorId: string,
     messageKind: ZLinkDispatchMessageKind,
-    error?: unknown
+    error?: unknown,
+    severity?: 'warning'
   ): void {
     this.options.dispatchErrors?.report({
       surface: ZLinkDispatchErrorSurface.SpotActor,
@@ -612,7 +656,8 @@ export class ZLinkSpotActorPacketDispatch {
       action: ZLinkDispatchErrorAction.Drop,
       spotId: this.options.spotId(),
       actorId,
-      error
+      error,
+      severity
     });
   }
 

package/src/runtime/spots/spot-actor-packet-drain.ts

@@ -1,5 +1,4 @@
 import type { ActorRef, RoutingId, ZLinkMessageSerializer } from '../../contracts';
-import { ZLinkFrameworkException, ZLinkFrameworkErrorKind } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import { RequestResult } from '../backend/runtime-values';
@@ -7,15 +6,9 @@ import type { ZLinkBackendActorRef, ZLinkBackendActorRecvInfo } from '../backend
 import type { ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
 import { REMOTE_BOUND_SESSION_BIND_PACKET } from './spot-remote-codec';
 import { ZLINK_RECV_DONT_WAIT } from './spot-native-flags';
-import {
-  decodeStreamHeader,
-  encodeStreamFrame,
-  messageToBytes,
-  streamCodecForContentType,
-  ZLinkStreamHeaderFlags,
-  ZLinkStreamMessageKind
-} from '../streams/protocol';
-import { encodeFrameworkPayload } from '../messaging/payload-codec';
+import { decodeStreamHeader, messageToBytes, ZLinkStreamMessageKind } from '../streams/protocol';
+import { encodeActorReply } from '../actors/actor-reply';
+import { boundSessionErrorPayload } from '../streams/bound-session-response-target';
 
 export interface ZLinkActorDispatchPart {
   readonly info: {
@@ -218,7 +211,7 @@ export class ZLinkSpotActorPacketDrain {
           this.encodeActorReplyFrame(
             parts[0],
             ZLinkStreamMessageKind.Error,
-            frameworkErrorPayload(error)
+            boundSessionErrorPayload(error)
           )
         ],
         RequestResult.Ok
@@ -231,37 +224,14 @@ export class ZLinkSpotActorPacketDrain {
     kind: ZLinkStreamMessageKind.Response | ZLinkStreamMessageKind.Error,
     payload: unknown
   ): Message {
-    const requestHeader = decodeStreamHeader(messageToBytes(requestHeaderPart), this.flowEnabled());
-    const encoded = encodeFrameworkPayload(
+    const [frame] = encodeActorReply(
+      messageToBytes(requestHeaderPart),
+      kind,
       payload,
       this.options.messageSerializers,
-      kind === ZLinkStreamMessageKind.Response ? requestHeader.name : undefined,
-      'payload'
+      this.flowEnabled()
     );
-    try {
-      //  encodeStreamFrame returns a fresh, unaliased array; view it without re-copying.
-      const frame = encodeStreamFrame(
-        {
-          kind,
-          codec: streamCodecForContentType(encoded.contentType),
-          flags: ZLinkStreamHeaderFlags.None,
-          requestSeq: requestHeader.requestSeq,
-          name: '',
-          metadata: new Map(),
-          correlationId: requestHeader.correlationId,
-          // Spec 27 §7: preserve the request flow pair on the reply while
-          // tracing is on; the gated decode above already strips it at Off.
-          flowId: requestHeader.flowId,
-          flowOrigin: requestHeader.flowOrigin
-        },
-        encoded.message.data()
-      );
-      return RuntimeMessage.fromOwned(
-        Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength)
-      ) as Message;
-    } finally {
-      encoded.message.close();
-    }
+    return RuntimeMessage.fromOwned(frame) as Message;
   }
 
   private consumeRemoteBoundSessionBind(
@@ -329,16 +299,3 @@ function isStreamHeaderMessage(message: Message, flowEnabled: boolean): boolean
 function closeMessages(messages: readonly Message[]): void {
   for (const message of messages) message.close();
 }
-
-function frameworkErrorPayload(error: unknown): {
-  readonly message: string;
-  readonly kind: ZLinkFrameworkErrorKind;
-} {
-  return {
-    message: error instanceof Error ? error.message : String(error),
-    kind:
-      error instanceof ZLinkFrameworkException
-        ? error.kind
-        : ZLinkFrameworkErrorKind.InternalFailure
-  };
-}

package/src/runtime/spots/spot-entry-activation.ts

@@ -1,3 +1,4 @@
+import { currentApplicationJobOrigin } from '../application-jobs/application-job-queue-scope';
 import type {
   ActorRef,
   RoutingId,
@@ -50,7 +51,7 @@ import {
   DefaultZLinkSpotHandlerRegistry
 } from './spot-handler-registry';
 import { DefaultZLinkSpotOutbound, type ZLinkSpotRoutedTransport } from './spot-outbound';
-import { createProviderInstance } from './spot-provider';
+import { createFreshProviderInstance } from './spot-provider';
 import { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import { ZLinkSpotSerialExecutor } from './spot-serial-executor';
 import { invokeSpotClosing } from './spot-closing';
@@ -269,7 +270,7 @@ export class ZLinkEntrySpotActivation {
   }
 
   async create(): Promise<void> {
-    const entrySpot = await createProviderInstance(
+    const entrySpot = await createFreshProviderInstance(
       this.options.entrySpotType,
       this.options.providerResolver,
       this.context
@@ -479,23 +480,7 @@ export class ZLinkEntrySpotActivation {
       remoteBoundSessionTarget,
       fallbackActorRef,
       undefined,
-      messageFollowOrigin,
-      (
-        replayedParts,
-        replayReturnResponse,
-        replayRemoteBoundSessionTarget,
-        replayFallbackActorRef
-      ) =>
-        this.spotSerialExecutor.executeActor(actorId, () =>
-          this.dispatchActorPacketInsideMailbox({
-            origin: delivery.origin,
-            actorId,
-            parts: replayedParts,
-            returnResponse: replayReturnResponse,
-            remoteBoundSessionTarget: replayRemoteBoundSessionTarget,
-            fallbackActorRef: replayFallbackActorRef
-          })
-        )
+      messageFollowOrigin
     );
     if (handoff !== undefined) return await handoff;
     return this.spotSerialExecutor.executeActor(actorId, () =>
@@ -503,6 +488,26 @@ export class ZLinkEntrySpotActivation {
     );
   }
 
+  /** Restores source packets through the Entry Actor's existing executor. */
+  admitActorPacketPrefix(
+    actorId: string,
+    records: readonly import('../actors/actor-handoff').ZLinkActorHandoffPrefixRecord[]
+  ): import('../actors/actor-handoff').ZLinkActorHandoffPrefixAdmission {
+    return this.spotSerialExecutor.admitActorPacketPrefix(
+      actorId,
+      records,
+      (_serial, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) =>
+        this.dispatchActorPacketInsideMailbox({
+          origin: currentApplicationJobOrigin(),
+          actorId,
+          parts,
+          returnResponse,
+          remoteBoundSessionTarget,
+          fallbackActorRef
+        })
+    );
+  }
+
   private async replayActorBacklog(
     actor: ZLinkActor,
     backlog: readonly ZLinkActorHandoffPacket[]

package/src/runtime/spots/spot-handler-registry.ts

@@ -2,9 +2,11 @@ import type {
   Type,
   ZLinkActor,
   ZLinkEntrySpot,
+  ZLinkInstanceSpot,
   ZLinkInstanceSpotHandlerRegistry,
   ZLinkSpot,
-  ZLinkSpotHandlerRegistry
+  ZLinkSpotHandlerRegistry,
+  ZLinkSpotTimerHandler
 } from '../../contracts';
 import type {
   ZLinkEntrySpotActorRequestHandlerRegistration,
@@ -26,7 +28,7 @@ import { ZLinkActorPacketKind, ZLinkSpotActorHandlerRegistryRuntime } from '../a
 import { readZLinkDecoratorMetadata } from '../../contracts/Handlers/Attributes';
 
 export interface ZLinkSpotHandlerRegistration {
-  readonly kind: 'packet' | 'subscribe' | 'actorSend' | 'actorRequest' | 'spotHandler';
+  readonly kind: 'packet' | 'subscribe' | 'actorSend' | 'actorRequest' | 'timer';
   readonly handlerType: Type;
   readonly packetName?: string;
   readonly channelName?: string;
@@ -195,9 +197,11 @@ export class DefaultZLinkSpotHandlerRegistry<
     return this.addSubscribe(handlerType, channelName, topic);
   }
 
-  addSpotHandler(handlerType: Type): this {
+  addTimerHandler<THandler extends ZLinkSpotTimerHandler<ZLinkSpot>>(
+    handlerType: Type<THandler>
+  ): this {
     prepareHandlerInstance(this.providerResolver, handlerType);
-    this.entries.push({ kind: 'spotHandler', handlerType });
+    this.entries.push({ kind: 'timer', handlerType });
     return this;
   }
 
@@ -218,6 +222,13 @@ export class DefaultZLinkInstanceSpotHandlerRegistry implements ZLinkInstanceSpo
     return this;
   }
 
+  addTimerHandler<THandler extends ZLinkSpotTimerHandler<ZLinkInstanceSpot>>(
+    handlerType: Type<THandler>
+  ): this {
+    this.registrations.addTimerHandler(handlerType as never);
+    return this;
+  }
+
   snapshot(): readonly ZLinkSpotHandlerRegistration[] {
     return this.registrations.snapshot();
   }

package/src/runtime/spots/spot-manager-internal-contracts.ts

@@ -5,7 +5,7 @@ export interface ZLinkLocalSpotCreateResult {
   readonly state: ZLinkSpotCreateState;
   readonly reply?: unknown;
   readonly publication?: {
-    publish(): void;
-    abort(): void;
+    publish(): void | Promise<void>;
+    abort(): void | Promise<void>;
   };
 }

package/src/runtime/spots/spot-manager-public.ts

@@ -196,7 +196,7 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
       yield: (signal) => {
         const yieldTurn = requireZLinkYieldTurn(turn);
         const pending = this.submit(spotId, stableType, generatedIdentity, state, signal);
-        return yieldTurn.yieldPromise(pending);
+        return yieldTurn.yieldFrameworkPromise(pending);
       }
     };
     return call;
@@ -264,7 +264,7 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
             }
           };
         } catch (error) {
-          this.options.local.abortUserSpotPublication(target.meshName, spotId);
+          await this.options.local.abortUserSpotPublication(target.meshName, spotId);
           throw error;
         }
       },

package/src/runtime/spots/spot-node-autoconnect.ts

@@ -1,3 +1,4 @@
+import { routingIdsEqual } from '../routing-id';
 import { ZLINK_DEFAULT_PUBLIC_WEIGHT } from '../../contracts/Configuration/RegistrationBuilderPolicy';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { ZLinkPeerLocationFilter } from '../../contracts/Locations/Keys';
@@ -8,13 +9,13 @@ import { ZLinkLocationAutoConnectType } from '../../contracts/Locations/Values';
 import { ZLinkFrameworkRuntimeState, ZLinkLocationRole } from '../../contracts';
 import type { ZLinkSpotNodeOptions } from '../configuration';
 import type { ZLinkBackendMeshNode } from '../backend/contracts';
-import { AsyncResource } from 'node:async_hooks';
-import { ZLinkStateLane } from '../execution/state-lane';
+import { startOutsideStateLane, ZLinkStateLane } from '../execution/state-lane';
 import { toBackendRoutingId as toBackendRoutingId } from '../routing-id';
 import { MeshPeerRuntimeState } from '../foundation/service-runtime-contracts';
 import {
   ZLinkLocationRuntime,
   ZLinkOwnerLeaseTracker,
+  ZLinkRequestSourceResolver,
   type IZLinkAutoConnectExecutor,
   type ZLinkAutoConnectLocal,
   type ZLinkAutoConnectTarget,
@@ -28,6 +29,7 @@ export interface ZLinkSpotNodeLocationAutoConnectContext {
   readonly options: ZLinkLocationOptionOverrides;
   readonly leaseTracker: ZLinkOwnerLeaseTracker;
   readonly resolver: ZLinkPeerLocationResolver;
+  readonly requestSources: ZLinkRequestSourceResolver;
   readonly events?: ZLinkLocationEventSink;
   readonly changeStampStore?: Pick<ZLinkLocationStore, 'getMeshNodeChangeStamp'>;
 }
@@ -48,12 +50,17 @@ export function createSpotNodeLocationAutoConnectContext(
     store: stores.ownerLeaseStore,
     options
   });
+  const requestSources = new ZLinkRequestSourceResolver({
+    listLiveMeshNodes: (meshName, signal) => runtime.listLiveMeshNodes(meshName, signal),
+    remainingOwnerTokenLeaseMs: (owner, signal) => runtime.remainingOwnerTokenLeaseMs(owner, signal)
+  });
   return {
     runtime,
     stores,
     options,
     leaseTracker,
-    resolver: meshDescriptorPeerResolver(runtime),
+    resolver: meshDescriptorPeerResolver(runtime, requestSources),
+    requestSources,
     events,
     // The opaque provider has no cross-process change notification primitive.
     // A process-local inherited stamp would hide descriptors written by peers,
@@ -86,14 +93,16 @@ export function spotNodeAutoConnectCapability(
       (channel) => channel.server === true
     )
   };
-  const manualConnections = hasManualRouterConnections(spotNode);
   return {
     local,
-    executor: new ZLinkSpotNodeAutoConnectExecutor(node, manualConnections)
+    executor: new ZLinkSpotNodeAutoConnectExecutor(node)
   };
 }
 
-function meshDescriptorPeerResolver(runtime: ZLinkLocationRuntime): ZLinkPeerLocationResolver {
+function meshDescriptorPeerResolver(
+  runtime: ZLinkLocationRuntime,
+  requestSources: ZLinkRequestSourceResolver
+): ZLinkPeerLocationResolver {
   return {
     async listLivePeers(
       filter: ZLinkPeerLocationFilter,
@@ -108,6 +117,8 @@ function meshDescriptorPeerResolver(runtime: ZLinkLocationRuntime): ZLinkPeerLoc
         return [];
       }
       const descriptors = await runtime.listLiveMeshNodes(filter.meshName, signal);
+      // The auto-connect poll owns the live descriptors; request acceptance reads them.
+      await requestSources.observeLiveDescriptors(filter.meshName, descriptors, signal);
       return descriptors
         .map((descriptor): ZLinkPeerLocation => ({
           autoConnectType: ZLinkLocationAutoConnectType.RouteMesh,
@@ -130,22 +141,13 @@ function meshDescriptorPeerResolver(runtime: ZLinkLocationRuntime): ZLinkPeerLoc
         }))
         .filter(
           (peer) =>
-            (filter.nodeRid === undefined || String(peer.nodeRid) === String(filter.nodeRid)) &&
+            (filter.nodeRid === undefined || routingIdsEqual(peer.nodeRid, filter.nodeRid)) &&
             (filter.endpoint === undefined || peer.endpoint === filter.endpoint)
         );
     }
   };
 }
 
-function hasManualRouterConnections(spotNode: ZLinkSpotNodeOptions): boolean {
-  return (
-    (spotNode.router?.manualConnections?.length ?? 0) > 0 ||
-    (spotNode.router?.manualPeerConnections?.length ?? 0) > 0
-  );
-}
-
-const detachedSpotNodeAutoConnectResource = new AsyncResource('zlink:spot-node-autoconnect');
-
 interface ZLinkSpotNodeConnectionIntent {
   connectionIntentId?: bigint;
 }
@@ -154,10 +156,7 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
   private readonly lane = new ZLinkStateLane();
   private readonly connectionIntents = new Map<string, ZLinkSpotNodeConnectionIntent>();
 
-  constructor(
-    private readonly node: ZLinkBackendMeshNode,
-    private readonly manualConnections: boolean
-  ) {}
+  constructor(private readonly node: ZLinkBackendMeshNode) {}
 
   onDisconnected(handler: (endpoint: string) => void): void {
     this.node.onPeerDisconnected?.(handler);
@@ -172,7 +171,7 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
       return false;
     const intent = await this.lane.run(() => this.prepareConnectCore(key));
     if (intent === undefined) return true;
-    return await runDetachedSpotNodeAutoConnect(() => this.connectPeer(target, key, intent));
+    return await startOutsideStateLane(() => this.connectPeer(target, key, intent));
   }
 
   disconnect(target: ZLinkAutoConnectTarget): void {
@@ -180,24 +179,6 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
     this.disconnectPeer(target);
   }
 
-  disconnectStalePeers(targets: readonly ZLinkAutoConnectTarget[]): void {
-    if (this.manualConnections) return;
-    const current = new Map(
-      targets
-        .filter((target) => target.nodeRid !== undefined)
-        .map((target) => [String(target.nodeRid), target])
-    );
-    const peers = this.node.peers();
-    for (const peer of peers) {
-      if (peer.routingId === null) continue;
-      const target = current.get(String(peer.routingId));
-      if (target !== undefined && peer.endpoint === target.endpoint) {
-        continue;
-      }
-      this.node.disconnectPeer(peer.routingId, peer.lifecycleGeneration);
-    }
-  }
-
   isDisconnected(target: ZLinkAutoConnectTarget): boolean {
     // A connect intent still owns transport state even when its peer has not
     // reached the admitted table yet. Shutdown must remove that intent before
@@ -209,7 +190,7 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
         (peer) =>
           peer.routingId !== null &&
           peer.endpoint === target.endpoint &&
-          (target.nodeRid === undefined || String(peer.routingId) === String(target.nodeRid)) &&
+          (target.nodeRid === undefined || routingIdsEqual(peer.routingId, target.nodeRid)) &&
           peer.lifecycleGeneration === target.lifecycleGeneration &&
           peer.state === MeshPeerRuntimeState.Serving
       );
@@ -291,7 +272,7 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
       if (peer.endpoint !== target.endpoint) {
         continue;
       }
-      if (target.nodeRid !== undefined && String(peer.routingId) !== String(target.nodeRid)) {
+      if (target.nodeRid !== undefined && !routingIdsEqual(peer.routingId, target.nodeRid)) {
         continue;
       }
       this.node.disconnectPeer(peer.routingId, peer.lifecycleGeneration);
@@ -299,10 +280,6 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
   }
 }
 
-function runDetachedSpotNodeAutoConnect<T>(work: () => Promise<T>): Promise<T> {
-  return detachedSpotNodeAutoConnectResource.runInAsyncScope(work);
-}
-
 function connectionKey(target: ZLinkAutoConnectTarget): string {
   return `${target.nodeRid ?? ''}\0${target.lifecycleGeneration}\0${target.endpoint}`;
 }