@zlink-systems/framework 0.25.0 → 0.27.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,
@@ -84,11 +86,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) {}
@@ -123,6 +120,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
         try {
           const result = await awaitWithAbort(
             this.options.routed.sendToSpot(existing, message, {
+              instanceSpot: call.instanceSpot,
               timeoutMs: deadline.requireRemaining(),
               signal: deadline.signal,
               metadata: call.metadata
@@ -226,7 +224,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
       const encoded = this.encode(ZLinkChannelMessageKind.Command, selected.meshName, message);
       const sourceSpotId =
         call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId);
-      const mapped = mapSubmitResult(
+      const mapped = classifySubmitResult(
         await awaitWithAbort(
           selected.node.sendToMissingInstanceSpot(
             selected.target,
@@ -236,7 +234,8 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
             call.metadata
           ),
           deadline.signal
-        )
+        ),
+        'Instance Spot submission'
       );
       this.traceInstanceAddress(
         submitResultFlowOutcome(mapped.status),
@@ -280,57 +279,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 +355,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 +430,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 +553,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
@@ -771,25 +715,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 +744,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 +781,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:

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

@@ -51,7 +51,8 @@ export interface ZLinkSpotNodeRuntimeOptionsFactoryOptions {
 export class ZLinkSpotNodeRuntimeOptionsFactory {
   constructor(private readonly options: ZLinkSpotNodeRuntimeOptionsFactoryOptions) {}
 
-  create(): ZLinkSpotNodeRuntimeManagerOptions {
+  create(): Omit<ZLinkSpotNodeRuntimeManagerOptions, 'errorSink'> {
+    const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
     return {
       registration: this.options.registration,
       primaryMeshName: this.options.meshRouters.primaryMeshName(),
@@ -59,7 +60,9 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
       context: this.options.context,
       channelClient: new DefaultZLinkChannelClient(
         this.options.registration,
-        this.options.channelTransport
+        this.options.channelTransport,
+        this.options.routeTransport,
+        spotRouterChannelIdForMesh
       ),
       fanoutClient: new DefaultZLinkFanoutClient(
         this.options.registration,
@@ -70,7 +73,7 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
         this.options.spotPublisherTransport
       ),
       routedTransport: this.options.routeTransport,
-      spotRouterChannelIdForMesh: this.options.meshRouters.spotRouterChannelIdByMesh(),
+      spotRouterChannelIdForMesh,
       providerResolver: this.options.providerResolver,
       dispatchErrors: this.options.dispatchErrors,
       runtimeEventPublisher: this.options.runtimeEventPublisher,

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

@@ -49,12 +49,26 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
   ) => Promise<void>;
   readonly beginInstanceIdleClosingAuthority: (
     meshName: string,
-    spotId: string
-  ) => Promise<{ restoreReady(): Promise<void> } | undefined>;
+    spotId: string,
+    onCommitted: () => void
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly beginInstanceClosingAuthority: (
     meshName: string,
-    spotId: string
-  ) => Promise<{ restoreReady(): Promise<void> } | undefined>;
+    spotId: string,
+    onCommitted: () => void
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
+  readonly beginUserClosingAuthority: (
+    meshName: string,
+    spotId: string,
+    objectGeneration: bigint,
+    onCommitted: () => void
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly createLocationSpotRouteResolver: () => ZLinkSpotRouteResolver | undefined;
   readonly boundSessionRelay: ZLinkBoundSessionRelay;
   readonly actorHandoff: ZLinkActorHandoffCoordinator;
@@ -63,13 +77,14 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
   readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
   readonly metrics: import('../diagnostics').ZLinkRuntimeMetrics;
   readonly admission: ZLinkRuntimeAdmissionGate;
-  readonly statefulExecutionAllowed: () => boolean;
+  readonly statefulExecution: NonNullable<ZLinkSpotManagerOptions['statefulExecution']>;
 }
 
 export class ZLinkSpotRuntimeOptionsFactory {
   constructor(private readonly options: ZLinkSpotRuntimeOptionsFactoryOptions) {}
 
   create(actorTransferRuntime: ZLinkActorTransferRuntime): Partial<ZLinkSpotManagerOptions> {
+    const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
     return {
       nodeRid: undefined,
       nodeRidProvider: (meshName) => this.meshNodeRoutingId(meshName),
@@ -120,9 +135,20 @@ export class ZLinkSpotRuntimeOptionsFactory {
         }
         await runtime.dispatchEntryActorJoin(meshName, actor, handoffBacklog);
       },
+      executeEntryActor: (meshName, actorId, operation) => {
+        const runtime = this.options.spotNodeRuntime();
+        if (runtime === undefined) {
+          throw new ZLinkConfigurationException(
+            'Entry Spot Actor completion requires the MeshNode runtime.'
+          );
+        }
+        return runtime.executeEntryActor(meshName, actorId, operation);
+      },
       channelClient: new DefaultZLinkChannelClient(
         this.options.registration,
-        this.options.channelTransport
+        this.options.channelTransport,
+        this.options.routeTransport,
+        spotRouterChannelIdForMesh
       ),
       fanoutClient: new DefaultZLinkFanoutClient(
         this.options.registration,
@@ -134,25 +160,70 @@ export class ZLinkSpotRuntimeOptionsFactory {
       ),
       routedTransport: this.options.routeTransport,
       addressTransport: this.options.addressTransport,
-      spotRouterChannelIdForMesh: this.options.meshRouters.spotRouterChannelIdByMesh(),
-      channelMeshNameForChannel: (channelName) => {
-        const matches = [...this.options.registration.spotNodes.entries()]
-          .filter(([, node]) =>
-            Object.prototype.hasOwnProperty.call(node.meshChannels ?? {}, channelName)
-          )
-          .map(([meshName]) => meshName);
-        return matches.length === 1 ? matches[0] : undefined;
-      },
+      spotRouterChannelIdForMesh,
       messageSerializers: this.options.registration.messageSerializers,
       runtimeEventPublisher: this.options.runtimeEventPublisher,
       detachedTaskRunner: this.options.detachedTaskRunner,
       locationLifecycle: this.options.locationLifecycle(),
       releaseInstanceAuthority: (meshName, spotId, objectGeneration) =>
         this.options.releaseInstanceAuthority(meshName, String(spotId), objectGeneration),
-      beginInstanceIdleClosingAuthority: (meshName, spotId) =>
-        this.options.beginInstanceIdleClosingAuthority(meshName, String(spotId)),
-      beginInstanceClosingAuthority: (meshName, spotId) =>
-        this.options.beginInstanceClosingAuthority(meshName, String(spotId)),
+      beginInstanceIdleClosingAuthority: (meshName, spotId, onCommitted) =>
+        this.options.beginInstanceIdleClosingAuthority(meshName, String(spotId), onCommitted),
+      beginInstanceClosingAuthority: async (meshName, spotId, onCommitted, objectGeneration) => {
+        const authority = await this.options.beginInstanceClosingAuthority(
+          meshName,
+          String(spotId),
+          onCommitted
+        );
+        if (authority === undefined) return undefined;
+        // A Close without Reincarnate ends this incarnation. The Instance authority
+        // release also forgets the node's Ready projection, so a request on a cached
+        // Ready route is refused instead of rematerializing the closed generation.
+        const release = () =>
+          this.options.releaseInstanceAuthority(meshName, String(spotId), objectGeneration);
+        if (authority.reincarnate === undefined) return { release };
+        return {
+          release,
+          reincarnate: async (initialize) => {
+            const current = await authority.reincarnate!(initialize);
+            const node = this.options.spotNodeRuntime()?.meshNode(meshName);
+            const route = {
+              targetSpotId: String(spotId),
+              targetNodeRid: String(current.allocation.descriptor.rid),
+              targetNodeGeneration: current.allocation.descriptorLifecycleGeneration,
+              objectGeneration: current.objectGeneration,
+              authorityOwnerGeneration: current.authorityOwnerGeneration,
+              ownerId: current.ownerId,
+              leaseGeneration: current.ownerLeaseGeneration,
+              storeVersion: current.storeVersion.value
+            };
+            node?.restoreSpotAuthority?.(
+              String(spotId),
+              'instance_spot',
+              current.stableType,
+              current.objectGeneration,
+              current.authorityOwnerGeneration
+            );
+            node?.registerInstanceIntent?.(current.stableType, route);
+            node?.rememberSpotRoute?.({
+              spot: { spotId: String(spotId), generation: current.objectGeneration },
+              targetNodeRid: route.targetNodeRid,
+              targetNodeGeneration: route.targetNodeGeneration,
+              authorityOwnerGeneration: route.authorityOwnerGeneration,
+              ownerLeaseGeneration: route.leaseGeneration,
+              storeVersion: route.storeVersion
+            });
+            return current;
+          }
+        };
+      },
+      beginUserClosingAuthority: (meshName, spotId, objectGeneration, onCommitted) =>
+        this.options.beginUserClosingAuthority(
+          meshName,
+          String(spotId),
+          objectGeneration,
+          onCommitted
+        ),
       instanceSpotApplicationTargetProvider: (meshName, spotId) =>
         this.options
           .spotNodeRuntime()
@@ -196,11 +267,6 @@ export class ZLinkSpotRuntimeOptionsFactory {
           }
         } as never;
       },
-      createReceived: () => {
-        const runtime = this.options.spotNodeRuntime();
-        if (runtime === undefined) throw new Error('Spot backend runtime is not initialized.');
-        return runtime.createReceived();
-      },
       createTopicMessage: () => {
         const runtime = this.options.spotNodeRuntime();
         if (runtime === undefined) throw new Error('Spot backend runtime is not initialized.');
@@ -264,17 +330,13 @@ export class ZLinkSpotRuntimeOptionsFactory {
           ZLinkSpotRelocationCoordinationMode.FrameworkManaged
         );
       },
-      actorBindingGenerationObserver: (actorId, generation) =>
-        this.options
-          .actorManager()
-          ?.getState(actorId)
-          ?.setBoundSessionBindingGeneration(generation),
       actorTransferRuntime,
       boundSessionRuntime: this.options.boundSessionRelay.boundSessions,
       actorHandoffRuntime: this.options.actorHandoff,
       metrics: this.options.metrics,
       admission: this.options.admission,
-      statefulExecutionAllowed: this.options.statefulExecutionAllowed,
+      statefulExecution: this.options.statefulExecution,
+      closeErrorSink: this.options.runtimeOrPreStartErrorSink,
       dispatchErrors: this.options.dispatchErrorReporter(this.options.runtimeOrPreStartErrorSink)
     };
   }

package/src/runtime/host/stateful-authority-route-runtime.ts

@@ -19,6 +19,7 @@ import type {
 } from '../foundation/service-stateful-wire-codec';
 import { routingIdsEqual } from '../routing-id';
 import {
+  decodeServiceClosingSpotAuthority,
   decodeServiceInstanceAuthorityPayload,
   decodeServiceReadySpotAuthority,
   type ServiceActivationRecoveryState
@@ -74,6 +75,7 @@ interface StatefulAuthorityRouteSink {
 
 interface AppliedAuthorityRoute {
   readonly kind: 'user_spot' | 'instance_spot';
+  readonly closing: boolean;
   readonly stableType: string;
   readonly meshName: string;
   readonly spotRoute: ServiceDirectSpotRouteFence;
@@ -189,7 +191,7 @@ export class ZLinkStatefulAuthorityRouteRuntime {
         const expectedInstanceRoute =
           previousRoute?.kind === 'instance_spot' ? previousRoute.instanceRoute : null;
         sink.rememberSpotRoute(route.spotRoute, expectedSpotRoute);
-        if (route.kind === 'instance_spot') {
+        if (route.kind === 'instance_spot' && !route.closing) {
           const status = sink.status();
           if (
             routingIdsEqual(status.routingId, route.instanceRoute.targetNodeRid) &&
@@ -555,9 +557,9 @@ function pendingInstanceActivation(
 
 function authorityRoute(snapshot: ZLinkAuthoritySnapshot): AppliedAuthorityRoute | undefined {
   const allocation = snapshot.allocation;
-  const decoded = decodeServiceReadySpotAuthority(
-    serviceRelocationAuthorityApplicationPayload(snapshot.payload)
-  );
+  const payload = serviceRelocationAuthorityApplicationPayload(snapshot.payload);
+  const ready = decodeServiceReadySpotAuthority(payload);
+  const decoded = ready ?? decodeServiceClosingSpotAuthority(payload);
   if (
     allocation.state !== 'active' ||
     allocation.objectKind === 'actor' ||
@@ -585,6 +587,7 @@ function authorityRoute(snapshot: ZLinkAuthoritySnapshot): AppliedAuthorityRoute
   };
   return {
     kind: allocation.objectKind,
+    closing: ready === undefined,
     stableType: allocation.stableType,
     meshName: allocation.descriptor.meshName,
     spotRoute,
@@ -617,6 +620,7 @@ function sameAppliedRoute(
   if (right === undefined) return false;
   return (
     left.kind === right.kind &&
+    left.closing === right.closing &&
     left.stableType === right.stableType &&
     left.meshName === right.meshName &&
     left.instanceRoute.targetNodeRid === right.instanceRoute.targetNodeRid &&