@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/spots/spot-activation-registry.d.ts

@@ -35,9 +35,11 @@ export declare class ZLinkSpotActivationRegistry {
     nextActiveActivationBatch(limit?: number): readonly ZLinkSpotActivation[];
     closingOperation(meshName: string, spotId: RoutingId): ZLinkSpotCloseOperation | undefined;
     whenEmpty(signal?: AbortSignal): Promise<void>;
-    register(activation: ZLinkSpotActivation): void;
+    registerPreparing(activation: ZLinkSpotActivation): void;
+    register(activation: ZLinkSpotActivation): ZLinkSpotActivation | undefined;
+    private registerIncarnation;
     stage(meshName: string, spotId: RoutingId): void;
-    publish(meshName: string, spotId: RoutingId): void;
+    publish(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined;
     detachRelocated(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined;
     abandonStage(meshName: string, spotId: RoutingId): void;
     startClose(meshName: string, spotId: RoutingId, close: (activation: ZLinkSpotActivation) => Promise<void>, resourcesReleased: (activation: ZLinkSpotActivation) => boolean, reason?: ZLinkSpotCloseReason): ZLinkSpotCloseOperation | undefined;

package/dist/runtime/spots/spot-activation-registry.js

@@ -31,24 +31,22 @@ class ZLinkSpotActivationRegistry {
     }
     resolve(meshName, spotId) {
         const key = spotActivationKey(meshName, spotId);
-        return this.staged.has(key) ? undefined : this.activations.get(key);
+        return this.staged.has(key) || this.pending.has(key) ? undefined : this.activations.get(key);
     }
     resolveUnique(spotId) {
         const matches = [...this.activations.values()].filter((activation) => String(activation.spotId) === String(spotId) &&
-            !this.staged.has(spotActivationKey(activation.meshName, activation.spotId)));
+            this.has(activation.meshName, activation.spotId));
         return matches.length === 1 ? matches[0] : undefined;
     }
     has(meshName, spotId) {
-        const key = spotActivationKey(meshName, spotId);
-        return !this.staged.has(key) && this.activations.has(key);
+        return this.resolve(meshName, spotId) !== undefined;
     }
     list(meshName) {
         return [...this.activations.values()]
             .filter((activation) => {
             if (activation.meshName !== meshName)
                 return false;
-            const key = spotActivationKey(activation.meshName, activation.spotId);
-            return !this.staged.has(key);
+            return this.has(activation.meshName, activation.spotId);
         })
             .map((activation) => String(activation.spotId))
             .sort((left, right) => left.localeCompare(right))
@@ -112,19 +110,31 @@ class ZLinkSpotActivationRegistry {
             signal?.addEventListener('abort', abort, { once: true });
         });
     }
+    registerPreparing(activation) {
+        this.registerIncarnation(activation);
+    }
     register(activation) {
+        return this.registerIncarnation(activation);
+    }
+    registerIncarnation(activation) {
         const key = spotActivationKey(activation.meshName, activation.spotId);
-        if (this.activations.has(key)) {
+        const existing = this.activations.get(key);
+        if (existing !== undefined && existing !== activation) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `Spot '${activation.spotId}' was activated more than once.`);
         }
-        this.activations.set(key, activation);
-        this.lifecycleMetrics.opened('user');
+        if (existing === undefined) {
+            this.activations.set(key, activation);
+            this.lifecycleMetrics.opened('user');
+        }
+        return this.staged.has(key) ? undefined : activation;
     }
     stage(meshName, spotId) {
         this.staged.add(spotActivationKey(meshName, spotId));
     }
     publish(meshName, spotId) {
-        this.staged.delete(spotActivationKey(meshName, spotId));
+        const key = spotActivationKey(meshName, spotId);
+        this.staged.delete(key);
+        return this.activations.get(key);
     }
     detachRelocated(meshName, spotId) {
         const key = spotActivationKey(meshName, spotId);
@@ -189,7 +199,7 @@ class ZLinkSpotActivationRegistry {
     getOrBegin(meshName, spotType, spotId, create) {
         const key = spotActivationKey(meshName, spotId);
         const existing = this.activations.get(key);
-        if (existing !== undefined) {
+        if (existing !== undefined && !this.pending.has(key)) {
             return {
                 owner: false,
                 ready: existing.serial.execute(() => {

package/dist/runtime/spots/spot-activation-state.d.ts

@@ -71,7 +71,7 @@ export declare class ZLinkSpotActivation {
     waitForRelocationBoundary(signal?: AbortSignal): Promise<boolean>;
     completeConsumedRelocationBoundary(outcome: ZLinkSpotRelocationReadyOutcome): Promise<void>;
     notifyRelocatedBoundary(): Promise<void>;
-    executeActor<T>(actorId: string, operation: (serial: ZLinkSpotSerialTurnExecutor) => Promise<T> | T): Promise<T>;
+    executeActor<T>(actorId: string, operation: (serial: ZLinkSpotSerialTurnExecutor) => Promise<T> | T, workOptions?: import('../execution/serial-execution-queue').ZLinkSerialWorkOptions): Promise<T>;
     sealExecution(kind?: ZLinkExecutionBarrierSeal['kind']): ZLinkExecutionBarrierSeal;
     waitForExecutionQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
     abortExecutionSeal(seal: ZLinkExecutionBarrierSeal): boolean;

package/dist/runtime/spots/spot-activation-state.js

@@ -146,17 +146,17 @@ class ZLinkSpotActivation {
             return;
         this.relocationBoundaryConsumed = false;
         this.relocationReadyDeferredTurnId = undefined;
-        await this.serial.post(() => this.notifyRelocationReadyCompleted(outcome));
+        await this.serial.postBarrierTurn(() => this.notifyRelocationReadyCompleted(outcome));
     }
     async notifyRelocatedBoundary() {
-        await this.serial.post(() => this.notifyRelocationReadyCompleted(contracts_1.ZLinkSpotRelocationReadyOutcome.Relocated));
+        await this.serial.postBarrierTurn(() => this.notifyRelocationReadyCompleted(contracts_1.ZLinkSpotRelocationReadyOutcome.Relocated));
     }
-    executeActor(actorId, operation) {
-        return this.serialExecutor.executeActor(actorId, operation);
+    executeActor(actorId, operation, workOptions) {
+        return this.serialExecutor.executeActor(actorId, operation, workOptions);
     }
     /** @internal Restores a non-executing durable prefix into one Actor FIFO. */
-    admitActorDurablePrefix(actorId, records) {
-        return this.serialExecutor.admitActorDurablePrefix(actorId, records);
+    admitActorPacketPrefix(actorId, records, dispatch) {
+        return this.serialExecutor.admitActorPacketPrefix(actorId, records, dispatch);
     }
     sealExecution(kind = 'relocation') {
         return this.executionBarrier.seal(kind);
@@ -187,7 +187,7 @@ class ZLinkSpotActivation {
     abortRelocation(capture) {
         if (!this.executionBarrier.isCurrent(capture.seal))
             return false;
-        this.timers.abortRelocation(capture.timers);
+        this.timers.abortRelocation();
         return this.abortExecutionSeal(capture.seal);
     }
     async commitRelocation(capture) {

package/dist/runtime/spots/spot-activation.d.ts

@@ -12,7 +12,7 @@ import { ZLinkDispatchErrorReporter } from '../channels';
 import { type ZLinkRemoteBoundSessionTarget } from '../actors';
 import { ZLinkWorkerRuntime } from '../workers';
 import { type ZLinkSpotAddressTransport, type ZLinkSpotRoutedTransport } from './spot-outbound';
-import { type ZLinkTimerClock } from './spot-timer';
+import { type ZLinkTimerClock, type ZLinkTimerRelocationState } from './spot-timer';
 import type { ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
 import type { ZLinkRouteToActorJoinPrewarm } from './spot-actor-packet-dispatch';
 import { ZLinkSpotActivation } from './spot-activation-state';
@@ -29,6 +29,7 @@ export interface ZLinkSpotActivationLifecycleOptions {
     readonly nodeRid?: RoutingId;
     readonly nodeRidProvider?: (meshName: string) => RoutingId | undefined;
     readonly actorCountProvider?: (spotId: RoutingId) => number;
+    readonly releaseActorMembers?: (meshName: string, spotId: RoutingId) => Promise<void>;
     readonly userSpotExecutionMode?: (meshName: string, spotType: Type<ZLinkSpot>) => ZLinkUserSpotExecutionMode;
     readonly userSpotRelocationCoordinationMode?: (meshName: string, spotType: Type<ZLinkSpot>) => ZLinkSpotRelocationCoordinationMode;
     readonly channelClient?: ZLinkChannelClient;
@@ -57,7 +58,9 @@ export interface ZLinkSpotActivationLifecycleOptions {
     readonly leaveActor: (spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal, meshName?: string) => Promise<void>;
     /** Starts a context Close request after its calling turn has ended. */
     readonly requestContextClose: (activation: ZLinkSpotActivation, objectGeneration: bigint, signal?: AbortSignal) => Promise<boolean>;
-    readonly registerActivation: (activation: ZLinkSpotActivation) => void;
+    readonly registerActivation: (activation: ZLinkSpotActivation) => void | Promise<void>;
+    readonly stageActivation?: (activation: ZLinkSpotActivation) => void;
+    readonly discardActivation?: (activation: ZLinkSpotActivation) => void;
     readonly routeToActorJoinPrewarm?: ZLinkRouteToActorJoinPrewarm;
     readonly releaseLocation: (activation: ZLinkSpotActivation, meshName: string, spotId: RoutingId) => Promise<void>;
     readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
@@ -73,7 +76,7 @@ export declare class ZLinkSpotActivationLifecycle {
     private readonly actorAdmission;
     private readonly cleanupStates;
     constructor(options: ZLinkSpotActivationLifecycleOptions);
-    materializeRelocation<TSpot extends ZLinkSpot | ZLinkInstanceSpot>(meshName: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, implementation: Type<TSpot>, spotId: RoutingId, objectGeneration: bigint, authorityOwnerGeneration: bigint, signal?: AbortSignal): Promise<ZLinkSpotActivation>;
+    materializeRelocation<TSpot extends ZLinkSpot | ZLinkInstanceSpot>(meshName: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, implementation: Type<TSpot>, spotId: RoutingId, objectGeneration: bigint, authorityOwnerGeneration: bigint, restoredTimers: readonly ZLinkTimerRelocationState[], signal?: AbortSignal): Promise<ZLinkSpotActivation>;
     materializeInstance<TSpot extends ZLinkInstanceSpot>(meshName: string, instanceType: string, implementation: Type<TSpot>, spotId: RoutingId, objectGeneration: bigint, signal?: AbortSignal, serialOwner?: ZLinkSpotActivation): Promise<ZLinkSpotActivation>;
     discardInstance(activation: ZLinkSpotActivation): Promise<void>;
     create<TSpot extends ZLinkSpot>(meshName: string, spotType: Type<TSpot>, spotId: RoutingId, request: Message, signal?: AbortSignal, authority?: ZLinkNativeSpotAuthority): Promise<ZLinkLocalSpotCreateResult>;
@@ -86,6 +89,7 @@ export declare class ZLinkSpotActivationLifecycle {
     dispatchActorPacket(origin: ApplicationJobOrigin, activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     private runCreateLifecycle;
     private cleanupActivation;
+    discardPreparation(activation: ZLinkSpotActivation): Promise<void>;
     private runCleanup;
     private decodeCreateReply;
 }

package/dist/runtime/spots/spot-activation.js

@@ -29,14 +29,14 @@ class ZLinkSpotActivationLifecycle {
         }
         this.actorAdmission = new spot_actor_admission_coordinator_1.ZLinkSpotActorAdmissionCoordinator(options);
     }
-    async materializeRelocation(meshName, objectKind, stableType, implementation, spotId, objectGeneration, authorityOwnerGeneration, signal) {
+    async materializeRelocation(meshName, objectKind, stableType, implementation, spotId, objectGeneration, authorityOwnerGeneration, restoredTimers, signal) {
         const executionMode = objectKind === 'user_spot'
             ? (this.options.userSpotExecutionMode?.(meshName, implementation) ?? contracts_1.ZLinkUserSpotExecutionMode.SpotWide)
             : contracts_1.ZLinkUserSpotExecutionMode.SpotWide;
         const serial = new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(executionMode === contracts_1.ZLinkUserSpotExecutionMode.SpotWide, spotId);
         const serialExecutor = new spot_serial_executor_1.ZLinkSpotSerialExecutor(serial, executionMode, spotId);
         const actorHandlers = new actors_1.ZLinkSpotActorHandlerRegistryRuntime();
-        const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers);
+        const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers, this.options.providerResolver);
         (0, spot_handler_registry_1.applySpotHandlerRegistrations)(handlers, implementation, objectKind === 'user_spot'
             ? {
                 actorSendHandlers: this.options.spotActorSendHandlers,
@@ -46,6 +46,9 @@ class ZLinkSpotActivationLifecycle {
             }
             : { packetHandlers: this.options.spotPacketHandlers });
         const timers = new spot_timer_1.ZLinkSpotTimerRegistry(this.options.metrics, () => this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, undefined, this.options.statefulExecutionAllowed, (name, operation) => serialExecutor.executeTimer(name, operation), (name) => serialExecutor.isTimerExecuting(name), this.options.timerClock);
+        // Spot timer §1: the source schedule exists before Configure so its
+        // registrations reattach to the restored keys.
+        timers.stageRelocation(restoredTimers);
         const outbound = new spot_outbound_1.DefaultZLinkSpotOutbound({
             serial,
             channelClient: this.options.channelClient,
@@ -102,12 +105,6 @@ class ZLinkSpotActivationLifecycle {
                 enumerable: false,
                 value: context
             });
-            await instance.configure?.();
-            await (0, spot_timer_1.addSpotTimerRegistrations)(timers, implementation, spotId, instance, serial, { timerHandlers: this.options.spotTimerHandlers }, {
-                providerResolver: this.options.providerResolver,
-                runtimeEventPublisher: this.options.runtimeEventPublisher,
-                signal
-            });
             activation = new spot_activation_state_1.ZLinkSpotActivation({
                 meshName,
                 spotId,
@@ -130,10 +127,27 @@ class ZLinkSpotActivationLifecycle {
                 nativeSpot,
                 metrics: this.options.metrics
             });
-            this.options.registerActivation(activation);
+            serialExecutor.beginPreparation('relocation');
+            const configured = instance;
+            await serial.postBarrierTurn(() => timers.runRelocationInitialization(async () => {
+                await configured.configure?.();
+                await (0, spot_timer_1.addSpotTimerRegistrations)(timers, implementation, spotId, configured, serial, { timerHandlers: this.options.spotTimerHandlers }, {
+                    providerResolver: this.options.providerResolver,
+                    runtimeEventPublisher: this.options.runtimeEventPublisher,
+                    signal
+                });
+                // Node timer relocation: restored handlers resolve by name among the
+                // constructors announced in Configure (addTimer or addTimerHandler).
+                await timers.resolveRelocationHandlers(handlers
+                    .snapshot()
+                    .filter((entry) => entry.kind === 'timer')
+                    .map((entry) => entry.handlerType), (name, periodMs, handlerType) => context.addTimer(name, periodMs, handlerType, undefined, signal));
+            }));
+            await this.options.registerActivation(activation);
             return activation;
         }
         catch (error) {
+            const preparation = await Promise.allSettled(activation === undefined ? [] : [this.discardPreparation(activation)]);
             const cleanup = await Promise.allSettled([
                 timers.dispose(),
                 ...(instance === undefined
@@ -141,7 +155,7 @@ class ZLinkSpotActivationLifecycle {
                     : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)]),
                 ...(nativeSpot === undefined ? [] : [Promise.resolve().then(() => nativeSpot.dispose())])
             ]);
-            const cleanupErrors = cleanup
+            const cleanupErrors = [...preparation, ...cleanup]
                 .filter((result) => result.status === 'rejected')
                 .map((result) => result.reason);
             if (cleanupErrors.length > 0) {
@@ -151,10 +165,11 @@ class ZLinkSpotActivationLifecycle {
         }
     }
     async materializeInstance(meshName, instanceType, implementation, spotId, objectGeneration, signal, serialOwner) {
+        (0, abort_1.throwIfAborted)(signal);
         const serial = serialOwner?.serial ?? new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(true, spotId);
         const serialExecutor = new spot_serial_executor_1.ZLinkSpotSerialExecutor(serial, contracts_1.ZLinkUserSpotExecutionMode.SpotWide, spotId);
         const actorHandlers = new actors_1.ZLinkSpotActorHandlerRegistryRuntime();
-        const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers);
+        const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers, this.options.providerResolver);
         const instanceHandlers = new spot_handler_registry_1.DefaultZLinkInstanceSpotHandlerRegistry(handlers);
         (0, spot_handler_registry_1.applySpotHandlerRegistrations)(handlers, implementation, {
             packetHandlers: this.options.spotPacketHandlers
@@ -207,31 +222,56 @@ class ZLinkSpotActivationLifecycle {
             externalActorCount: () => this.options.actorCountProvider?.(spotId) ?? 0
         });
         try {
-            await instance.configure?.();
-            await (0, spot_timer_1.addSpotTimerRegistrations)(timers, implementation, spotId, instance, serial, { timerHandlers: this.options.spotTimerHandlers }, {
-                providerResolver: this.options.providerResolver,
-                runtimeEventPublisher: this.options.runtimeEventPublisher,
-                signal
+            if (serialOwner === undefined)
+                serialExecutor.beginPreparation();
+            await serial.postBarrierTurn(async () => {
+                (0, abort_1.throwIfAborted)(signal);
+                await instance.configure?.();
+                await (0, spot_timer_1.addSpotTimerRegistrations)(timers, implementation, spotId, instance, serial, { timerHandlers: this.options.spotTimerHandlers }, {
+                    providerResolver: this.options.providerResolver,
+                    runtimeEventPublisher: this.options.runtimeEventPublisher,
+                    signal
+                });
+                (0, abort_1.throwIfAborted)(signal);
+                await instance.onInitialize?.(signal);
             });
-            await (serialOwner === undefined
-                ? serial.execute(() => instance.onInitialize?.())
-                : serial.postBarrierTurn(() => instance.onInitialize?.()));
-            this.options.registerActivation(activation);
+            (0, abort_1.throwIfAborted)(signal);
+            await this.options.registerActivation(activation);
             return activation;
         }
         catch (error) {
-            const cleanup = await Promise.allSettled([
-                timers.dispose(),
-                (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)
-            ]);
-            const cleanupErrors = cleanup
-                .filter((result) => result.status === 'rejected')
-                .map((result) => result.reason);
-            throw new AggregateError([error, ...cleanupErrors], `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`);
+            const failure = signal?.aborted === true ? (0, abort_1.createAbortError)() : error;
+            const cancelled = (0, abort_1.isAbortError)(failure);
+            if (cancelled && serialOwner === undefined)
+                serial.closeAdmission();
+            const cleanupErrors = [];
+            try {
+                await serialExecutor.finishPreparation(async () => {
+                    const cleanup = await Promise.allSettled([
+                        timers.dispose(),
+                        (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)
+                    ]);
+                    cleanupErrors.push(...cleanup
+                        .filter((result) => result.status === 'rejected')
+                        .map((result) => result.reason));
+                });
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+            if (cancelled && cleanupErrors.length === 0)
+                throw failure;
+            throw new AggregateError([failure, ...cleanupErrors], `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`);
         }
     }
     async discardInstance(activation) {
         const errors = [];
+        try {
+            await this.discardPreparation(activation);
+        }
+        catch (error) {
+            errors.push(error);
+        }
         try {
             await activation.serial.execute(() => (0, spot_closing_1.invokeSpotClosing)(activation.spot.onClosing?.bind(activation.spot), contracts_1.ZLinkSpotCloseReason.ExplicitClose));
         }
@@ -263,12 +303,13 @@ class ZLinkSpotActivationLifecycle {
         }
     }
     async create(meshName, spotType, spotId, request, signal, authority) {
+        (0, abort_1.throwIfAborted)(signal);
         const executionMode = this.options.userSpotExecutionMode?.(meshName, spotType) ??
             contracts_1.ZLinkUserSpotExecutionMode.SpotWide;
         const serial = new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(executionMode === contracts_1.ZLinkUserSpotExecutionMode.SpotWide, spotId);
         const serialExecutor = new spot_serial_executor_1.ZLinkSpotSerialExecutor(serial, executionMode, spotId);
         const actorHandlers = new actors_1.ZLinkSpotActorHandlerRegistryRuntime();
-        const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers);
+        const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers, this.options.providerResolver);
         (0, spot_handler_registry_1.applySpotHandlerRegistrations)(handlers, spotType, {
             actorSendHandlers: this.options.spotActorSendHandlers,
             actorRequestHandlers: this.options.spotActorRequestHandlers,
@@ -370,7 +411,8 @@ class ZLinkSpotActivationLifecycle {
             const cleanupErrors = [];
             try {
                 if (activation !== undefined) {
-                    await this.cleanupActivation(activation, locationClaim.meshName, lifecycleStarted, signal);
+                    if (!lifecycleStarted)
+                        await this.cleanupActivation(activation, locationClaim.meshName, false);
                 }
                 else {
                     const partialCleanup = await Promise.allSettled([
@@ -475,7 +517,7 @@ class ZLinkSpotActivationLifecycle {
         return await this.cleanupActivation(activation, activation.meshName, true, undefined, reason, deadline, true);
     }
     async cleanupFailedIncarnation(activation) {
-        await this.cleanupActivation(activation, activation.meshName, false, undefined, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, true);
+        await this.cleanupActivation(activation, activation.meshName, false, undefined, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, !activation.serialExecutor.isPreparing);
     }
     async dispatchActorPacket(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
         return await this.actorAdmission.dispatchActorPacket(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
@@ -490,30 +532,36 @@ class ZLinkSpotActivationLifecycle {
     }
     async runCreateLifecycle(activation, spotType, request, locationClaim, nativeDispatch, signal) {
         try {
-            await activation.spot.configure?.();
-            nativeDispatch?.configureSubscriptions(activation.handlers.snapshot());
-            await (0, spot_timer_1.addSpotTimerRegistrations)(activation.timers, spotType, activation.spotId, activation.spot, activation.serial, { timerHandlers: this.options.spotTimerHandlers }, {
-                providerResolver: this.options.providerResolver,
-                runtimeEventPublisher: this.options.runtimeEventPublisher,
-                signal
-            });
+            activation.serialExecutor.beginPreparation();
+            this.options.stageActivation?.(activation);
             let createResponse;
-            await activation.serial.execute(async () => {
-                createResponse = await activation.spot.onCreate?.((0, payload_codec_1.wrapFrameworkPayloadMessage)(request, this.options.messageSerializers, (0, payload_codec_1.frameworkPayloadContentType)(request)));
+            await activation.serial.postBarrierTurn(async () => {
+                (0, abort_1.throwIfAborted)(signal);
+                await activation.spot.configure?.();
+                nativeDispatch?.configureSubscriptions(activation.handlers.snapshot());
+                await (0, spot_timer_1.addSpotTimerRegistrations)(activation.timers, spotType, activation.spotId, activation.spot, activation.serial, { timerHandlers: this.options.spotTimerHandlers }, {
+                    providerResolver: this.options.providerResolver,
+                    runtimeEventPublisher: this.options.runtimeEventPublisher,
+                    signal
+                });
+                (0, abort_1.throwIfAborted)(signal);
+                createResponse = await activation.spot.onCreate?.((0, payload_codec_1.wrapFrameworkPayloadMessage)(request, this.options.messageSerializers, (0, payload_codec_1.frameworkPayloadContentType)(request)), signal);
                 if (createResponse?.accepted === false) {
                     return;
                 }
-                await activation.spot.onInitialize?.();
+                (0, abort_1.throwIfAborted)(signal);
+                await activation.spot.onInitialize?.(signal);
             });
+            (0, abort_1.throwIfAborted)(signal);
             if (createResponse?.accepted === false) {
-                await this.cleanupActivation(activation, locationClaim.meshName, false, signal);
+                await this.cleanupActivation(activation, locationClaim.meshName, false);
                 return {
                     spotId: activation.spotId,
                     state: contracts_1.ZLinkSpotCreateState.Rejected,
                     reply: this.decodeCreateReply(createResponse.reply)
                 };
             }
-            this.options.registerActivation(activation);
+            await this.options.registerActivation(activation);
             return {
                 spotId: activation.spotId,
                 state: contracts_1.ZLinkSpotCreateState.Created,
@@ -521,13 +569,17 @@ class ZLinkSpotActivationLifecycle {
             };
         }
         catch (error) {
+            const failure = signal?.aborted === true ? (0, abort_1.createAbortError)() : error;
+            const cancelled = (0, abort_1.isAbortError)(failure);
+            if (cancelled)
+                activation.serial.closeAdmission();
             try {
-                await this.cleanupActivation(activation, locationClaim.meshName, true, signal);
+                await this.cleanupActivation(activation, locationClaim.meshName, !cancelled);
             }
             catch (cleanupError) {
-                throw new AggregateError([error, cleanupError], `Spot '${activation.spotId}' creation cleanup failed.`);
+                throw new AggregateError([failure, cleanupError], `Spot '${activation.spotId}' creation cleanup failed.`);
             }
-            throw error;
+            throw failure;
         }
     }
     async cleanupActivation(activation, locationMeshName, notifyClosing, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline, owningLifecycle = false) {
@@ -544,11 +596,38 @@ class ZLinkSpotActivationLifecycle {
         this.cleanupStates.set(activation, state);
         if (state.inFlight !== undefined)
             return await state.inFlight;
-        state.inFlight = this.runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline, owningLifecycle).finally(() => {
+        let result;
+        const cleanup = async (ownsLifecycle) => {
+            try {
+                result = await this.runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline, ownsLifecycle);
+            }
+            finally {
+                if (activation.serialExecutor.isPreparing) {
+                    activation.serial.closeAdmission();
+                    // The receive pump releases retained payloads when these records finish.
+                    activation.serial.visitPendingApplication((record) => {
+                        record.operation = () => undefined;
+                    });
+                    this.options.discardActivation?.(activation);
+                }
+            }
+        };
+        state.inFlight = (!owningLifecycle && activation.serialExecutor.isPreparing
+            ? activation.serialExecutor.finishPreparation(() => cleanup(true))
+            : cleanup(owningLifecycle))
+            .then(() => result)
+            .finally(() => {
             state.inFlight = undefined;
         });
         return await state.inFlight;
     }
+    async discardPreparation(activation) {
+        if (!activation.serialExecutor.isPreparing)
+            return;
+        // Clear timer generations before opening admission, so an already due
+        // dispatch can finish without invoking application code.
+        await activation.serialExecutor.finishPreparation(() => activation.timers.dispose());
+    }
     async runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline, owningLifecycle = false) {
         const errors = [];
         let closingFailure;
@@ -571,7 +650,9 @@ class ZLinkSpotActivationLifecycle {
             catch (error) {
                 // An OnClosing failure is diagnostic and cleanup continues. It is
                 // returned so host shutdown can classify its teardown outcome.
-                this.options.closeErrorSink?.reportRuntimeTaskException(`spot ${String(activation.spotId)} onClosing`, error);
+                if (reason !== contracts_1.ZLinkSpotCloseReason.HostShutdown) {
+                    this.options.closeErrorSink?.reportRuntimeTaskException(`spot ${String(activation.spotId)} onClosing`, error);
+                }
                 closingFailure = error;
             }
         }
@@ -598,7 +679,12 @@ class ZLinkSpotActivationLifecycle {
             });
         }
         if (!state.nativeDisposed) {
-            await cleanup(() => activation.nativeSpot?.dispose(), () => {
+            await cleanup(async () => {
+                if (reason === contracts_1.ZLinkSpotCloseReason.HostShutdown) {
+                    await this.options.releaseActorMembers?.(locationMeshName, activation.spotId);
+                }
+                await activation.nativeSpot?.dispose();
+            }, () => {
                 state.nativeDisposed = true;
             });
         }
@@ -617,9 +703,11 @@ class ZLinkSpotActivationLifecycle {
                 state.locationReleased = true;
             });
         }
-        if (errors.length === 1)
-            throw errors[0];
-        if (errors.length > 1) {
+        if (errors.length > 0) {
+            if (closingFailure !== undefined)
+                errors.unshift(closingFailure);
+            if (errors.length === 1)
+                throw errors[0];
             throw new AggregateError(errors, `Spot '${activation.spotId}' cleanup failed.`);
         }
         return closingFailure;

package/dist/runtime/spots/spot-actor-admission-coordinator.d.ts

@@ -14,6 +14,7 @@ export declare class ZLinkSpotActorAdmissionCoordinator {
     dispatchActorPacket(origin: ApplicationJobOrigin, activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     attachNativeActorJoinDispatch(activation: ZLinkSpotActivation, nativeSpot: ZLinkBackendSpot | undefined): ZLinkSpotActorJoinDispatch | undefined;
     private dispatchActorPacketInActorTurn;
+    private resolveActor;
     private commitTransferredActorTransaction;
     private replayActorBacklog;
 }

package/dist/runtime/spots/spot-actor-admission-coordinator.js

@@ -12,7 +12,7 @@ class ZLinkSpotActorAdmissionCoordinator {
         this.options = options;
     }
     async dispatchActorPacket(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
-        const handoff = this.options.actorHandoffRuntime?.capture(origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, undefined, messageFollowOrigin, (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) => this.dispatchActorPacketDirect(origin, activation, actorId, replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef));
+        const handoff = this.options.actorHandoffRuntime?.capture(origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, undefined, messageFollowOrigin);
         if (handoff !== undefined)
             return await handoff;
         return await this.dispatchActorPacketDirect(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
@@ -25,9 +25,7 @@ class ZLinkSpotActorAdmissionCoordinator {
             createTopicMessage: requireBackendValueFactory(this.options.createTopicMessage, 'TopicMessage'),
             serial: activation.serial,
             actors: {
-                resolveActor: (actorId) => activation.hasDepartedActor(actorId)
-                    ? undefined
-                    : (activation.resolveJoinedActor(actorId) ?? this.options.actorResolver?.(actorId)),
+                resolveActor: (actorId) => this.resolveActor(activation, actorId),
                 getTarget: () => activation.spot,
                 defaultAccept: false,
                 transfer: this.options.actorTransferRuntime === undefined
@@ -75,20 +73,7 @@ class ZLinkSpotActorAdmissionCoordinator {
      * @internal
      */
     admitActorPacketPrefix(activation, actorId, records) {
-        const terminals = activation.admitActorDurablePrefix(actorId, records.map((record) => ({
-            operation: (executeChild) => record.drain((parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => executeChild((actorSerial) => this.dispatchActorPacketInActorTurn((0, application_job_queue_scope_1.currentApplicationJobOrigin)(), activation, actorSerial, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef))),
-            preparation: record.preparation,
-            workOptions: { payloadBytes: record.payloadBytes }
-        })));
-        const terminal = Promise.allSettled(terminals).then((outcomes) => {
-            const errors = outcomes.flatMap((outcome) => outcome.status === 'rejected' ? [outcome.reason] : []);
-            if (errors.length === 1)
-                throw errors[0];
-            if (errors.length > 1) {
-                throw new AggregateError(errors, `Actor '${actorId}' durable prefix replay failed.`);
-            }
-        });
-        return { terminal };
+        return activation.admitActorPacketPrefix(actorId, records, (actorSerial, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => this.dispatchActorPacketInActorTurn((0, application_job_queue_scope_1.currentApplicationJobOrigin)(), activation, actorSerial, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef));
     }
     dispatchActorPacketInActorTurn(origin, activation, actorSerial, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
         return new spot_actor_packet_dispatch_1.ZLinkSpotActorPacketDispatch({
@@ -96,10 +81,7 @@ class ZLinkSpotActorAdmissionCoordinator {
             spotId: () => String(activation.spotId),
             registry: activation.actorHandlers,
             serial: actorSerial,
-            resolveActor: (targetActorId) => activation.hasDepartedActor(targetActorId)
-                ? undefined
-                : (activation.resolveJoinedActor(targetActorId) ??
-                    this.options.actorResolver?.(targetActorId)),
+            resolveActor: (targetActorId) => this.resolveActor(activation, targetActorId),
             actorLeft: (targetActorId) => activation.hasDepartedActor(targetActorId),
             onDisconnectActor: (actor) => activation.serial.execute(() => activation.spot.onDisconnectActor?.(actor)),
             actorResponseSender: this.options.boundSessionRuntime?.sendActorResponse.bind(this.options.boundSessionRuntime),
@@ -110,6 +92,15 @@ class ZLinkSpotActorAdmissionCoordinator {
             routeToActorJoinPrewarm: this.options.routeToActorJoinPrewarm
         }).dispatch(origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
     }
+    resolveActor(activation, actorId) {
+        if (activation.hasDepartedActor(actorId))
+            return undefined;
+        // The manager owns relocation visibility. Membership alone cannot publish
+        // a staged Actor; resolver absence supports standalone Spot runtimes.
+        return this.options.actorResolver === undefined
+            ? activation.resolveJoinedActor(actorId)
+            : this.options.actorResolver(actorId);
+    }
     async commitTransferredActorTransaction(activation, actor, backlog, sealedSession) {
         const transfer = this.options.actorTransferRuntime;
         let routeSwitchStarted = false;

package/dist/runtime/spots/spot-actor-membership.d.ts

@@ -31,7 +31,6 @@ export declare class ZLinkSpotActorMembership {
     notifyActorLeftAfterTransfer(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     prepareActorLeaveForTransfer(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     commitActorLeaveAfterTransfer(spotId: RoutingId, actorId: string): Promise<void>;
-    restoreActorAfterFailedTransfer(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     beginActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     cancelActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     notifyJoinedActorDisconnected(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<boolean>;

package/dist/runtime/spots/spot-actor-membership.js

@@ -113,14 +113,6 @@ class ZLinkSpotActorMembership {
         const activation = this.requireActivation(spotId);
         await this.runLifecycleOperation(activation, () => activation.serial.execute(() => activation.commitActorDeparture(actorId)));
     }
-    async restoreActorAfterFailedTransfer(spotId, actor, signal) {
-        (0, abort_1.throwIfAborted)(signal);
-        const activation = this.requireActivation(spotId);
-        await this.runLifecycleOperation(activation, () => activation.serial.execute(async () => {
-            activation.cancelActorTransfer(actor.context.actorId);
-            await activation.spot.onJoinedActor(actor);
-        }));
-    }
     async beginActorTransfer(spotId, actorId) {
         const activation = this.requireActivation(spotId);
         await this.runLifecycleOperation(activation, () => activation.serial.execute(() => activation.beginActorTransfer(actorId)));