@zlink-systems/framework 0.24.0 → 0.26.0

package/dist/runtime/host/spot-runtime-options-factory.d.ts

@@ -22,11 +22,14 @@ export interface ZLinkSpotRuntimeOptionsFactoryOptions {
     readonly actorManager: () => DefaultZLinkActorManager | undefined;
     readonly locationLifecycle: () => ZLinkLocationLifecycle | undefined;
     readonly releaseInstanceAuthority: (meshName: string, spotId: string, objectGeneration: bigint) => Promise<void>;
-    readonly beginInstanceIdleClosingAuthority: (meshName: string, spotId: string) => Promise<{
-        restoreReady(): Promise<void>;
+    readonly beginInstanceIdleClosingAuthority: (meshName: string, spotId: string, onCommitted: () => void) => Promise<{
+        release(): Promise<void>;
     } | undefined>;
-    readonly beginInstanceClosingAuthority: (meshName: string, spotId: string) => Promise<{
-        restoreReady(): Promise<void>;
+    readonly beginInstanceClosingAuthority: (meshName: string, 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;

package/dist/runtime/host/spot-runtime-options-factory.js

@@ -55,8 +55,9 @@ class ZLinkSpotRuntimeOptionsFactory {
             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: (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()
                 ?.meshNode(meshName)
@@ -85,12 +86,6 @@ class ZLinkSpotRuntimeOptionsFactory {
                     }
                 };
             },
-            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)
@@ -152,6 +147,7 @@ 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/dist/runtime/host/stateful-authority-route-runtime.js

@@ -78,7 +78,7 @@ class ZLinkStatefulAuthorityRouteRuntime {
                 const expectedSpotRoute = previousRoute?.spotRoute ?? null;
                 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 ((0, routing_id_1.routingIdsEqual)(status.routingId, route.instanceRoute.targetNodeRid) &&
                         status.lifecycleGeneration === route.instanceRoute.targetNodeGeneration) {
@@ -346,7 +346,9 @@ function pendingInstanceActivation(snapshot) {
 }
 function authorityRoute(snapshot) {
     const allocation = snapshot.allocation;
-    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(snapshot.payload));
+    const payload = (0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(snapshot.payload);
+    const ready = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(payload);
+    const decoded = ready ?? (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(payload);
     if (allocation.state !== 'active' ||
         allocation.objectKind === 'actor' ||
         allocation.descriptor.meshName.length === 0 ||
@@ -372,6 +374,7 @@ function authorityRoute(snapshot) {
     };
     return {
         kind: allocation.objectKind,
+        closing: ready === undefined,
         stableType: allocation.stableType,
         meshName: allocation.descriptor.meshName,
         spotRoute,
@@ -397,6 +400,7 @@ function sameAppliedRoute(left, right) {
     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/dist/runtime/host/user-spot-creation-coordinator.d.ts

@@ -53,15 +53,23 @@ export declare class ZLinkUserSpotCreationCoordinator {
         readonly nodeRid: RoutingId;
         readonly isLocal: boolean;
     }, authority: ZLinkAuthoritySnapshot, signal: AbortSignal) => Promise<ZLinkLocalSpotCreateResult>, discard?: (signal?: AbortSignal) => Promise<void>): Promise<ZLinkUserSpotCreationResult>;
-    close(spot: SpotRef, closeOwner: (current: SpotRef, snapshot: ZLinkAuthoritySnapshot) => Promise<boolean>, signal?: AbortSignal, ownerPresent?: (current: SpotRef) => boolean, ownerCanClose?: (current: SpotRef) => boolean): Promise<boolean>;
+    close(spot: SpotRef, closeOwner: (current: SpotRef, beginAuthority: (onCommitted: () => void) => Promise<{
+        release(): Promise<void>;
+    }>) => Promise<boolean>, signal?: AbortSignal): Promise<boolean>;
+    /** Commits Closing for the owner's own incarnation when its context requests Close. */
+    beginOwnerClose(spot: SpotRef, onCommitted: () => void): Promise<{
+        release(): Promise<void>;
+    } | undefined>;
     resolveCloseTarget(spot: SpotRef, signal?: AbortSignal): Promise<ZLinkUserSpotCloseTarget | undefined>;
     handleRemoteCreate(record: ServiceUserSpotCreateRecord, materialize: (requestPayload: Uint8Array, authority: ZLinkAuthoritySnapshot, signal: AbortSignal) => Promise<ZLinkLocalSpotCreateResult>, discard?: (signal?: AbortSignal) => Promise<void>, signal?: AbortSignal): Promise<ZLinkUserSpotCreationResult>;
     private handleLocalCreate;
     private materializeRemoteCreate;
-    handleRemoteClose(record: ServiceUserSpotCloseRecord, closeOwner: (spot: SpotRef, signal?: AbortSignal) => Promise<boolean>, signal?: AbortSignal): Promise<boolean>;
+    handleRemoteClose(record: ServiceUserSpotCloseRecord, closeOwner: (spot: SpotRef, beginAuthority: (onCommitted: () => void) => Promise<{
+        release(): Promise<void>;
+    }>, signal?: AbortSignal) => Promise<boolean>, signal?: AbortSignal, canResume?: (spot: SpotRef) => boolean): Promise<boolean>;
+    private commitCloseAuthority;
     forgetReadyRoute(spotId: RoutingId, snapshot: ZLinkAuthoritySnapshot): void;
     private beginClosing;
-    private restoreReady;
     private awaitReady;
     private remoteCreate;
 }

package/dist/runtime/host/user-spot-creation-coordinator.js

@@ -192,60 +192,35 @@ class ZLinkUserSpotCreationCoordinator {
             deadline.close();
         }
     }
-    async close(spot, closeOwner, signal, ownerPresent, ownerCanClose) {
+    async close(spot, closeOwner, signal) {
         const resolved = await this.resolveCloseTarget(spot, signal);
         if (resolved === undefined)
             return false;
         const { spot: currentRef, snapshot: current } = resolved;
         const key = (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(spot.spotId));
-        if (ownerPresent?.(currentRef) === false) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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;
-        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);
-        if (deleted.kind === 'deleted') {
-            this.forgetReadyRoute(currentRef.spotId, current);
-            return true;
-        }
-        if (deleted.kind === 'conflict') {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${String(spot.spotId)}' authority changed while closing.`, true);
-        }
-        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale, `User Spot '${String(spot.spotId)}' generation cannot be closed.`);
+        return await closeOwner(currentRef, async (onCommitted) => this.commitCloseAuthority(key, current, String(spot.spotId), onCommitted));
+    }
+    /** Commits Closing for the owner's own incarnation when its context requests Close. */
+    async beginOwnerClose(spot, onCommitted) {
+        const resolved = await this.resolveCloseTarget(spot);
+        if (resolved === undefined)
+            return undefined;
+        const spotId = String(spot.spotId);
+        return await this.commitCloseAuthority((0, authority_key_codec_1.encodeAuthorityKey)('user_spot', spotId), resolved.snapshot, spotId, onCommitted);
     }
     async resolveCloseTarget(spot, signal) {
         const key = (0, authority_key_codec_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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(record, materialize, discard, signal) {
         const key = `${record.spotId}\0${record.reservation.reservationId}`;
@@ -430,52 +405,50 @@ class ZLinkUserSpotCreationCoordinator {
             throw error;
         }
     }
-    async handleRemoteClose(record, closeOwner, signal) {
+    async handleRemoteClose(record, closeOwner, signal, canResume) {
         const key = (0, authority_key_codec_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${record.target.spotId}' close authority is moving.`, true);
-        }
-        const spot = {
+        const candidate = {
             spotId: record.target.spotId,
             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;
-        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' }, signal);
-        if (deleted.kind === 'deleted') {
-            this.forgetReadyRoute(record.target.spotId, current);
-            return true;
-        }
-        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${record.target.spotId}' authority changed while closing.`, true);
+        // 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 &&
+            (0, service_authority_payload_codec_1.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);
+    }
+    async commitCloseAuthority(key, current, spotId, onCommitted) {
+        const closing = await this.beginClosing(key, current, spotId);
+        const authority = {
+            release: async () => {
+                this.forgetReadyRoute(spotId, current);
+                const deleted = await this.options.store.compareExchangeAuthority(key, closing.storeVersion, {
+                    kind: 'delete'
+                });
+                if (deleted.kind !== 'deleted') {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${spotId}' authority changed while closing.`, true);
+                }
+            }
+        };
+        onCommitted();
+        return authority;
     }
     forgetReadyRoute(spotId, snapshot) {
         this.options.forgetReadyRoute?.(snapshot.allocation.descriptor.meshName, readySpotRoute(spotId, snapshot));
     }
-    async beginClosing(key, current, spotId, signal) {
+    async beginClosing(key, current, spotId) {
         const ready = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(current.payload);
         if (ready?.kind !== 'user_spot' ||
             ready.spotId !== spotId ||
@@ -486,23 +459,13 @@ class ZLinkUserSpotCreationCoordinator {
             kind: 'put',
             payload: userSpotAuthorityPayload(current, spotId, 'closing'),
             generationTransition: 'preserve'
-        }, signal);
+        }, undefined);
         if (closing.kind === 'stored') {
             const { kind: _kind, ...snapshot } = closing;
             return { kind: 'snapshot', ...snapshot };
         }
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot authority changed while entering Closing.`, true);
     }
-    async restoreReady(key, closing, spotId, signal) {
-        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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'User Spot Ready authority could not be restored after close was declined.', true);
-        }
-    }
     async awaitReady(request, signal) {
         const key = (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(request.spotId));
         for (;;) {
@@ -588,6 +551,41 @@ function readySpotRoute(spotId, snapshot) {
         storeVersion: snapshot.storeVersion.value
     };
 }
+/**
+ * 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, spotId, fence) {
+    if (current.objectGeneration !== fence.objectGeneration) {
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale, `User Spot '${spotId}' generation is stale.`);
+    }
+    // A committed Closing stays the close target: its owner resumes that Close.
+    const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(current.payload) ??
+        (0, service_authority_payload_codec_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${spotId}' owner fence changed or the Spot is moving.`, true);
+    }
+    return {
+        spotId: spotId,
+        objectGeneration: current.objectGeneration,
+        meshName: allocation.descriptor.meshName,
+        nodeRid: allocation.descriptor.rid
+    };
+}
 function spotRef(snapshot, request, allowPending = false) {
     const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(snapshot.payload);
     if (allowPending

package/dist/runtime/locations/in-memory-provider-location-store.js

@@ -52,11 +52,9 @@ class ZLinkInMemoryProviderLocationStore {
                 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);
+            const expiresAt = retentionMs === undefined ? undefined : new Date(storeNow.getTime() + retentionMs);
             this.values.set(mutation.key.value, {
                 bytes: mutation.bytes.slice(),
                 version,
@@ -169,9 +167,13 @@ function requireValue(bytes, retentionMs) {
     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) {
     const bytes = Buffer.byteLength(value, 'utf8');

package/dist/runtime/locations/lifecycle.d.ts

@@ -31,7 +31,7 @@ export declare class ZLinkLocationLifecycle {
     private retryActorRelease;
     claimSpot(meshName: string, spotId: RoutingId, spotType: string, nodeRid: RoutingId, spotKind: ZLinkSpotKind, spotGeneration: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkLocationWriteStatus>;
     releaseSpot(meshName: string, spotId: RoutingId, expectedObjectGeneration?: bigint): Promise<void>;
-    beginInstanceSpotClosing(meshName: string, spotId: RoutingId): Promise<ZLinkInstanceClosingAuthority | undefined>;
+    beginInstanceSpotClosing(meshName: string, spotId: RoutingId, onCommitted: () => void): Promise<ZLinkInstanceClosingAuthority | undefined>;
     trackInstanceSpot(input: ZLinkTrackedInstanceAuthority): void;
     reclaimOwnerRows(): Promise<void>;
     bindActorSessionRoute(sessionRid: RoutingId, actorId: string, ownerNodeRid: RoutingId): Promise<void>;

package/dist/runtime/locations/lifecycle.js

@@ -81,8 +81,8 @@ class ZLinkLocationLifecycle {
     async releaseSpot(meshName, spotId, expectedObjectGeneration) {
         await this.spotClaims.release(meshName, spotId, expectedObjectGeneration);
     }
-    async beginInstanceSpotClosing(meshName, spotId) {
-        return await this.spotClaims.beginInstanceClosing(meshName, spotId);
+    async beginInstanceSpotClosing(meshName, spotId, onCommitted) {
+        return await this.spotClaims.beginInstanceClosing(meshName, spotId, onCommitted);
     }
     trackInstanceSpot(input) {
         this.spotClaims.trackInstanceAuthority(input);

package/dist/runtime/locations/resolvers.js

@@ -582,7 +582,10 @@ class ZLinkAuthoritySpotRouteResolver {
                 return prepared.cached;
             const current = await this.store.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('user_spot', key), signal);
             if (current.kind === 'snapshot' && current.allocation.state === 'active') {
-                const decoded = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(current.payload));
+                const authorityPayload = (0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(current.payload);
+                const ready = (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(authorityPayload);
+                const closing = (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(authorityPayload);
+                const decoded = ready ?? closing;
                 if (decoded !== undefined &&
                     decoded.spotId === String(spotId) &&
                     decoded.ownerId === current.ownerId &&
@@ -610,7 +613,9 @@ class ZLinkAuthoritySpotRouteResolver {
                         authorityStoreVersion: current.storeVersion.value,
                         targetNodeState: await this.targetNodeStateResolver?.(decoded.ownerMeshName, decoded.ownerNodeRid, current.allocation.descriptorLifecycleGeneration, 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/dist/runtime/locations/spot-location-claims.d.ts

@@ -13,7 +13,7 @@ export declare class ZLinkSpotLocationClaims {
     claim(meshName: string, spotId: RoutingId, spotType: string, nodeRid: RoutingId, spotKind: ZLinkSpotKind, spotGeneration: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkLocationWriteStatus>;
     trackInstanceAuthority(input: ZLinkTrackedInstanceAuthority): void;
     release(meshName: string, spotId: RoutingId, expectedObjectGeneration?: bigint): Promise<void>;
-    beginInstanceClosing(meshName: string, spotId: RoutingId): Promise<ZLinkInstanceClosingAuthority | undefined>;
+    beginInstanceClosing(meshName: string, spotId: RoutingId, onCommitted: () => void): Promise<ZLinkInstanceClosingAuthority | undefined>;
     onOwnershipLost(event: ZLinkOwnershipLostEvent): void;
     reclaimOwnerRows(): Promise<void>;
     private releaseAuthority;
@@ -32,5 +32,5 @@ export interface ZLinkTrackedInstanceAuthority {
     readonly deactivate?: () => Promise<void>;
 }
 export interface ZLinkInstanceClosingAuthority {
-    restoreReady(): Promise<void>;
+    release(): Promise<void>;
 }

package/dist/runtime/locations/spot-location-claims.js

@@ -82,7 +82,7 @@ class ZLinkSpotLocationClaims {
         }
         this.invalidateSpotRoute?.(tracked.spotId);
     }
-    async beginInstanceClosing(meshName, spotId) {
+    async beginInstanceClosing(meshName, spotId, onCommitted) {
         const canonical = key_codec_1.ZLinkLocationKeyCodec.encodeSpotKey({ meshName, spotId });
         const tracked = this.spots.get(canonical);
         const store = this.authorityStore;
@@ -116,33 +116,9 @@ 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: (0, service_relocation_runtime_1.replaceServiceRelocationAuthorityApplicationPayload)(current.payload, (0, service_authority_payload_codec_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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
         };
     }
     onOwnershipLost(event) {

package/dist/runtime/protocol/service_wire_codec.generated.d.ts

@@ -343,6 +343,7 @@ export type SessionRelocationRouteUpdate = {
     readonly targetAuthorityOwnerGeneration: NonzeroU64;
     readonly targetNodeRid: Rid;
     readonly targetNodeGeneration: NonzeroU64;
+    readonly targetOwnerLeaseGeneration: NonzeroU64;
 } | {
     readonly action: "abort";
     readonly currentAuthorityOwnerGeneration: NonzeroU64;

package/dist/runtime/protocol/service_wire_codec.generated.js

@@ -3701,6 +3701,7 @@ function readSessionRelocationRouteUpdate(reader, context, enclosing, flags) {
         value["targetAuthorityOwnerGeneration"] = readNonzeroU64(body, context, value, flags);
         value["targetNodeRid"] = readRid(body, context, value, flags);
         value["targetNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+        value["targetOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
     }
     else if (same(value["action"], "abort")) {
         value["currentAuthorityOwnerGeneration"] = readNonzeroU64(body, context, value, flags);
@@ -3732,9 +3733,12 @@ function writeSessionRelocationRouteUpdate(input, writer, context, enclosing, fl
         if (value["targetNodeGeneration"] === undefined)
             fail("targetNodeGeneration required");
         writeNonzeroU64(numeric(value["targetNodeGeneration"]), body, context, value, flags);
+        if (value["targetOwnerLeaseGeneration"] === undefined)
+            fail("targetOwnerLeaseGeneration required");
+        writeNonzeroU64(numeric(value["targetOwnerLeaseGeneration"]), body, context, value, flags);
     }
     else if (same(value["action"], "abort")) {
-        if (value["previousAuthorityOwnerGeneration"] !== undefined || value["targetAuthorityOwnerGeneration"] !== undefined || value["targetNodeRid"] !== undefined || value["targetNodeGeneration"] !== undefined)
+        if (value["previousAuthorityOwnerGeneration"] !== undefined || value["targetAuthorityOwnerGeneration"] !== undefined || value["targetNodeRid"] !== undefined || value["targetNodeGeneration"] !== undefined || value["targetOwnerLeaseGeneration"] !== undefined)
             fail("session-relocation-route-update discriminator agreement");
         if (value["currentAuthorityOwnerGeneration"] === undefined)
             fail("currentAuthorityOwnerGeneration required");

package/dist/runtime/protocol/service_wire_pilot_codec.generated.d.ts

@@ -200,6 +200,7 @@ export type ServiceWireSessionRouteUpdate = {
     readonly targetAuthorityOwnerGeneration: bigint;
     readonly targetNodeRid: Uint8Array;
     readonly targetNodeGeneration: bigint;
+    readonly targetOwnerLeaseGeneration: bigint;
 } | {
     readonly action: "abort";
     readonly currentAuthorityOwnerGeneration: bigint;

package/dist/runtime/protocol/service_wire_pilot_codec.generated.js

@@ -522,12 +522,13 @@ function b3ValidTerminal(result, failure, payload) { const boundary = [101, 103,
 } if (b3FailureResults.get(failure) !== result)
     throw new RangeError("typed failure"); }
 function b3WriteRoute(out, v) { out.push(v.action === "commit" ? 1 : 2); body16(out, b => { if (v.action === "commit") {
-    if (v.previousAuthorityOwnerGeneration === 0n || v.targetAuthorityOwnerGeneration === 0n || v.targetNodeGeneration === 0n)
+    if (v.previousAuthorityOwnerGeneration === 0n || v.targetAuthorityOwnerGeneration === 0n || v.targetNodeGeneration === 0n || v.targetOwnerLeaseGeneration === 0n)
         throw new RangeError("route commit");
     u64(b, v.previousAuthorityOwnerGeneration);
     u64(b, v.targetAuthorityOwnerGeneration);
     rid(b, v.targetNodeRid);
     u64(b, v.targetNodeGeneration);
+    u64(b, v.targetOwnerLeaseGeneration);
 }
 else {
     if (v.currentAuthorityOwnerGeneration === 0n)
@@ -535,7 +536,7 @@ else {
     u64(b, v.currentAuthorityOwnerGeneration);
 } }); }
 function b3ReadRoute(bytes, at) { const action = read8(bytes, at), end = boundedEnd(bytes, at, read16(bytes, at), "session route"); let value; if (action === 1)
-    value = { action: "commit", previousAuthorityOwnerGeneration: nonzero64(bytes, at, "previous authority"), targetAuthorityOwnerGeneration: nonzero64(bytes, at, "target authority"), targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node") };
+    value = { action: "commit", previousAuthorityOwnerGeneration: nonzero64(bytes, at, "previous authority"), targetAuthorityOwnerGeneration: nonzero64(bytes, at, "target authority"), targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node"), targetOwnerLeaseGeneration: nonzero64(bytes, at, "target lease") };
 else if (action === 2)
     value = { action: "abort", currentAuthorityOwnerGeneration: nonzero64(bytes, at, "current authority") };
 else

package/dist/runtime/spots/formal-remote-actor-admission-registry.d.ts

@@ -1,6 +1,6 @@
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId } from '../../contracts';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors/actor-runtime-state';
-import type { ZLinkDeferredJoinAcceptedRoot } from '../actors/deferred-join-accepted-journal';
+import type { ZLinkDeferredJoinCompletion } from '../actors/deferred-join-completion';
 import type { ZLinkActorRequestTerminal } from './spot-actor-packet-dispatch';
 /**
  * One production-ingress arrival parked at the target between admission
@@ -40,7 +40,7 @@ export interface ZLinkFormalRemoteActorAdmissionOutcome {
     readonly actorRef: ActorRef;
     readonly reply?: Buffer;
     readonly replyContentType?: string;
-    readonly deferredJoinRoot?: ZLinkDeferredJoinAcceptedRoot;
+    readonly deferredJoinCompletion?: ZLinkDeferredJoinCompletion;
 }
 export interface ZLinkFormalRemoteActorAdmissionFailure {
     readonly error: unknown;
@@ -111,7 +111,7 @@ export declare class ZLinkFormalRemoteActorAdmissionRegistry {
     complete(transferId: string, outcome: ZLinkFormalRemoteActorAdmissionOutcome): void;
     fail(transferId: string, error: unknown): void;
     markCommitted(transferId: string, actor: ZLinkActor): void;
-    attachDeferredJoinRoot(transferId: string, root: ZLinkDeferredJoinAcceptedRoot): void;
+    attachDeferredJoinCompletion(transferId: string, root: ZLinkDeferredJoinCompletion): void;
     abort(transferId: string): void;
     /**
      * Releases the admission for {@code transferId} — normal retention

package/dist/runtime/spots/formal-remote-actor-admission-registry.js

@@ -161,9 +161,9 @@ class ZLinkFormalRemoteActorAdmissionRegistry {
             ...(outcome.replyContentType === undefined
                 ? {}
                 : { replyContentType: outcome.replyContentType }),
-            ...(outcome.deferredJoinRoot === undefined
+            ...(outcome.deferredJoinCompletion === undefined
                 ? {}
-                : { deferredJoinRoot: outcome.deferredJoinRoot })
+                : { deferredJoinCompletion: outcome.deferredJoinCompletion })
         };
         entry.resolveResult(entry.result);
         if (!outcome.accepted) {
@@ -192,7 +192,7 @@ class ZLinkFormalRemoteActorAdmissionRegistry {
         entry.state = 'committed';
         entry.actor = actor;
     }
-    attachDeferredJoinRoot(transferId, root) {
+    attachDeferredJoinCompletion(transferId, root) {
         const entry = this.admissions.get(transferId);
         if (entry === undefined ||
             entry.state !== 'admitted' ||
@@ -201,7 +201,7 @@ class ZLinkFormalRemoteActorAdmissionRegistry {
             !entry.result.accepted) {
             throw new Error(`Remote actor admission '${transferId}' cannot attach deferred recovery.`);
         }
-        entry.result = { ...entry.result, deferredJoinRoot: root };
+        entry.result = { ...entry.result, deferredJoinCompletion: root };
     }
     abort(transferId) {
         const entry = this.admissions.get(transferId);