@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/host/spot-address-transport.ts

@@ -1,3 +1,7 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation } from '../foundation/operation-registry';
+import { waitRequestReply } from '../messaging/request-deadline';
+import { mapZLinkRequestReply } from '../messaging/request-result';
 import type { ServiceInstanceColdActivationTarget } from '../foundation/service-stateful-wire-codec';
 import { ZLinkFrameworkException, ZLinkSpotKind, type RoutingId } from '../../contracts';
 import {
@@ -52,6 +56,7 @@ import type {
 } from '../spots/spot-routing-internal';
 
 export interface ZLinkHostSpotAddressTransportOptions {
+  readonly requests?: RequestRuntime;
   readonly resolver: () => ZLinkSpotRouteResolver | undefined;
   readonly routed: ZLinkSpotRoutedTransport;
   readonly meshNames: () => readonly string[];
@@ -81,7 +86,10 @@ type MissingTargetSelection =
 
 /** Owns global Spot authority lookup and Missing Instance placement. */
 export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport {
-  constructor(private readonly options: ZLinkHostSpotAddressTransportOptions) {}
+  private readonly requests: RequestRuntime;
+  constructor(private readonly options: ZLinkHostSpotAddressTransportOptions) {
+    this.requests = options.requests ?? new RequestRuntime();
+  }
 
   sendToSpotAddress(
     spotId: RoutingId,
@@ -252,67 +260,74 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     call: ZLinkSpotAddressCallOptions
   ): Promise<TReply> {
     const timeoutMs = call.timeoutMs ?? this.options.defaultRequestTimeoutMs;
-    const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
-    try {
-      const resolution = await this.resolveExisting(spotId, deadline.signal, call);
-      const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
-      if (resolution !== undefined && 'kind' in resolution)
-        call = this.reactivationCall(resolution, call);
-      deadline.requireRemaining();
-      if (existing === undefined) {
-        return await this.requestToMissingInstance(spotId, request, call, deadline, resolution);
-      }
-      this.validateExisting(existing, call);
+    return this.requests.request(timeoutMs, call.signal, async (requestOperation) => {
+      const deadline = createSpotAddressDeadline(requestOperation, call.signal);
       try {
-        return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
-      } catch (error) {
-        if (isSpotRouteRefreshError(error)) {
-          this.options.resolver()?.invalidate?.(spotId);
+        for (;;) {
+          deadline.requireRemaining();
+          const resolution = await waitRequestReply(
+            this.resolveExisting(spotId, deadline.signal, call),
+            'Spot address resolve',
+            requestOperation,
+            () => deadline.close()
+          );
+          const existing =
+            resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
+          if (resolution !== undefined && 'kind' in resolution)
+            call = this.reactivationCall(resolution, call);
+          deadline.requireRemaining();
+          try {
+            if (existing === undefined) {
+              return await this.requestToMissingInstance(
+                spotId,
+                request,
+                call,
+                deadline,
+                resolution
+              );
+            }
+            this.validateExisting(existing, call);
+            return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
+          } catch (error) {
+            if (
+              (existing !== undefined || isPreAdmissionStaleRoute(error)) &&
+              isSpotRouteRefreshError(error)
+            ) {
+              this.options.resolver()?.invalidate?.(spotId);
+            }
+            // §9 keeps admission-before-stale-route handling in this logical request.
+            if (call.instanceSpot && isPreAdmissionStaleRoute(error)) continue;
+            if (existing !== undefined) {
+              this.reportInstanceRequestError(
+                spotId,
+                request,
+                error,
+                existing.routerChannelId,
+                existing.targetNodeRid,
+                existing.stableType,
+                addressedInstanceErrorReason(error)
+              );
+            }
+            throw error;
+          }
         }
-        // Failover policy §4.4: SpotMoving is the owner's Ready owner-fence
-        // refusal, made before admission. With Instance intent, one authority
-        // read under the same deadline decides: Missing means Close released
-        // the incarnation, so the request activates a new one. Any other
-        // answer, and any message the owner admitted, keeps this terminal.
+      } catch (error) {
         if (
-          call.instanceSpot &&
-          isOwnerFenceRefusal(error) &&
-          (await this.resolveExisting(spotId, deadline.signal)) === undefined
+          error instanceof ZLinkFrameworkException &&
+          internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.DeadlineExceeded
         ) {
-          deadline.requireRemaining();
-          return await this.requestToMissingInstance(spotId, request, call, deadline);
+          throw createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
+            `Spot request for '${String(spotId)}' exceeded its end-to-end deadline.`,
+            true,
+            error
+          );
         }
-        this.reportInstanceRequestError(
-          spotId,
-          request,
-          error,
-          existing.routerChannelId,
-          existing.targetNodeRid,
-          existing.stableType,
-          addressedInstanceErrorReason(error)
-        );
         throw error;
+      } finally {
+        deadline.close();
       }
-    } catch (error) {
-      if (
-        deadline.expired() &&
-        !(
-          error instanceof ZLinkFrameworkException &&
-          internalFrameworkErrorKind(error) ===
-            ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
-        )
-      ) {
-        throw createInternalFrameworkException(
-          ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
-          `Spot request for '${String(spotId)}' exceeded its end-to-end deadline.`,
-          true,
-          error
-        );
-      }
-      throw error;
-    } finally {
-      deadline.close();
-    }
+    });
   }
 
   private async requestToExistingSpot<TReply>(
@@ -331,16 +346,29 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
       existing.stableType,
       existing.targetNodeRid
     );
-    const reply = await awaitWithAbort(
-      this.options.routed.requestToSpot<TReply>(existing, request, {
-        instanceSpot: call.instanceSpot,
-        timeoutMs: deadline.requireRemaining(),
-        signal: deadline.signal,
-        metadata: call.metadata,
-        onAdmitted: call.onAdmitted
-      }),
-      deadline.signal
-    );
+    // The address request owns the terminal entry. Observe the wire stage so
+    // a pre-admission refusal can reach the authority decision in §9.
+    const stage = new Promise<TReply>((resolve, reject) => {
+      const result = this.options.routed.requestToSpot<TReply>(
+        existing,
+        request,
+        {
+          instanceSpot: call.instanceSpot,
+          timeoutMs: deadline.requireRemaining(),
+          deadlineMs: deadline.deadlineMs,
+          signal: deadline.signal,
+          metadata: call.metadata,
+          onAdmitted: call.onAdmitted,
+          requestOperation: deadline.operation
+        },
+        {
+          operationCompleted: (_id, value) => resolve(value as TReply),
+          operationFailed: (_id, error) => reject(error)
+        }
+      );
+      if (result.operation === undefined) void mapZLinkRequestReply(result).then(resolve, reject);
+    });
+    const reply = await waitRequestReply(stage, 'Spot request', deadline.operation);
     this.traceInstanceAddress(
       ZLinkMessageFlowOutcome.ReplyReceived,
       ZLinkDispatchMessageKind.Request,
@@ -418,9 +446,11 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
           deadlineUnixMs,
           call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId),
           call.metadata,
-          call.onAdmitted
+          call.onAdmitted,
+          deadline.operation
         ),
-      deadline.signal
+      deadline.signal,
+      deadline.operation
     );
     this.traceInstanceAddress(
       ZLinkMessageFlowOutcome.Sent,
@@ -431,7 +461,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
       selected.target.stableType,
       selected.target.targetNodeRid
     );
-    const completion = await awaitWithAbort(completionPromise, deadline.signal);
+    const completion = await completionPromise;
     try {
       if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
         const error = missingInstanceRequestFailure(
@@ -754,19 +784,19 @@ function isSpotRouteRefreshError(error: unknown): error is ZLinkFrameworkExcepti
   if (!(error instanceof ZLinkFrameworkException)) return false;
   const kind = internalFrameworkErrorKind(error);
   return (
+    isPreAdmissionStaleRoute(error) ||
     kind === ZLinkFrameworkInternalErrorKind.SpotRouteNotFound ||
-    kind === ZLinkFrameworkInternalErrorKind.SpotGenerationStale ||
-    kind === ZLinkFrameworkInternalErrorKind.SpotMoving ||
     kind === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound ||
-    kind === ZLinkFrameworkInternalErrorKind.ActorLocationStale ||
     kind === ZLinkFrameworkInternalErrorKind.RouteNotConnected
   );
 }
 
-function isOwnerFenceRefusal(error: unknown): boolean {
+function isPreAdmissionStaleRoute(error: unknown): boolean {
   return (
     error instanceof ZLinkFrameworkException &&
-    internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotMoving
+    (internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotMoving ||
+      internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.ActorLocationStale ||
+      internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotGenerationStale)
   );
 }
 
@@ -828,41 +858,28 @@ function addressedInstanceErrorReason(error: unknown): ZLinkDispatchErrorReason
 }
 
 interface ZLinkSpotAddressDeadline {
+  readonly operation: PendingOperation<unknown>;
   readonly deadlineUnixMs: number;
+  readonly deadlineMs: number;
   readonly signal: AbortSignal;
   requireRemaining(): number;
-  expired(): boolean;
   close(): void;
 }
 
 function createSpotAddressDeadline(
-  timeoutMs: number,
+  operation: PendingOperation<unknown>,
   parent?: AbortSignal
 ): ZLinkSpotAddressDeadline {
   const startedAtMs = performance.now();
   const startedAtUnixMs = Date.now();
-  const deadlineMs = startedAtMs + Math.max(0, timeoutMs);
+  const deadlineMs = operation.deadlineMs ?? Number.POSITIVE_INFINITY;
   const controller = new AbortController();
-  let expired = false;
-  let timeout: ReturnType<typeof setTimeout> | undefined;
-  const expire = () => {
-    expired = true;
-    controller.abort();
-  };
-  const arm = () => {
-    if (timeout !== undefined) clearTimeout(timeout);
-    const remainingMs = deadlineMs - performance.now();
-    if (remainingMs <= 0) {
-      expire();
-      return;
-    }
-    timeout = setTimeout(expire, remainingMs);
-  };
-  arm();
   const abort = () => controller.abort(parent?.reason);
   if (parent?.aborted === true) abort();
   else parent?.addEventListener('abort', abort, { once: true });
   return {
+    operation,
+    deadlineMs,
     get deadlineUnixMs() {
       return Math.round(startedAtUnixMs + (deadlineMs - startedAtMs));
     },
@@ -870,7 +887,6 @@ function createSpotAddressDeadline(
     requireRemaining() {
       const remainingMs = deadlineMs - performance.now();
       if (remainingMs <= 0) {
-        expired = true;
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
           'Spot address operation exceeded its end-to-end deadline.',
@@ -879,9 +895,8 @@ function createSpotAddressDeadline(
       }
       return Math.max(1, Math.ceil(remainingMs));
     },
-    expired: () => expired,
     close() {
-      if (timeout !== undefined) clearTimeout(timeout);
+      controller.abort();
       parent?.removeEventListener('abort', abort);
     }
   };

package/src/runtime/host/spot-runtime-options-factory.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../../contracts/Configuration/Registration';
 import { routingIdsEqual } from '../routing-id';
 import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
 import { ZLinkSpotRelocationCoordinationMode, ZLinkUserSpotExecutionMode } from '../../contracts';
@@ -87,6 +88,8 @@ export class ZLinkSpotRuntimeOptionsFactory {
   create(actorTransferRuntime: ZLinkActorTransferRuntime): Partial<ZLinkSpotManagerOptions> {
     const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
     return {
+      defaultRequestTimeoutMs:
+        this.options.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
       nodeRid: undefined,
       nodeRidProvider: (meshName) => this.meshNodeRoutingId(meshName),
       nodeGenerationProvider: (meshName) =>

package/src/runtime/host/user-spot-creation-coordinator.ts

@@ -5,6 +5,7 @@ import {
   type SpotRef,
   type ZLinkSpotCreateResult,
   ZLinkFrameworkException,
+  ZLinkFrameworkErrorKind,
   ZLinkSpotCreateState
 } from '../../contracts';
 
@@ -25,6 +26,7 @@ import {
   wireReplyFailureException
 } from '../framework-errors-internal';
 import { encodeAuthorityKey } from '../locations/authority-key-codec';
+import type { ZLinkOwnerLeaseTracker } from '../locations/lease-tracker';
 import type {
   ZLinkAuthoritySnapshot,
   ZLinkLocationOwnerToken,
@@ -40,10 +42,11 @@ const DEFAULT_USER_SPOT_POLL_INTERVAL_MS = 10;
 
 export interface ZLinkUserSpotCreationCoordinatorOptions {
   readonly relocationPolicy?: (
-    meshName: string,
+    meshName: string | undefined,
     stableType: string
   ) => import('../locations/internal-location-contracts').ZLinkObjectReserveRequest['actorRelocationPolicy'];
   readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
+  readonly leaseTracker: Pick<ZLinkOwnerLeaseTracker, 'isOwnerTokenLive'>;
   readonly target: (
     request: Pick<ZLinkUserSpotCreationRequest, 'meshName' | 'stableType'>,
     signal?: AbortSignal,
@@ -134,6 +137,16 @@ export class ZLinkUserSpotCreationCoordinator {
     let target: Awaited<ReturnType<ZLinkUserSpotCreationCoordinatorOptions['target']>>;
     let reserved: ZLinkObjectReserveResult;
     for (;;) {
+      try {
+        const spot = await this.awaitReady(request, signal);
+        if (spot !== undefined) {
+          deadline.close();
+          return { result: { spot, state: ZLinkSpotCreateState.Existing }, spot };
+        }
+      } catch (error) {
+        deadline.close();
+        throw error;
+      }
       try {
         target = await this.options.target(request, signal, excludedNodeRids);
       } catch (error) {
@@ -147,6 +160,16 @@ export class ZLinkUserSpotCreationCoordinator {
         );
       }
       if (target === undefined) {
+        try {
+          const current = await this.options.store.readAuthority(
+            encodeAuthorityKey('user_spot', String(request.spotId)),
+            signal
+          );
+          if (current.kind !== 'missing') continue;
+        } catch (error) {
+          deadline.close();
+          throw error;
+        }
         deadline.close();
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted,
@@ -219,30 +242,14 @@ export class ZLinkUserSpotCreationCoordinator {
       }
       if (
         reserved.kind === 'alreadyExists' ||
-        (reserved.kind === 'conflict' &&
-          reserved.current.kind === 'snapshot' &&
-          reserved.current.allocation.objectKind === 'user_spot' &&
-          reserved.current.allocation.stableType === request.stableType)
-      ) {
-        if (request.generatedIdentity === true) {
-          deadline.close();
-          throw spotIdConflict(request.spotId);
-        }
-        try {
-          const spot = await this.awaitReady(request, signal);
-          if (spot !== undefined) {
-            deadline.close();
-            return { result: { spot, state: ZLinkSpotCreateState.Existing }, spot };
-          }
-        } catch (error) {
-          deadline.close();
-          throw error;
-        }
+        (reserved.kind === 'conflict' && reserved.current.kind === 'snapshot')
+      )
         continue;
-      }
-      if (reserved.kind !== 'placementCapacityExhausted') break;
+      if (reserved.kind === 'placementCapacityExhausted') continue;
+      if (!(reserved.kind === 'conflict' && reserved.current.kind === 'missing')) break;
       excludedNodeRids.add(encodeRoutingIdStorageHex(target.nodeRid));
     }
+
     if (reserved.kind === 'typeMismatch') {
       deadline.close();
       if (request.generatedIdentity === true) {
@@ -721,6 +728,7 @@ export class ZLinkUserSpotCreationCoordinator {
       signal.throwIfAborted();
       const current = await this.options.store.readAuthority(key, signal);
       if (current.kind === 'missing') return undefined;
+      if (request.generatedIdentity === true) throw spotIdConflict(request.spotId);
       if (
         current.allocation.objectKind !== 'user_spot' ||
         current.allocation.stableType !== request.stableType
@@ -730,6 +738,45 @@ export class ZLinkUserSpotCreationCoordinator {
           `User Spot '${String(request.spotId)}' has another stable type.`
         );
       }
+      const ownerLive = await this.options.leaseTracker.isOwnerTokenLive(
+        {
+          ownerId: current.ownerId,
+          leaseGeneration: current.ownerLeaseGeneration
+        },
+        signal
+      );
+      if (!ownerLive || current.allocation.state !== 'active') {
+        const release = this.options.store.releaseEndedReservation;
+        if (release === undefined) {
+          throw new ZLinkFrameworkException(
+            ZLinkFrameworkErrorKind.NotConfigured,
+            'User Spot creation requires repository ended-owner release support.'
+          );
+        }
+        if (
+          await release.call(this.options.store, key, current.storeVersion.value, signal, {
+            key: { kind: 'user_spot', globalId: String(request.spotId) },
+            intent: { stableType: request.stableType },
+            actorRelocationPolicy: this.options.relocationPolicy?.(
+              request.meshName,
+              request.stableType
+            )
+          })
+        )
+          continue;
+        const confirmed = await this.options.store.readAuthority(key, signal);
+        if (
+          confirmed.kind === 'missing' ||
+          confirmed.storeVersion.value !== current.storeVersion.value
+        )
+          continue;
+        if (!ownerLive) {
+          throw new ZLinkFrameworkException(
+            ZLinkFrameworkErrorKind.Unavailable,
+            'User Spot authority owner lease is unavailable.'
+          );
+        }
+      }
       if (
         current.allocation.state === 'active' &&
         decodeServiceClosingSpotAuthority(current.payload) === undefined

package/src/runtime/internal-observation.ts

@@ -0,0 +1,2 @@
+// Internal snapshots are available only through this module, not a package entry.
+export const inspectRuntime = Symbol('zlink.internal.runtime-observation');

package/src/runtime/locations/actor-location-claims.ts

@@ -1,3 +1,4 @@
+import { ZLinkFrameworkException, ZLinkFrameworkErrorKind } from '../../contracts/Errors';
 import type { ActorRef, RoutingId } from '../../contracts/Common';
 import {
   ZLinkLocationKind,
@@ -214,7 +215,8 @@ export class ZLinkActorLocationClaims {
     spotId: RoutingId,
     spotGeneration: bigint,
     spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User,
-    ownerNodeGeneration: bigint
+    ownerNodeGeneration: bigint,
+    signal?: AbortSignal
   ): Promise<void> {
     const actorId = actorRef.actorId;
     const store = this.authorityStore;
@@ -223,14 +225,17 @@ export class ZLinkActorLocationClaims {
       throw new Error('Actor membership commit requires Location Store authority and owner.');
     }
     const key = encodeAuthorityKey('actor', actorId);
-    const current = await store.readAuthority(key);
+    const current = await store.readAuthority(key, signal);
     if (
       !matchesActorAuthority(current, actorRef, owner) ||
       current.allocation.stableType !== actorType ||
       current.authorityOwnerGeneration !== authorityOwnerGeneration ||
       current.allocation.descriptorLifecycleGeneration !== ownerNodeGeneration
     ) {
-      throw new Error(`Actor '${actorId}' membership authority fence does not match.`);
+      throw new ZLinkFrameworkException(
+        classifyMembershipAuthorityFailure(current, actorRef),
+        `Actor '${actorId}' membership authority fence does not match.`
+      );
     }
     const identity = decodeActorAuthorityIdentity(current.payload, current.objectGeneration);
     if (
@@ -242,21 +247,33 @@ export class ZLinkActorLocationClaims {
       !routingIdsEqual(identity.actor.nodeRid, actorRef.nodeRid) ||
       identity.meshName !== actorRef.meshName
     ) {
-      throw new Error(`Actor '${actorId}' membership authority identity does not match.`);
+      throw new ZLinkFrameworkException(
+        ZLinkFrameworkErrorKind.Unavailable,
+        `Actor '${actorId}' membership authority identity does not match.`
+      );
     }
-    const result = await store.compareExchangeAuthority(key, current.storeVersion, {
-      kind: 'put',
-      generationTransition: 'preserve',
-      payload: rewriteActorAuthorityRoute(
-        current.payload,
-        actorRef,
-        String(spotId),
-        spotGeneration,
-        spotKind
-      )
-    });
+    const result = await store.compareExchangeAuthority(
+      key,
+      current.storeVersion,
+      {
+        kind: 'put',
+        generationTransition: 'preserve',
+        payload: rewriteActorAuthorityRoute(
+          current.payload,
+          actorRef,
+          String(spotId),
+          spotGeneration,
+          spotKind
+        )
+      },
+      signal
+    );
     if (result.kind !== 'stored') {
-      throw new Error(
+      throw new ZLinkFrameworkException(
+        result.kind === 'conflict'
+          ? (result.membershipFailure ??
+              classifyMembershipAuthorityFailure(result.current, actorRef))
+          : ZLinkFrameworkErrorKind.InternalFailure,
         `Actor '${actorId}' membership commit was rejected with status ${result.kind}.`
       );
     }
@@ -442,6 +459,15 @@ interface TrackedActor {
   readonly deactivate?: () => Promise<void>;
 }
 
+function classifyMembershipAuthorityFailure(
+  current: { readonly kind: 'missing' } | ZLinkAuthoritySnapshot,
+  actorRef: ActorRef
+): ZLinkFrameworkErrorKind {
+  return current.kind === 'snapshot' && current.objectGeneration !== actorRef.objectGeneration
+    ? ZLinkFrameworkErrorKind.InvalidOperation
+    : ZLinkFrameworkErrorKind.Unavailable;
+}
+
 function matchesActorAuthority(
   current: { readonly kind: 'missing' } | ZLinkAuthoritySnapshot,
   actorRef: ActorRef,

package/src/runtime/locations/auto-connect-loop.ts

@@ -6,7 +6,6 @@ import type { ZLinkDomainLocationStore as ZLinkLocationStore } from './domain-st
 import type { ZLinkOwnerLeaseTracker } from './lease-tracker';
 import type { ZLinkAutoConnectLocal } from './auto-connect-types';
 import type { ZLinkAutoConnectReconciler } from './auto-connect-reconciler';
-import { ZLinkStateLane } from '../execution/state-lane';
 
 export interface ZLinkAutoConnectLoopOptions {
   readonly reconciler: ZLinkAutoConnectReconciler;
@@ -19,7 +18,6 @@ export interface ZLinkAutoConnectLoopOptions {
 }
 
 export class ZLinkAutoConnectLoop {
-  private readonly lane = new ZLinkStateLane();
   private readonly reconciler: ZLinkAutoConnectReconciler;
   private readonly options: Required<ZLinkLocationOptionOverrides>;
   private readonly meshName: string;
@@ -46,15 +44,19 @@ export class ZLinkAutoConnectLoop {
   }
 
   async start(signal?: AbortSignal): Promise<void> {
-    if (await this.lane.run(() => this.controller !== undefined)) return;
-    await this.tick(signal);
-    const started = await this.lane.run(() => {
-      if (this.controller !== undefined) return false;
-      this.controller = new AbortController();
-      return true;
-    });
-    if (!started) return;
-    this.scheduleNext();
+    if (this.controller !== undefined) return;
+    // Reserve the lifecycle before yielding so stop also owns the first publication.
+    const controller = new AbortController();
+    this.controller = controller;
+    try {
+      await this.tick(signal);
+    } catch (error) {
+      if (this.controller === controller) {
+        await this.prepareTransportShutdown();
+      }
+      throw error;
+    }
+    this.scheduleNext(controller);
   }
 
   async requestPeerReconcile(meshName: string, _peerRid: string): Promise<void> {
@@ -91,8 +93,14 @@ export class ZLinkAutoConnectLoop {
 
   async tick(signal?: AbortSignal): Promise<void> {
     const controller = this.controller;
+    const tickSignal =
+      controller === undefined
+        ? signal
+        : signal === undefined
+          ? controller.signal
+          : AbortSignal.any([signal, controller.signal]);
     await this.enqueueTick(async () => {
-      if (controller?.signal.aborted !== true) await this.tickCore(signal ?? controller?.signal);
+      if (tickSignal?.aborted !== true) await this.tickCore(tickSignal);
     });
   }
 
@@ -144,15 +152,15 @@ export class ZLinkAutoConnectLoop {
     return this.lastTickFailed;
   }
 
-  private scheduleNext(): void {
-    if (this.controller === undefined || this.controller.signal.aborted) {
+  private scheduleNext(controller: AbortController): void {
+    if (this.controller !== controller || controller.signal.aborted) {
       return;
     }
     this.timer = this.setTimer(() => {
       this.timer = undefined;
-      void this.tick(this.controller?.signal)
+      void this.tick(controller.signal)
         .catch(() => undefined)
-        .finally(() => this.scheduleNext());
+        .finally(() => this.scheduleNext(controller));
     }, this.options.pollingIntervalMs);
   }
 }

package/src/runtime/locations/auto-connect-planner.ts

@@ -130,14 +130,11 @@ function targetOf(peer: ZLinkPeerLocation): ZLinkAutoConnectTarget {
 }
 
 function isAutoConnectSelf(local: ZLinkAutoConnectLocal, peer: ZLinkPeerLocation): boolean {
-  if (
+  return (
     local.nodeRid !== undefined &&
     peer.nodeRid !== undefined &&
     routingIdsEqual(local.nodeRid, peer.nodeRid)
-  ) {
-    return true;
-  }
-  return peer.endpoint === local.endpoint;
+  );
 }
 
 function shouldDialAutoConnectPeer(local: ZLinkAutoConnectLocal, peer: ZLinkPeerLocation): boolean {