@zlink-systems/framework 0.24.0 → 0.26.0

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

@@ -49,12 +49,20 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
   ) => Promise<void>;
   readonly beginInstanceIdleClosingAuthority: (
     meshName: string,
-    spotId: string
-  ) => Promise<{ restoreReady(): Promise<void> } | undefined>;
+    spotId: string,
+    onCommitted: () => void
+  ) => Promise<{ release(): Promise<void> } | undefined>;
   readonly beginInstanceClosingAuthority: (
     meshName: string,
-    spotId: string
-  ) => Promise<{ restoreReady(): Promise<void> } | undefined>;
+    spotId: string,
+    onCommitted: () => void
+  ) => Promise<{ release(): Promise<void> } | undefined>;
+  readonly beginUserClosingAuthority: (
+    meshName: string,
+    spotId: string,
+    objectGeneration: bigint,
+    onCommitted: () => void
+  ) => Promise<{ release(): Promise<void> } | undefined>;
   readonly createLocationSpotRouteResolver: () => ZLinkSpotRouteResolver | undefined;
   readonly boundSessionRelay: ZLinkBoundSessionRelay;
   readonly actorHandoff: ZLinkActorHandoffCoordinator;
@@ -149,10 +157,17 @@ export class ZLinkSpotRuntimeOptionsFactory {
       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: (meshName, spotId, onCommitted) =>
+        this.options.beginInstanceClosingAuthority(meshName, String(spotId), onCommitted),
+      beginUserClosingAuthority: (meshName, spotId, objectGeneration, onCommitted) =>
+        this.options.beginUserClosingAuthority(
+          meshName,
+          String(spotId),
+          objectGeneration,
+          onCommitted
+        ),
       instanceSpotApplicationTargetProvider: (meshName, spotId) =>
         this.options
           .spotNodeRuntime()
@@ -196,11 +211,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.');
@@ -275,6 +285,7 @@ export class ZLinkSpotRuntimeOptionsFactory {
       metrics: this.options.metrics,
       admission: this.options.admission,
       statefulExecutionAllowed: this.options.statefulExecutionAllowed,
+      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 &&

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

@@ -17,6 +17,7 @@ import type {
 import { ZLinkFrameworkException, ZLinkSpotCreateState } from '../../contracts';
 import {
   decodeServiceReadySpotAuthority,
+  decodeServiceClosingSpotAuthority,
   encodeServiceUserSpotAuthorityPayload
 } from '../foundation/service-authority-payload-codec';
 import { encodeAuthorityKey } from '../locations/authority-key-codec';
@@ -332,55 +333,34 @@ export class ZLinkUserSpotCreationCoordinator {
 
   async close(
     spot: SpotRef,
-    closeOwner: (current: SpotRef, snapshot: ZLinkAuthoritySnapshot) => Promise<boolean>,
-    signal?: AbortSignal,
-    ownerPresent?: (current: SpotRef) => boolean,
-    ownerCanClose?: (current: SpotRef) => boolean
+    closeOwner: (
+      current: SpotRef,
+      beginAuthority: (onCommitted: () => void) => Promise<{ release(): Promise<void> }>
+    ) => Promise<boolean>,
+    signal?: AbortSignal
   ): Promise<boolean> {
     const resolved = await this.resolveCloseTarget(spot, signal);
     if (resolved === undefined) return false;
     const { spot: currentRef, snapshot: current } = resolved;
     const key = encodeAuthorityKey('user_spot', String(spot.spotId));
-    if (ownerPresent?.(currentRef) === false) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotMoving,
-        `User Spot '${String(spot.spotId)}' is missing from its authority owner.`,
-        true
-      );
-    }
-    if (ownerCanClose?.(currentRef) === false) return false;
-    const closing = await this.beginClosing(key, current, String(spot.spotId), signal);
-    let closed: boolean;
-    try {
-      closed = await closeOwner(currentRef, closing);
-    } catch (error) {
-      await this.restoreReady(key, closing, String(spot.spotId), signal);
-      throw error;
-    }
-    if (!closed) {
-      await this.restoreReady(key, closing, String(spot.spotId), signal);
-      return false;
-    }
-    const deleted = await this.options.store.compareExchangeAuthority(
-      key,
-      closing.storeVersion,
-      { kind: 'delete' },
-      signal
+    return await closeOwner(currentRef, async (onCommitted) =>
+      this.commitCloseAuthority(key, current, String(spot.spotId), onCommitted)
     );
-    if (deleted.kind === 'deleted') {
-      this.forgetReadyRoute(currentRef.spotId, current);
-      return true;
-    }
-    if (deleted.kind === 'conflict') {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotMoving,
-        `User Spot '${String(spot.spotId)}' authority changed while closing.`,
-        true
-      );
-    }
-    throw createInternalFrameworkException(
-      ZLinkFrameworkInternalErrorKind.SpotGenerationStale,
-      `User Spot '${String(spot.spotId)}' generation cannot be closed.`
+  }
+
+  /** Commits Closing for the owner's own incarnation when its context requests Close. */
+  async beginOwnerClose(
+    spot: SpotRef,
+    onCommitted: () => void
+  ): Promise<{ release(): Promise<void> } | undefined> {
+    const resolved = await this.resolveCloseTarget(spot);
+    if (resolved === undefined) return undefined;
+    const spotId = String(spot.spotId);
+    return await this.commitCloseAuthority(
+      encodeAuthorityKey('user_spot', spotId),
+      resolved.snapshot,
+      spotId,
+      onCommitted
     );
   }
 
@@ -391,29 +371,14 @@ export class ZLinkUserSpotCreationCoordinator {
     const key = encodeAuthorityKey('user_spot', String(spot.spotId));
     const current = await this.options.store.readAuthority(key, signal);
     if (current.kind === 'missing') return undefined;
-    if (current.objectGeneration !== spot.objectGeneration) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotGenerationStale,
-        `User Spot '${String(spot.spotId)}' generation is stale.`
-      );
-    }
-    const currentRef = spotRef(current, {
-      meshName: current.allocation.descriptor.meshName,
-      spotId: spot.spotId,
-      stableType: current.allocation.stableType,
-      requestPayload: Buffer.alloc(0),
-      timeoutMs: 1
-    });
-    if (
-      String(current.allocation.descriptor.rid) !== String(spot.nodeRid) ||
-      current.allocation.descriptor.meshName !== spot.meshName
-    ) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotGenerationStale,
-        `User Spot '${String(spot.spotId)}' owner route is stale.`
-      );
-    }
-    return { spot: currentRef, snapshot: current };
+    return {
+      spot: requireCloseTarget(current, String(spot.spotId), {
+        objectGeneration: spot.objectGeneration,
+        nodeRid: String(spot.nodeRid),
+        meshName: spot.meshName
+      }),
+      snapshot: current
+    };
   }
 
   async handleRemoteCreate(
@@ -672,65 +637,71 @@ export class ZLinkUserSpotCreationCoordinator {
 
   async handleRemoteClose(
     record: ServiceUserSpotCloseRecord,
-    closeOwner: (spot: SpotRef, signal?: AbortSignal) => Promise<boolean>,
-    signal?: AbortSignal
+    closeOwner: (
+      spot: SpotRef,
+      beginAuthority: (onCommitted: () => void) => Promise<{ release(): Promise<void> }>,
+      signal?: AbortSignal
+    ) => Promise<boolean>,
+    signal?: AbortSignal,
+    canResume?: (spot: SpotRef) => boolean
   ): Promise<boolean> {
     const key = encodeAuthorityKey('user_spot', record.target.spotId);
     const current = await this.options.store.readAuthority(key, signal);
     if (current.kind === 'missing') return false;
-    if (current.objectGeneration !== record.target.objectGeneration) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotGenerationStale,
-        `User Spot '${record.target.spotId}' generation is stale.`
-      );
-    }
-    if (
-      current.authorityOwnerGeneration !== record.target.authorityOwnerGeneration ||
-      current.storeVersion.value !== record.target.expectedStoreVersion ||
-      String(current.allocation.descriptor.rid) !== record.target.targetNodeRid ||
-      current.allocation.descriptorLifecycleGeneration !== record.target.targetNodeGeneration ||
-      current.allocation.objectKind !== 'user_spot' ||
-      current.allocation.state !== 'active'
-    ) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotMoving,
-        `User Spot '${record.target.spotId}' close authority is moving.`,
-        true
-      );
-    }
-    const spot: SpotRef = {
+    const candidate: SpotRef = {
       spotId: record.target.spotId as RoutingId,
       objectGeneration: current.objectGeneration,
       meshName: current.allocation.descriptor.meshName,
       nodeRid: current.allocation.descriptor.rid
     };
-    const closing = await this.beginClosing(key, current, record.target.spotId, signal);
-    let closed: boolean;
-    try {
-      closed = await closeOwner(spot, signal);
-    } catch (error) {
-      await this.restoreReady(key, closing, record.target.spotId, signal);
-      throw error;
-    }
-    if (!closed) {
-      await this.restoreReady(key, closing, record.target.spotId, signal);
-      return false;
-    }
-    const deleted = await this.options.store.compareExchangeAuthority(
-      key,
-      closing.storeVersion,
-      { kind: 'delete' },
+    // A Closing committed by this owner is resumed, so its store version has
+    // advanced past the one the source observed.
+    const resuming =
+      canResume?.(candidate) === true &&
+      decodeServiceClosingSpotAuthority(current.payload)?.kind === 'user_spot';
+    const spot = requireCloseTarget(current, record.target.spotId, {
+      objectGeneration: record.target.objectGeneration,
+      nodeRid: record.target.targetNodeRid,
+      nodeGeneration: record.target.targetNodeGeneration,
+      authorityOwnerGeneration: record.target.authorityOwnerGeneration,
+      storeVersion: resuming ? undefined : record.target.expectedStoreVersion
+    });
+    return await closeOwner(
+      spot,
+      async (onCommitted) =>
+        this.commitCloseAuthority(key, current, record.target.spotId, onCommitted),
       signal
     );
-    if (deleted.kind === 'deleted') {
-      this.forgetReadyRoute(record.target.spotId as RoutingId, current);
-      return true;
-    }
-    throw createInternalFrameworkException(
-      ZLinkFrameworkInternalErrorKind.SpotMoving,
-      `User Spot '${record.target.spotId}' authority changed while closing.`,
-      true
-    );
+  }
+
+  private async commitCloseAuthority(
+    key: ReturnType<typeof encodeAuthorityKey>,
+    current: ZLinkAuthoritySnapshot,
+    spotId: string,
+    onCommitted: () => void
+  ): Promise<{ release(): Promise<void> }> {
+    const closing = await this.beginClosing(key, current, spotId);
+    const authority = {
+      release: async () => {
+        this.forgetReadyRoute(spotId as RoutingId, current);
+        const deleted = await this.options.store.compareExchangeAuthority(
+          key,
+          closing.storeVersion,
+          {
+            kind: 'delete'
+          }
+        );
+        if (deleted.kind !== 'deleted') {
+          throw createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.SpotMoving,
+            `User Spot '${spotId}' authority changed while closing.`,
+            true
+          );
+        }
+      }
+    };
+    onCommitted();
+    return authority;
   }
 
   forgetReadyRoute(spotId: RoutingId, snapshot: ZLinkAuthoritySnapshot): void {
@@ -743,8 +714,7 @@ export class ZLinkUserSpotCreationCoordinator {
   private async beginClosing(
     key: ReturnType<typeof encodeAuthorityKey>,
     current: ZLinkAuthoritySnapshot,
-    spotId: string,
-    signal?: AbortSignal
+    spotId: string
   ): Promise<ZLinkAuthoritySnapshot> {
     const ready = decodeServiceReadySpotAuthority(current.payload);
     if (
@@ -766,7 +736,7 @@ export class ZLinkUserSpotCreationCoordinator {
         payload: userSpotAuthorityPayload(current, spotId, 'closing'),
         generationTransition: 'preserve'
       },
-      signal
+      undefined
     );
     if (closing.kind === 'stored') {
       const { kind: _kind, ...snapshot } = closing;
@@ -779,31 +749,6 @@ export class ZLinkUserSpotCreationCoordinator {
     );
   }
 
-  private async restoreReady(
-    key: ReturnType<typeof encodeAuthorityKey>,
-    closing: ZLinkAuthoritySnapshot,
-    spotId: string,
-    signal?: AbortSignal
-  ): Promise<void> {
-    const restored = await this.options.store.compareExchangeAuthority(
-      key,
-      closing.storeVersion,
-      {
-        kind: 'put',
-        payload: userSpotAuthorityPayload(closing, spotId, 'ready'),
-        generationTransition: 'preserve'
-      },
-      signal
-    );
-    if (restored.kind !== 'stored') {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.SpotMoving,
-        'User Spot Ready authority could not be restored after close was declined.',
-        true
-      );
-    }
-  }
-
   private async awaitReady(
     request: ZLinkUserSpotCreationRequest,
     signal: AbortSignal
@@ -926,6 +871,66 @@ function readySpotRoute(
   };
 }
 
+/** The Close fence a caller observed; omitted parts are not part of that caller's fence. */
+interface ZLinkUserSpotCloseFence {
+  readonly objectGeneration: bigint;
+  readonly nodeRid: string;
+  readonly meshName?: string;
+  readonly nodeGeneration?: bigint;
+  readonly authorityOwnerGeneration?: bigint;
+  readonly storeVersion?: string;
+}
+
+/**
+ * The single classifier of a Close target (§7, §9): another ObjectGeneration is
+ * SpotGenerationStale; any owner fence difference or an authority that is not
+ * in a Framework-owned Ready or Closing state is SpotMoving.
+ */
+function requireCloseTarget(
+  current: ZLinkAuthoritySnapshot,
+  spotId: string,
+  fence: ZLinkUserSpotCloseFence
+): SpotRef {
+  if (current.objectGeneration !== fence.objectGeneration) {
+    throw createInternalFrameworkException(
+      ZLinkFrameworkInternalErrorKind.SpotGenerationStale,
+      `User Spot '${spotId}' generation is stale.`
+    );
+  }
+  // A committed Closing stays the close target: its owner resumes that Close.
+  const decoded =
+    decodeServiceReadySpotAuthority(current.payload) ??
+    decodeServiceClosingSpotAuthority(current.payload);
+  const allocation = current.allocation;
+  if (
+    decoded?.kind !== 'user_spot' ||
+    decoded.spotId !== spotId ||
+    decoded.ownerId !== current.ownerId ||
+    decoded.ownerLeaseGeneration !== current.ownerLeaseGeneration ||
+    allocation.objectKind !== 'user_spot' ||
+    allocation.state !== 'active' ||
+    String(allocation.descriptor.rid) !== fence.nodeRid ||
+    (fence.meshName !== undefined && allocation.descriptor.meshName !== fence.meshName) ||
+    (fence.nodeGeneration !== undefined &&
+      allocation.descriptorLifecycleGeneration !== fence.nodeGeneration) ||
+    (fence.authorityOwnerGeneration !== undefined &&
+      current.authorityOwnerGeneration !== fence.authorityOwnerGeneration) ||
+    (fence.storeVersion !== undefined && current.storeVersion.value !== fence.storeVersion)
+  ) {
+    throw createInternalFrameworkException(
+      ZLinkFrameworkInternalErrorKind.SpotMoving,
+      `User Spot '${spotId}' owner fence changed or the Spot is moving.`,
+      true
+    );
+  }
+  return {
+    spotId: spotId as RoutingId,
+    objectGeneration: current.objectGeneration,
+    meshName: allocation.descriptor.meshName,
+    nodeRid: allocation.descriptor.rid
+  };
+}
+
 function spotRef(
   snapshot: ZLinkAuthoritySnapshot,
   request: ZLinkUserSpotCreationRequest,

package/src/runtime/locations/in-memory-provider-location-store.ts

@@ -70,12 +70,10 @@ export class ZLinkInMemoryProviderLocationStore implements ZLinkLocationStore {
         this.values.delete(mutation.key.value);
         continue;
       }
-      requireValue(mutation.bytes, mutation.retentionMs);
+      const retentionMs = requireValue(mutation.bytes, mutation.retentionMs);
       const version = storeVersion((++this.nextVersion).toString());
       const expiresAt =
-        mutation.retentionMs === undefined
-          ? undefined
-          : new Date(storeNow.getTime() + mutation.retentionMs);
+        retentionMs === undefined ? undefined : new Date(storeNow.getTime() + retentionMs);
       this.values.set(mutation.key.value, {
         bytes: mutation.bytes.slice(),
         version,
@@ -195,13 +193,19 @@ function requireScanRequest(request: ZLinkStoreScanRequest): void {
   }
 }
 
-function requireValue(bytes: Uint8Array, retentionMs: number | undefined): void {
+function requireValue(bytes: Uint8Array, retentionMs: number | undefined): number | undefined {
   if (bytes.byteLength > 1024 * 1024) {
     throw new RangeError('Location Store value exceeds 1 MiB.');
   }
-  if (retentionMs !== undefined && (!Number.isSafeInteger(retentionMs) || retentionMs < 1)) {
-    throw new RangeError('Location Store retention must be a positive safe integer.');
+  if (
+    retentionMs !== undefined &&
+    (!Number.isFinite(retentionMs) ||
+      retentionMs <= 0 ||
+      !Number.isSafeInteger(Math.ceil(retentionMs)))
+  ) {
+    throw new RangeError('Location Store retention must round to a positive safe integer.');
   }
+  return retentionMs === undefined ? undefined : Math.ceil(retentionMs);
 }
 
 function requireKey(value: string): void {

package/src/runtime/locations/lifecycle.ts

@@ -226,9 +226,10 @@ export class ZLinkLocationLifecycle {
 
   async beginInstanceSpotClosing(
     meshName: string,
-    spotId: RoutingId
+    spotId: RoutingId,
+    onCommitted: () => void
   ): Promise<ZLinkInstanceClosingAuthority | undefined> {
-    return await this.spotClaims.beginInstanceClosing(meshName, spotId);
+    return await this.spotClaims.beginInstanceClosing(meshName, spotId, onCommitted);
   }
 
   trackInstanceSpot(input: ZLinkTrackedInstanceAuthority): void {

package/src/runtime/locations/resolvers.ts

@@ -29,7 +29,10 @@ import type {
   ZLinkRouteLocationStore,
   ZLinkSpotLocationStore
 } from './internal-store-contracts';
-import { decodeServiceReadySpotAuthority } from '../foundation/service-authority-payload-codec';
+import {
+  decodeServiceClosingSpotAuthority,
+  decodeServiceReadySpotAuthority
+} from '../foundation/service-authority-payload-codec';
 import { serviceRelocationAuthorityApplicationPayload } from '../foundation/service-relocation-runtime';
 import { decodeActorAuthorityIdentity } from '../actors/actor-authority-publication';
 import { encodeAuthorityKey } from './authority-key-codec';
@@ -930,9 +933,10 @@ export class ZLinkAuthoritySpotRouteResolver implements ZLinkSpotRouteResolver {
 
       const current = await this.store.readAuthority(encodeAuthorityKey('user_spot', key), signal);
       if (current.kind === 'snapshot' && current.allocation.state === 'active') {
-        const decoded = decodeServiceReadySpotAuthority(
-          serviceRelocationAuthorityApplicationPayload(current.payload)
-        );
+        const authorityPayload = serviceRelocationAuthorityApplicationPayload(current.payload);
+        const ready = decodeServiceReadySpotAuthority(authorityPayload);
+        const closing = decodeServiceClosingSpotAuthority(authorityPayload);
+        const decoded = ready ?? closing;
         if (
           decoded !== undefined &&
           decoded.spotId === String(spotId) &&
@@ -975,15 +979,17 @@ export class ZLinkAuthoritySpotRouteResolver implements ZLinkSpotRouteResolver {
               signal
             )
           };
-          await this.lane.run(() =>
-            this.cacheResolutionCore(
-              key,
-              prepared.epoch,
-              target,
-              remainingLeaseMs,
-              current.storeVersion.value
-            )
-          );
+          if (ready !== undefined) {
+            await this.lane.run(() =>
+              this.cacheResolutionCore(
+                key,
+                prepared.epoch,
+                target,
+                remainingLeaseMs,
+                current.storeVersion.value
+              )
+            );
+          }
           return target;
         }
       }

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

@@ -126,7 +126,8 @@ export class ZLinkSpotLocationClaims {
 
   async beginInstanceClosing(
     meshName: string,
-    spotId: RoutingId
+    spotId: RoutingId,
+    onCommitted: () => void
   ): Promise<ZLinkInstanceClosingAuthority | undefined> {
     const canonical = ZLinkLocationKeyCodec.encodeSpotKey({ meshName, spotId });
     const tracked = this.spots.get(canonical);
@@ -166,39 +167,9 @@ export class ZLinkSpotLocationClaims {
       return undefined;
     }
     tracked.storeVersion = result.storeVersion.value;
-    this.invalidateSpotRoute?.(tracked.spotId);
-    let restored = false;
+    onCommitted();
     return {
-      restoreReady: async () => {
-        if (restored) return;
-        const restore = await store.compareExchangeAuthority(key, result.storeVersion, {
-          kind: 'put',
-          generationTransition: 'preserve',
-          payload: replaceServiceRelocationAuthorityApplicationPayload(
-            current.payload,
-            encodeServiceInstanceAuthorityPayload({
-              state: 'ready',
-              stableType: decoded.stableType,
-              spotId: decoded.spotId,
-              ownerId: decoded.ownerId,
-              ownerLeaseGeneration: decoded.ownerLeaseGeneration,
-              ownerMeshName: decoded.ownerMeshName,
-              ownerNodeRid: decoded.ownerNodeRid,
-              ownerNodeGeneration: decoded.ownerNodeGeneration
-            })
-          )
-        });
-        if (restore.kind !== 'stored') {
-          throw createInternalFrameworkException(
-            ZLinkFrameworkInternalErrorKind.SpotMoving,
-            `Instance Spot '${String(spotId)}' Ready authority could not be restored after idle eviction was declined.`,
-            true
-          );
-        }
-        restored = true;
-        tracked.storeVersion = restore.storeVersion.value;
-        this.invalidateSpotRoute?.(tracked.spotId);
-      }
+      release: async () => undefined
     };
   }
 
@@ -382,7 +353,7 @@ export interface ZLinkTrackedInstanceAuthority {
 }
 
 export interface ZLinkInstanceClosingAuthority {
-  restoreReady(): Promise<void>;
+  release(): Promise<void>;
 }
 
 interface TrackedLegacySpot {