@zlink-systems/framework 0.26.0 → 0.28.0

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

@@ -1,24 +1,10 @@
+import { ZLinkFrameworkException, ZLinkSpotKind, type RoutingId } from '../../contracts';
 import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException,
-  internalFrameworkErrorKind,
-  internalFrameworkErrorKindFromWireReply,
-  isCanonicalWireReplyTerminal
-} from '../framework-errors-internal';
-import {
-  RequestResult,
-  SubmitResult,
-  type ZLinkBackendMessageLike as MessageLike
-} from '../backend/runtime-values';
-import { ZLinkFrameworkException, type RoutingId } from '../../contracts';
-import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
-import { ZLinkSpotKind } from '../../contracts';
-import {
-  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
   ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
   ZLinkDispatchErrorSurface,
-  ZLinkDispatchMessageKind
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { awaitWithAbort } from '../abort';
 import type { ZLinkBackendMeshNode } from '../backend/contracts';
@@ -27,16 +13,32 @@ import {
   type ZLinkMeshCompletionTable
 } from '../backend/mesh-completion-table';
 import {
+  RequestResult,
+  type ZLinkBackendMessageLike as MessageLike
+} from '../backend/runtime-values';
+import type { ZLinkDispatchErrorReporter } from '../channels';
+import {
+  ZLinkChannelMessageKind,
   decodeChannelReply,
   encodeChannelEnvelopeParts,
   encodeChannelEnvelopePartsAtDeadline,
-  type ZLinkChannelEnvelopeCodecRegistry,
-  ZLinkChannelMessageKind
+  type ZLinkChannelEnvelopeCodecRegistry
 } from '../channels/channel-envelope';
-import type { ZLinkDispatchErrorReporter } from '../channels';
 import { flowIfEnabled } from '../diagnostics';
 import { runWithOutboundFlow } from '../diagnostics/flow-context';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException,
+  internalFrameworkErrorKind,
+  internalFrameworkErrorKindFromWireReply,
+  isCanonicalWireReplyTerminal
+} from '../framework-errors-internal';
 import { resolveFrameworkPacketName } from '../messaging/packet-name';
+import {
+  ZLinkSubmitStatus,
+  classifySubmitResult,
+  type ZLinkSubmitResult
+} from '../messaging/submission-result';
 import type {
   ZLinkSpotAddressCallOptions,
   ZLinkSpotAddressTransport,
@@ -53,12 +55,6 @@ export interface ZLinkHostSpotAddressTransportOptions {
   readonly completions: (meshName: string) => ZLinkMeshCompletionTable | undefined;
   readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
   readonly defaultRequestTimeoutMs: number;
-  /** Internal one-way deadline policy; public calls do not expose this option. */
-  readonly defaultSendTimeoutMs?: number;
-  /** Resolves the send timeout for a configured Spot Mesh. */
-  readonly sendTimeoutMsForMesh?: (meshName: string) => number;
-  /** Resolves the send timeout for a resolved Spot route channel. */
-  readonly sendTimeoutMsForRouteChannel?: (routeChannelId: string) => number;
   readonly dispatchErrors?: ZLinkDispatchErrorReporter;
 }
 
@@ -84,11 +80,6 @@ type MissingTargetSelection =
   | { readonly kind: 'capacity' }
   | { readonly kind: 'unavailable' };
 
-// Only a synchronous target-admission rejection is safe to retry. A
-// completion with the same public error kind may already represent an
-// admitted application operation, so it must not enter the retry loop.
-const PRE_ADMISSION_MISSING_INSTANCE_ERRORS = new WeakSet<ZLinkFrameworkException>();
-
 /** Owns global Spot authority lookup and Missing Instance placement. */
 export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport {
   constructor(private readonly options: ZLinkHostSpotAddressTransportOptions) {}
@@ -96,7 +87,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
   sendToSpotAddress(
     spotId: RoutingId,
     message: unknown,
-    call: ZLinkSpotAddressCallOptions
+    call: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>
   ): Promise<ZLinkSubmitResult> {
     // Call-scoped flow (spec 27 §4): the envelope encoders and the
     // traceInstanceAddress points share one ambient flow that does not
@@ -110,155 +101,136 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
   private async sendToSpotAddressScoped(
     spotId: RoutingId,
     message: unknown,
-    call: ZLinkSpotAddressCallOptions
+    call: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>
   ): Promise<ZLinkSubmitResult> {
-    const timeoutMs = initialSendTimeoutMs(this.options, call);
-    const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
-    try {
-      const existing = await this.resolveExisting(spotId, deadline.signal);
-      deadline.requireRemaining();
-      if (existing !== undefined) {
-        this.validateExisting(existing, call);
-        deadline.setOwnerTimeout(this.sendTimeoutMsForRouteChannel(existing.routerChannelId));
-        try {
-          const result = await awaitWithAbort(
-            this.options.routed.sendToSpot(existing, message, {
-              timeoutMs: deadline.requireRemaining(),
-              signal: deadline.signal,
-              metadata: call.metadata
-            }),
-            deadline.signal
+    const activationDeadlineUnixMs = BigInt(
+      Math.round(Date.now() + this.options.defaultRequestTimeoutMs)
+    );
+    const existing = await this.resolveExisting(spotId);
+    if (existing !== undefined) {
+      this.validateExisting(existing, call);
+      try {
+        const result = await this.options.routed.sendToSpot(existing, message, {
+          instanceSpot: call.instanceSpot,
+          metadata: call.metadata
+        });
+        if (result.status === ZLinkSubmitStatus.Submitted) {
+          this.traceInstanceAddress(
+            ZLinkMessageFlowOutcome.Sent,
+            ZLinkDispatchMessageKind.Send,
+            spotId,
+            message,
+            existing.routerChannelId,
+            existing.stableType,
+            existing.targetNodeRid
           );
-          if (result.status === ZLinkSubmitStatus.Submitted) {
-            this.traceInstanceAddress(
-              ZLinkMessageFlowOutcome.Sent,
-              ZLinkDispatchMessageKind.Send,
-              spotId,
-              message,
-              existing.routerChannelId,
-              existing.stableType,
-              existing.targetNodeRid
-            );
-          } else {
-            this.traceInstanceAddress(
-              submitResultFlowOutcome(result.status),
-              ZLinkDispatchMessageKind.Send,
-              spotId,
-              message,
-              existing.routerChannelId,
-              existing.stableType,
-              existing.targetNodeRid,
-              submitResultReason(result.status)
-            );
-          }
-          if (
-            result.status === ZLinkSubmitStatus.TargetNotFound ||
-            result.status === ZLinkSubmitStatus.RouteNotConnected
-          ) {
-            this.options.resolver()?.invalidate?.(spotId);
-          }
-          return result;
-        } catch (error) {
-          if (isSpotRouteRefreshError(error)) {
-            this.options.resolver()?.invalidate?.(spotId);
-          }
-          const reason = addressedInstanceErrorReason(error);
+        } else {
           this.traceInstanceAddress(
-            reason === ZLinkDispatchErrorReason.Backpressure
-              ? ZLinkMessageFlowOutcome.Backpressured
-              : ZLinkMessageFlowOutcome.Dropped,
+            submitResultFlowOutcome(result.status),
             ZLinkDispatchMessageKind.Send,
             spotId,
             message,
             existing.routerChannelId,
             existing.stableType,
             existing.targetNodeRid,
-            reason
+            submitResultReason(result.status)
           );
-          throw error;
         }
-      }
-      if (!call.instanceSpot) {
-        return { status: ZLinkSubmitStatus.TargetNotFound };
-      }
-      const selected = this.selectMissingTarget(spotId, call);
-      if (selected.kind === 'unsupported') {
-        this.traceInstanceAddress(
-          ZLinkMessageFlowOutcome.Dropped,
-          ZLinkDispatchMessageKind.Send,
-          spotId,
-          message,
-          call.initialMeshName,
-          call.instanceSpotType,
-          undefined,
-          ZLinkDispatchErrorReason.StaleTarget
-        );
-        return { status: ZLinkSubmitStatus.TargetNotFound };
-      }
-      if (selected.kind === 'capacity') {
-        const error = missingInstancePlacementCapacity(spotId, call.instanceSpotType);
+        if (
+          result.status === ZLinkSubmitStatus.TargetNotFound ||
+          result.status === ZLinkSubmitStatus.RouteNotConnected
+        ) {
+          this.options.resolver()?.invalidate?.(spotId);
+        }
+        return result;
+      } catch (error) {
+        if (isSpotRouteRefreshError(error)) {
+          this.options.resolver()?.invalidate?.(spotId);
+        }
+        const reason = addressedInstanceErrorReason(error);
         this.traceInstanceAddress(
-          ZLinkMessageFlowOutcome.Backpressured,
+          reason === ZLinkDispatchErrorReason.Backpressure
+            ? ZLinkMessageFlowOutcome.Backpressured
+            : ZLinkMessageFlowOutcome.Dropped,
           ZLinkDispatchMessageKind.Send,
           spotId,
           message,
-          call.initialMeshName,
-          call.instanceSpotType,
-          undefined,
-          ZLinkDispatchErrorReason.Backpressure
+          existing.routerChannelId,
+          existing.stableType,
+          existing.targetNodeRid,
+          reason
         );
         throw error;
       }
-      if (selected.kind === 'unavailable') {
-        this.traceInstanceAddress(
-          ZLinkMessageFlowOutcome.Dropped,
-          ZLinkDispatchMessageKind.Send,
-          spotId,
-          message,
-          call.initialMeshName,
-          call.instanceSpotType,
-          undefined,
-          ZLinkDispatchErrorReason.StaleTarget
-        );
-        return { status: ZLinkSubmitStatus.RouteNotConnected };
-      }
-      deadline.setOwnerTimeout(this.sendTimeoutMsForMesh(selected.meshName));
-      const encoded = this.encode(ZLinkChannelMessageKind.Command, selected.meshName, message);
-      const sourceSpotId =
-        call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
-      const mapped = mapSubmitResult(
-        await awaitWithAbort(
-          selected.node.sendToMissingInstanceSpot(
-            selected.target,
-            encoded,
-            BigInt(deadline.deadlineUnixMs),
-            sourceSpotId,
-            call.metadata
-          ),
-          deadline.signal
-        )
+    }
+    if (!call.instanceSpot) {
+      return { status: ZLinkSubmitStatus.TargetNotFound };
+    }
+    const selected = this.selectMissingTarget(spotId, call);
+    if (selected.kind === 'unsupported') {
+      this.traceInstanceAddress(
+        ZLinkMessageFlowOutcome.Dropped,
+        ZLinkDispatchMessageKind.Send,
+        spotId,
+        message,
+        call.initialMeshName,
+        call.instanceSpotType,
+        undefined,
+        ZLinkDispatchErrorReason.StaleTarget
       );
+      return { status: ZLinkSubmitStatus.TargetNotFound };
+    }
+    if (selected.kind === 'capacity') {
+      const error = missingInstancePlacementCapacity(spotId, call.instanceSpotType);
       this.traceInstanceAddress(
-        submitResultFlowOutcome(mapped.status),
+        ZLinkMessageFlowOutcome.Backpressured,
         ZLinkDispatchMessageKind.Send,
         spotId,
         message,
-        selected.meshName,
-        selected.target.stableType,
-        selected.target.targetNodeRid,
-        mapped.status === ZLinkSubmitStatus.Submitted
-          ? undefined
-          : submitResultReason(mapped.status)
+        call.initialMeshName,
+        call.instanceSpotType,
+        undefined,
+        ZLinkDispatchErrorReason.Backpressure
       );
-      return mapped;
-    } catch (error) {
-      if (deadline.expired()) {
-        return { status: ZLinkSubmitStatus.TimedOut };
-      }
       throw error;
-    } finally {
-      deadline.close();
     }
+    if (selected.kind === 'unavailable') {
+      this.traceInstanceAddress(
+        ZLinkMessageFlowOutcome.Dropped,
+        ZLinkDispatchMessageKind.Send,
+        spotId,
+        message,
+        call.initialMeshName,
+        call.instanceSpotType,
+        undefined,
+        ZLinkDispatchErrorReason.StaleTarget
+      );
+      return { status: ZLinkSubmitStatus.RouteNotConnected };
+    }
+    const encoded = this.encode(ZLinkChannelMessageKind.Command, selected.meshName, message);
+    const sourceSpotId =
+      call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
+    const mapped = classifySubmitResult(
+      await selected.node.sendToMissingInstanceSpot(
+        selected.target,
+        encoded,
+        activationDeadlineUnixMs,
+        sourceSpotId,
+        call.metadata
+      ),
+      'Instance Spot submission'
+    );
+    this.traceInstanceAddress(
+      submitResultFlowOutcome(mapped.status),
+      ZLinkDispatchMessageKind.Send,
+      spotId,
+      message,
+      selected.meshName,
+      selected.target.stableType,
+      selected.target.targetNodeRid,
+      mapped.status === ZLinkSubmitStatus.Submitted ? undefined : submitResultReason(mapped.status)
+    );
+    return mapped;
   }
 
   requestToSpotAddress<TReply = unknown>(
@@ -280,57 +252,41 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     const timeoutMs = call.timeoutMs ?? this.options.defaultRequestTimeoutMs;
     const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
     try {
-      for (;;) {
-        const existing = await this.resolveExisting(spotId, deadline.signal);
-        deadline.requireRemaining();
-
-        if (existing !== undefined) {
-          this.validateExisting(existing, call);
-          try {
-            return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
-          } catch (error) {
-            if (isSpotRouteRefreshError(error)) {
-              this.options.resolver()?.invalidate?.(spotId);
-            }
-            const recovery = await this.recoverStaleInstanceRoute(
-              spotId,
-              call,
-              deadline,
-              error,
-              existing
-            );
-            if (recovery.kind === 'route') {
-              // Retry only after the resolver exposes a different route. The
-              // stale target cannot have admitted the application operation.
-              continue;
-            }
-            if (recovery.kind !== 'cold') {
-              this.reportInstanceRequestError(
-                spotId,
-                request,
-                error,
-                existing.routerChannelId,
-                existing.targetNodeRid,
-                existing.stableType,
-                addressedInstanceErrorReason(error)
-              );
-              throw error;
-            }
-            // The logical authority is no longer Ready, so the Instance
-            // intent path below may submit the original operation once.
-          }
+      const existing = await this.resolveExisting(spotId, deadline.signal);
+      deadline.requireRemaining();
+      if (existing === undefined) {
+        return await this.requestToMissingInstance(spotId, request, call, deadline);
+      }
+      this.validateExisting(existing, call);
+      try {
+        return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
+      } catch (error) {
+        if (isSpotRouteRefreshError(error)) {
+          this.options.resolver()?.invalidate?.(spotId);
         }
-
-        try {
+        // 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.
+        if (
+          call.instanceSpot &&
+          isOwnerFenceRefusal(error) &&
+          (await this.resolveExisting(spotId, deadline.signal)) === undefined
+        ) {
+          deadline.requireRemaining();
           return await this.requestToMissingInstance(spotId, request, call, deadline);
-        } catch (error) {
-          if (!isMissingInstanceRetryError(error)) throw error;
-          // A placement node can finish cleanup before its stale native result
-          // reaches this process. Refresh authority and select again under the
-          // same end-to-end deadline; the old envelope was not admitted.
-          this.options.resolver()?.invalidate?.(spotId);
-          await waitForSpotRouteRefresh(Math.min(10, deadline.requireRemaining()), deadline.signal);
         }
+        this.reportInstanceRequestError(
+          spotId,
+          request,
+          error,
+          existing.routerChannelId,
+          existing.targetNodeRid,
+          existing.stableType,
+          addressedInstanceErrorReason(error)
+        );
+        throw error;
       }
     } catch (error) {
       if (
@@ -372,6 +328,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     );
     const reply = await awaitWithAbort(
       this.options.routed.requestToSpot<TReply>(existing, request, {
+        instanceSpot: call.instanceSpot,
         timeoutMs: deadline.requireRemaining(),
         signal: deadline.signal,
         metadata: call.metadata
@@ -446,28 +403,17 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     const table = this.options.completions(selected.meshName);
     if (table === undefined)
       throw new Error(`MeshNode '${selected.meshName}' completion table is not started.`);
-    let completionPromise: ReturnType<ZLinkMeshCompletionTable['submit']>;
-    try {
-      completionPromise = table.submit(
-        () =>
-          selected.node.requestToMissingInstanceSpot(
-            selected.target,
-            encoded,
-            deadlineUnixMs,
-            call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId),
-            call.metadata
-          ),
-        deadline.signal
-      );
-    } catch (error) {
-      if (
-        error instanceof ZLinkFrameworkException &&
-        internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
-      ) {
-        PRE_ADMISSION_MISSING_INSTANCE_ERRORS.add(error);
-      }
-      throw error;
-    }
+    const completionPromise = table.submit(
+      () =>
+        selected.node.requestToMissingInstanceSpot(
+          selected.target,
+          encoded,
+          deadlineUnixMs,
+          call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId),
+          call.metadata
+        ),
+      deadline.signal
+    );
     this.traceInstanceAddress(
       ZLinkMessageFlowOutcome.Sent,
       ZLinkDispatchMessageKind.Request,
@@ -580,35 +526,6 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     }
   }
 
-  private async recoverStaleInstanceRoute(
-    spotId: RoutingId,
-    call: ZLinkSpotAddressCallOptions,
-    deadline: ZLinkSpotAddressDeadline,
-    error: unknown,
-    staleRoute: ZLinkSpotRouteTarget
-  ): Promise<
-    | { readonly kind: 'route'; readonly route: ZLinkSpotRouteTarget }
-    | { readonly kind: 'cold' }
-    | { readonly kind: 'fail' }
-  > {
-    if (
-      !call.instanceSpot ||
-      !(error instanceof ZLinkFrameworkException) ||
-      !isInstanceRouteStaleError(error)
-    ) {
-      return { kind: 'fail' };
-    }
-    for (;;) {
-      deadline.requireRemaining();
-      const current = await this.resolveExisting(spotId, deadline.signal);
-      if (current === undefined) return { kind: 'cold' };
-      if (!sameSpotRouteSnapshot(current, staleRoute)) {
-        return { kind: 'route', route: current };
-      }
-      await waitForSpotRouteRefresh(Math.min(10, deadline.requireRemaining()), deadline.signal);
-    }
-  }
-
   private selectMissingTarget(
     spotId: RoutingId,
     call: ZLinkSpotAddressCallOptions
@@ -698,22 +615,6 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     return { kind: 'unavailable' };
   }
 
-  private sendTimeoutMsForMesh(meshName: string): number {
-    return (
-      this.options.sendTimeoutMsForMesh?.(meshName) ??
-      this.options.defaultSendTimeoutMs ??
-      this.options.defaultRequestTimeoutMs
-    );
-  }
-
-  private sendTimeoutMsForRouteChannel(routeChannelId: string): number {
-    return (
-      this.options.sendTimeoutMsForRouteChannel?.(routeChannelId) ??
-      this.options.defaultSendTimeoutMs ??
-      this.options.defaultRequestTimeoutMs
-    );
-  }
-
   private validateExisting(
     target: import('../spots/spot-routing-internal').ZLinkSpotRouteTarget,
     call: ZLinkSpotAddressCallOptions
@@ -771,25 +672,6 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
   }
 }
 
-function isInstanceRouteStaleError(error: unknown): error is ZLinkFrameworkException {
-  if (!(error instanceof ZLinkFrameworkException)) return false;
-  const kind = internalFrameworkErrorKind(error);
-  // RequestTargetNotFound from an existing route is a pre-admission route
-  // lookup failure. A stale owner result is terminal for this application
-  // operation: the routed request may already have crossed the transport
-  // boundary, so refreshing the route and resubmitting it could execute the
-  // same operation twice. Instance cold activation is selected only when the
-  // authority resolver itself reports that the Ready route is absent.
-  if (kind === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound) return true;
-  return false;
-}
-
-function isMissingInstanceRetryError(error: unknown): error is ZLinkFrameworkException {
-  return (
-    error instanceof ZLinkFrameworkException && PRE_ADMISSION_MISSING_INSTANCE_ERRORS.has(error)
-  );
-}
-
 function missingInstanceRequestFailure(
   result: number,
   nativeErrno: number
@@ -819,27 +701,6 @@ function missingInstanceRequestFailure(
   );
 }
 
-function mapSubmitResult(result: number): ZLinkSubmitResult {
-  switch (result) {
-    case SubmitResult.Ok:
-      return { status: ZLinkSubmitStatus.Submitted };
-    case SubmitResult.Backpressured:
-    case SubmitResult.NotAdmitted:
-      return { status: ZLinkSubmitStatus.Backpressured };
-    case SubmitResult.NotFound:
-      return { status: ZLinkSubmitStatus.TargetNotFound };
-    case SubmitResult.NotConnected:
-      return { status: ZLinkSubmitStatus.RouteNotConnected };
-    case SubmitResult.Terminated:
-      return { status: ZLinkSubmitStatus.Shutdown };
-    default:
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.RequestFailed,
-        `Instance Spot submission failed with result ${result}.`
-      );
-  }
-}
-
 function missingInstancePlacementCapacity(
   spotId: RoutingId,
   stableType: string | undefined
@@ -877,39 +738,13 @@ function isSpotRouteRefreshError(error: unknown): error is ZLinkFrameworkExcepti
   );
 }
 
-function sameSpotRouteSnapshot(left: ZLinkSpotRouteTarget, right: ZLinkSpotRouteTarget): boolean {
+function isOwnerFenceRefusal(error: unknown): boolean {
   return (
-    String(left.targetNodeRid) === String(right.targetNodeRid) &&
-    String(left.spotId) === String(right.spotId) &&
-    left.routerChannelId === right.routerChannelId &&
-    left.spotKind === right.spotKind &&
-    left.stableType === right.stableType &&
-    left.targetSpotGeneration === right.targetSpotGeneration &&
-    left.targetNodeGeneration === right.targetNodeGeneration &&
-    left.authorityOwnerGeneration === right.authorityOwnerGeneration &&
-    left.targetOwnerId === right.targetOwnerId &&
-    left.ownerLeaseGeneration === right.ownerLeaseGeneration &&
-    left.authorityStoreVersion === right.authorityStoreVersion
+    error instanceof ZLinkFrameworkException &&
+    internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotMoving
   );
 }
 
-function waitForSpotRouteRefresh(delayMs: number, signal: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const finish = () => {
-      signal.removeEventListener('abort', abort);
-      resolve();
-    };
-    const abort = () => {
-      clearTimeout(timer);
-      signal.removeEventListener('abort', abort);
-      reject(signal.reason);
-    };
-    const timer = setTimeout(finish, delayMs);
-    signal.addEventListener('abort', abort, { once: true });
-    if (signal.aborted) abort();
-  });
-}
-
 function submitResultReason(status: ZLinkSubmitStatus): ZLinkDispatchErrorReason {
   switch (status) {
     case ZLinkSubmitStatus.Backpressured:
@@ -967,21 +802,9 @@ function addressedInstanceErrorReason(error: unknown): ZLinkDispatchErrorReason
   return ZLinkDispatchErrorReason.HandlerException;
 }
 
-function initialSendTimeoutMs(
-  options: ZLinkHostSpotAddressTransportOptions,
-  call: ZLinkSpotAddressCallOptions
-): number {
-  return call.initialMeshName === undefined
-    ? (options.defaultSendTimeoutMs ?? options.defaultRequestTimeoutMs)
-    : (options.sendTimeoutMsForMesh?.(call.initialMeshName) ??
-        options.defaultSendTimeoutMs ??
-        options.defaultRequestTimeoutMs);
-}
-
 interface ZLinkSpotAddressDeadline {
   readonly deadlineUnixMs: number;
   readonly signal: AbortSignal;
-  setOwnerTimeout(timeoutMs: number): void;
   requireRemaining(): number;
   expired(): boolean;
   close(): void;
@@ -993,7 +816,7 @@ function createSpotAddressDeadline(
 ): ZLinkSpotAddressDeadline {
   const startedAtMs = performance.now();
   const startedAtUnixMs = Date.now();
-  let deadlineMs = startedAtMs + Math.max(0, timeoutMs);
+  const deadlineMs = startedAtMs + Math.max(0, timeoutMs);
   const controller = new AbortController();
   let expired = false;
   let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -1019,10 +842,6 @@ function createSpotAddressDeadline(
       return Math.round(startedAtUnixMs + (deadlineMs - startedAtMs));
     },
     signal: controller.signal,
-    setOwnerTimeout(ownerTimeoutMs: number) {
-      deadlineMs = startedAtMs + Math.max(0, ownerTimeoutMs);
-      arm();
-    },
     requireRemaining() {
       const remainingMs = deadlineMs - performance.now();
       if (remainingMs <= 0) {