@zlink-systems/framework 0.25.0 → 0.26.0

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

@@ -20,13 +20,16 @@ export interface ZLinkSpotActorMembershipOptions {
     readonly entrySpotIdProvider?: (meshName: string) => string | undefined;
     readonly spotRouteResolver?: ZLinkSpotRouteResolver;
     readonly actorTransferRuntime?: ZLinkSpotActorTransferRuntime;
+    readonly isSpotClosing?: (activation: ZLinkSpotActivation) => boolean;
 }
 export type ZLinkActorJoinRollback = () => Promise<void> | void;
 export declare class ZLinkSpotActorMembership {
     private readonly options;
     constructor(options: ZLinkSpotActorMembershipOptions);
     admitActorJoin(spotId: RoutingId, actor: ZLinkActor, request: Message, commit: (spot: ZLinkSpot) => Promise<ZLinkActorJoinRollback | void> | ZLinkActorJoinRollback | void, signal?: AbortSignal, leaveSource?: () => Promise<void>, contentType?: string): Promise<ZLinkSpotActorJoinResult>;
+    private admitActorJoinCore;
     leaveActor(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal, meshName?: string): Promise<void>;
+    private leaveActorCore;
     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>;
@@ -35,5 +38,6 @@ export declare class ZLinkSpotActorMembership {
     cancelActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     notifyJoinedActorDisconnected(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<boolean>;
     private requireActivation;
+    private runLifecycleOperation;
     private createActorDispatcher;
 }

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

@@ -5,6 +5,7 @@ const contracts_1 = require("../../contracts");
 const abort_1 = require("../abort");
 const runtime_message_1 = require("../backend/runtime-message");
 const configuration_1 = require("../configuration");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const actors_1 = require("../actors");
 const payload_codec_1 = require("../messaging/payload-codec");
 const routing_id_1 = require("../routing-id");
@@ -16,6 +17,14 @@ class ZLinkSpotActorMembership {
     async admitActorJoin(spotId, actor, request, commit, signal, leaveSource, contentType = 'application/json') {
         (0, abort_1.throwIfAborted)(signal);
         const activation = this.requireActivation(spotId);
+        return await this.runLifecycleOperation(activation, async () => {
+            if (this.options.isSpotClosing?.(activation) === true) {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `User Spot '${String(spotId)}' is closing.`);
+            }
+            return await this.admitActorJoinCore(activation, actor, request, commit, signal, leaveSource, contentType);
+        });
+    }
+    async admitActorJoinCore(activation, actor, request, commit, signal, leaveSource, contentType) {
         const dispatcher = this.createActorDispatcher(activation);
         const transaction = { committed: false };
         let response;
@@ -54,6 +63,9 @@ class ZLinkSpotActorMembership {
     async leaveActor(spotId, actor, signal, meshName) {
         (0, abort_1.throwIfAborted)(signal);
         const activation = this.requireActivation(spotId, meshName);
+        await this.runLifecycleOperation(activation, () => this.leaveActorCore(activation, actor, signal, meshName));
+    }
+    async leaveActorCore(activation, actor, signal, meshName) {
         const localEntryNodeRid = (meshName === undefined ? undefined : this.options.nodeRidProvider?.(meshName)) ??
             this.options.entryNodeRidProvider?.() ??
             this.options.entryNodeRid ??
@@ -109,40 +121,36 @@ class ZLinkSpotActorMembership {
     async notifyActorLeftAfterTransfer(spotId, actor, signal) {
         (0, abort_1.throwIfAborted)(signal);
         const activation = this.requireActivation(spotId);
-        await activation.serial.execute(async () => {
+        await this.runLifecycleOperation(activation, () => activation.serial.execute(async () => {
             activation.beginActorTransfer(actor.context.actorId);
             await activation.spot.onLeaveActor(actor);
             activation.commitActorDeparture(actor.context.actorId);
-        });
+        }));
     }
     async prepareActorLeaveForTransfer(spotId, actor, signal) {
         (0, abort_1.throwIfAborted)(signal);
         const activation = this.requireActivation(spotId);
-        await activation.serial.execute(() => activation.spot.onLeaveActor(actor));
+        await this.runLifecycleOperation(activation, () => activation.serial.execute(() => activation.spot.onLeaveActor(actor)));
     }
     async commitActorLeaveAfterTransfer(spotId, actorId) {
         const activation = this.requireActivation(spotId);
-        await activation.serial.execute(() => activation.commitActorDeparture(actorId));
+        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 activation.serial.execute(async () => {
+        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 activation.serial.execute(() => {
-            activation.beginActorTransfer(actorId);
-        });
+        await this.runLifecycleOperation(activation, () => activation.serial.execute(() => activation.beginActorTransfer(actorId)));
     }
     async cancelActorTransfer(spotId, actorId) {
         const activation = this.requireActivation(spotId);
-        await activation.serial.execute(() => {
-            activation.cancelActorTransfer(actorId);
-        });
+        await this.runLifecycleOperation(activation, () => activation.serial.execute(() => activation.cancelActorTransfer(actorId)));
     }
     async notifyJoinedActorDisconnected(spotId, actor, signal) {
         (0, abort_1.throwIfAborted)(signal);
@@ -164,6 +172,12 @@ class ZLinkSpotActorMembership {
         }
         return activation;
     }
+    async runLifecycleOperation(activation, operation) {
+        const pending = activation.serial.executeLifecycleOperation(operation);
+        return activation.serial.isCurrentTurn
+            ? await activation.serial.currentTurn.yieldFrameworkPromise(pending)
+            : await pending;
+    }
     createActorDispatcher(activation) {
         return new actors_1.ZLinkSpotActorDispatcher({
             registry: activation.actorHandlers,

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

@@ -3,7 +3,7 @@ import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProvider
 import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
 import type { ZLinkEntrySpotActorRequestHandlerRegistration, ZLinkEntrySpotActorSendHandlerRegistration, ZLinkEntrySpotPacketHandlerRegistration, ZLinkEntrySpotSubscriptionHandlerRegistration, ZLinkEntrySpotTimerHandlerRegistration } from '../../contracts/Configuration/RegistrationTypes';
 import type { Message } from '../../contracts/Common/Message';
-import type { ZLinkBackendReceived, ZLinkBackendSpot, ZLinkBackendSpotNode, ZLinkBackendTopicMessage } from '../backend/contracts';
+import type { ZLinkBackendSpot, ZLinkBackendSpotNode, ZLinkBackendTopicMessage } from '../backend/contracts';
 import type { ZLinkDispatchErrorReporter } from '../channels';
 import { ZLinkWorkerRuntime } from '../workers';
 import { type ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
@@ -21,7 +21,6 @@ interface ZLinkEntrySpotActivationOptions {
     readonly actorRequestHandlers?: readonly ZLinkEntrySpotActorRequestHandlerRegistration[];
     readonly nativeSpot: ZLinkBackendSpot;
     readonly nativeNode: ZLinkBackendSpotNode;
-    readonly createReceived: () => ZLinkBackendReceived;
     readonly createTopicMessage: () => ZLinkBackendTopicMessage;
     readonly nodeRid: RoutingId;
     readonly spotNodeName: string;

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

@@ -223,7 +223,6 @@ class ZLinkEntrySpotActivation {
     attachActorJoinDispatch() {
         const dispatch = new spot_actor_join_dispatch_1.ZLinkSpotActorJoinDispatch({
             nativeSpot: this.options.nativeSpot,
-            createReceived: this.options.createReceived,
             createTopicMessage: this.options.createTopicMessage,
             serial: this.serial,
             actors: {

package/dist/runtime/spots/spot-manager-public.js

@@ -51,7 +51,7 @@ class ZLinkPublicSpotManager {
             return false;
         const current = resolved.spot;
         if (this.options.isLocalNode(current.meshName, current.nodeRid)) {
-            const closed = await this.options.coordinator.close(spot, (local) => this.options.local.close(local.meshName, local.spotId, signal), signal, (local) => this.options.local.hasActiveSpot(local.spotId), (local) => this.options.local.canCloseUserSpot(local.meshName, local.spotId));
+            const closed = await this.options.coordinator.close(spot, (local, beginAuthority) => this.options.local.closeUserWithAuthority(local.meshName, local.spotId, beginAuthority, signal), signal);
             if (closed)
                 this.options.resolver()?.invalidate?.(spot.spotId);
             return closed;

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

@@ -19,7 +19,7 @@ interface ZLinkSpotNativeActorJoinAdmissionOptions {
 export declare class ZLinkSpotNativeActorJoinAdmission {
     private readonly options;
     constructor(options: ZLinkSpotNativeActorJoinAdmissionOptions);
-    admit(request: ZLinkBackendActorJoinRequest): Promise<void>;
+    admit(request: ZLinkBackendActorJoinRequest, rejectClosing?: boolean): Promise<void>;
     private decodeNativeActorJoinRequest;
     private reportHandlerException;
 }

package/dist/runtime/spots/spot-native-actor-join-admission.js

@@ -10,7 +10,7 @@ class ZLinkSpotNativeActorJoinAdmission {
     constructor(options) {
         this.options = options;
     }
-    async admit(request) {
+    async admit(request, rejectClosing = false) {
         const actorId = request.info.targetActor.actorId;
         let accepted = false;
         let acceptedActor;
@@ -21,7 +21,7 @@ class ZLinkSpotNativeActorJoinAdmission {
                 throw new Error('Remote actor join requires the two-phase routed transfer protocol.');
             }
             const actor = this.options.resolveActor(actorId);
-            if (actor !== undefined) {
+            if (!rejectClosing && actor !== undefined) {
                 const target = this.options.getTarget();
                 const joinRequest = request.message;
                 const joinPayload = (0, payload_codec_1.wrapFrameworkPayloadMessage)(joinRequest, this.options.messageSerializers);

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkChannelClient, ZLinkFanoutClient, ZLinkMessage, ZLinkMeshNodeDescriptor, ZLinkMessageSerializer, ZLinkSpotPublisherClient } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
@@ -18,9 +19,11 @@ import type { ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
 import type { ZLinkSpotRoutedTransport } from './spot-outbound';
 import type { ZLinkSpotRouteResolver } from './spot-routing-internal';
 import type { ZLinkEntryActorRuntime, ZLinkSpotActorTransferRuntime, ZLinkSpotActorHandoffRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
+import type { ZLinkActivationConcurrency } from '../activation-admission';
 import type { ServiceMessageFollowRecord } from '../foundation/service-stateful-wire-codec';
 import { ApplicationJobQueue } from '../host/application-job-queue';
 export interface ZLinkSpotNodeRuntimeManagerOptions {
+    readonly listenerRecords?: ZLinkListenerRecords;
     readonly registration: ZLinkFrameworkRegistration;
     readonly primaryMeshName?: string;
     readonly backendAdapterFactory: ZLinkBackendAdapterFactory;
@@ -46,10 +49,8 @@ export interface ZLinkSpotNodeRuntimeManagerOptions {
     readonly peerAdmissionSealed?: (meshName: string) => boolean;
     readonly meshRecordDispatcher?: (meshName: string, owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
     readonly messageFollowReceiver?: (record: ServiceMessageFollowRecord) => void;
-    readonly instanceActivationConcurrencyProvider?: (meshName: string) => {
-        readonly active: number;
-        readonly limit: number;
-    };
+    /** MeshNode §5.1 activation admission record; the descriptor projects it for placement. */
+    readonly activationConcurrency?: (meshName: string) => ZLinkActivationConcurrency;
 }
 export declare class ZLinkSpotNodeRuntimeManager {
     private readonly options;
@@ -72,7 +73,6 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private locationAutoConnect?;
     private readonly applicationJobQueue;
     constructor(options: ZLinkSpotNodeRuntimeManagerOptions);
-    createReceived(): import("../backend/runtime-values").ZLinkBackendReceived;
     createTopicMessage(): import("../backend/runtime-values").ZLinkBackendTopicMessage;
     configureLocationAutoConnect(runtime: ZLinkLocationRuntime, stores: ZLinkLocationRuntimeStores, options: ZLinkLocationOptionOverrides, events?: ZLinkLocationEventSink): void;
     startLocationAutoConnect(signal?: AbortSignal): Promise<void>;

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -55,9 +55,6 @@ class ZLinkSpotNodeRuntimeManager {
             options.applicationJobQueue ??
                 new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)());
     }
-    createReceived() {
-        return this.options.backendAdapterFactory.createReceived();
-    }
     createTopicMessage() {
         return this.options.backendAdapterFactory.createTopicMessage();
     }
@@ -236,6 +233,10 @@ class ZLinkSpotNodeRuntimeManager {
                 this.meshNodes.set(spotNodeName, node);
                 this.meshPumps.set(spotNodeName, pump);
                 this.meshCompletions.set(spotNodeName, completions);
+                const listenerEndpoint = node.status().localEndpoint;
+                if (listenerEndpoint.length > 0) {
+                    this.options.listenerRecords?.record('routeMesh', spotNodeName, listenerEndpoint);
+                }
             }
             catch (error) {
                 this.entryActivations.delete(spotNodeName);
@@ -333,13 +334,9 @@ class ZLinkSpotNodeRuntimeManager {
                         };
                     })
                 },
-                activationConcurrency: {
-                    active: this.options.instanceActivationConcurrencyProvider?.(meshName).active ??
-                        current?.activationConcurrency.active ??
-                        0,
-                    limit: this.options.instanceActivationConcurrencyProvider?.(meshName).limit ??
-                        registration.activationConcurrencyLimit ??
-                        128
+                activationConcurrency: this.options.activationConcurrency?.(meshName) ?? {
+                    active: 0,
+                    limit: registration.activationConcurrencyLimit ?? 128
                 },
                 channelWeights: Object.fromEntries(this.serverChannels(meshName).map(([channelName, channel]) => [
                     channelName,
@@ -693,7 +690,6 @@ class ZLinkSpotNodeRuntimeManager {
             entrySpotType: spotNode.entrySpotType,
             nativeSpot: node.entrySpot(),
             nativeNode: node,
-            createReceived: () => this.options.backendAdapterFactory.createReceived(),
             createTopicMessage: () => this.options.backendAdapterFactory.createTopicMessage(),
             nodeRid: String(node.status().routingId),
             spotNodeName,

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

@@ -5,7 +5,6 @@ exports.sendToSpotHandle = sendToSpotHandle;
 exports.requestToSpotHandle = requestToSpotHandle;
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const contracts_1 = require("../../contracts");
-const Errors_1 = require("../../contracts/Errors");
 const submission_result_1 = require("../messaging/submission-result");
 const routing_id_1 = require("../routing-id");
 const configuration_1 = require("../configuration");
@@ -405,26 +404,7 @@ async function requestToSpotHandle(transport, spot, request, options = {}) {
         }
         return transport.requestToSpot(target, request, transportOptions);
     };
-    const resolved = await requireSpotRef(spot, options.signal);
-    try {
-        return await requestResolved(resolved);
-    }
-    catch (error) {
-        if (!shouldRefreshAfterRouteDisconnect(resolved, error)) {
-            throw error;
-        }
-        let refreshed;
-        try {
-            refreshed = await (0, spot_handle_1.refreshSpotHandle)(spot, options.signal);
-        }
-        catch {
-            throw error;
-        }
-        if (isShutdownTargetState(refreshed?.targetNodeState)) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown, `Spot '${String(spot.spotId)}' target host is shutting down.`, false, error);
-        }
-        throw error;
-    }
+    return requestResolved(await requireSpotRef(spot, options.signal));
 }
 async function requireSpotRef(handle, signal) {
     const resolved = await (0, spot_handle_1.resolveSpotHandle)(handle, signal);
@@ -443,14 +423,6 @@ function spotRefToSpotRouteTarget(spot, spotRouterChannelIdForMesh = (meshName)
         targetNodeState: spot.targetNodeState
     };
 }
-function shouldRefreshAfterRouteDisconnect(target, error) {
-    return (target.targetNodeState === contracts_1.ZLinkFrameworkRuntimeState.Serving &&
-        error instanceof Errors_1.ZLinkFrameworkException &&
-        (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected);
-}
-function isShutdownTargetState(state) {
-    return (state === contracts_1.ZLinkFrameworkRuntimeState.Draining || state === contracts_1.ZLinkFrameworkRuntimeState.Stopped);
-}
 function normalizeSpotRefRoutingId(routingId) {
     return (0, routing_id_1.normalizeOpaqueRoutingId)(routingId);
 }

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

@@ -8,6 +8,7 @@ interface ZLinkRoutedActorAdmissionTarget {
 }
 interface ZLinkSpotRoutedActorAdmissionOptions {
     readonly serial: ZLinkSpotSerialTurnExecutor;
+    readonly isSpotClosing?: () => boolean;
     readonly getTarget: () => ZLinkRoutedActorAdmissionTarget;
     readonly defaultAccept: boolean;
     readonly routedActorTransferProvider?: ZLinkRoutedActorTransferProvider;

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

@@ -7,6 +7,7 @@ const payload_codec_1 = require("../messaging/payload-codec");
 const routing_id_1 = require("../routing-id");
 const spot_remote_codec_1 = require("./spot-remote-codec");
 const spot_route_replies_1 = require("./spot-route-replies");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 class ZLinkSpotRoutedActorAdmission {
     options;
     pending = new Map();
@@ -21,6 +22,15 @@ class ZLinkSpotRoutedActorAdmission {
         if (decoded === undefined) {
             return false;
         }
+        if (this.options.isSpotClosing?.() === true) {
+            try {
+                (0, spot_route_replies_1.submitRoutedActorJoinError)(received, decoded, (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `Actor '${decoded.actorId}' target Spot is closing.`));
+            }
+            finally {
+                this.closeDecoded(decoded);
+            }
+            return true;
+        }
         if (decoded.phase === 'admission') {
             await this.admitTransfer(decoded, received);
             return true;

package/dist/runtime/spots/spot-routed-frame-dispatch.d.ts

@@ -3,7 +3,7 @@ import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProvider
 import type { RoutingId } from '../../contracts';
 import type { ActorRef } from '../../contracts/Common/ActorRef';
 import type { ZLinkRemoteActorPacketTarget, ZLinkRemoteBoundSessionTarget } from '../actors';
-import type { ZLinkBackendReceived, ZLinkBackendSpot } from '../backend/contracts';
+import type { ZLinkBackendReceived } from '../backend/contracts';
 import type { ZLinkDispatchErrorReporter } from '../channels';
 import type { ZLinkActorPacketDelivery, ZLinkActorResponseOptions } from './spot-actor-packet-dispatch';
 import type { ZLinkSpotHandlerRegistration } from './spot-handler-registry';
@@ -15,10 +15,9 @@ interface ZLinkRoutedFrameAdmissionTarget {
     onActorJoin?(actorId: string, request: ZLinkMessage): Promise<ZLinkSpotActorJoinResult>;
 }
 interface ZLinkSpotRoutedFrameDispatchOptions {
-    readonly nativeSpot: ZLinkBackendSpot;
-    readonly createReceived: () => ZLinkBackendReceived;
     readonly nativeSpotId: string;
     readonly serial: ZLinkSpotSerialTurnExecutor;
+    readonly isSpotClosing?: () => boolean;
     readonly resolveActor: (actorId: string) => ZLinkActor | undefined;
     readonly getTarget: () => ZLinkRoutedFrameAdmissionTarget & ZLinkSpot;
     readonly defaultAccept: boolean;
@@ -34,11 +33,9 @@ interface ZLinkSpotRoutedFrameDispatchOptions {
     readonly providerResolver?: ZLinkProviderResolver;
     readonly dispatchErrors?: ZLinkDispatchErrorReporter;
     readonly claimApplicationWork?: () => ZLinkApplicationWorkClaim;
-    readonly waitIdle: () => Promise<void>;
 }
 export declare class ZLinkSpotRoutedFrameDispatch {
     private readonly options;
-    private routeDraining;
     private readonly packetHandlers;
     private readonly routedBoundSessionDispatch;
     private readonly actorPacketRelayDispatch;
@@ -46,7 +43,6 @@ export declare class ZLinkSpotRoutedFrameDispatch {
     private readonly routedActorAdmission;
     constructor(options: ZLinkSpotRoutedFrameDispatchOptions);
     configurePacketHandlers(registrations: readonly ZLinkSpotHandlerRegistration[]): void;
-    drain(received?: ZLinkBackendReceived | undefined, retryDeadlineMs?: number): Promise<void>;
     dispatchFromEvent(received: ZLinkBackendReceived): Promise<void>;
     private channelCodecs;
     private dispatch;

package/dist/runtime/spots/spot-routed-frame-dispatch.js

@@ -2,14 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotRoutedFrameDispatch = void 0;
 const spot_remote_route_codec_1 = require("./spot-remote-route-codec");
-const spot_native_flags_1 = require("./spot-native-flags");
 const spot_actor_packet_relay_dispatch_1 = require("./spot-actor-packet-relay-dispatch");
 const spot_route_packet_dispatch_1 = require("./spot-route-packet-dispatch");
 const spot_routed_actor_admission_1 = require("./spot-routed-actor-admission");
 const spot_routed_bound_session_dispatch_1 = require("./spot-routed-bound-session-dispatch");
 class ZLinkSpotRoutedFrameDispatch {
     options;
-    routeDraining = false;
     packetHandlers = new Map();
     routedBoundSessionDispatch;
     actorPacketRelayDispatch;
@@ -42,6 +40,7 @@ class ZLinkSpotRoutedFrameDispatch {
         });
         this.routedActorAdmission = new spot_routed_actor_admission_1.ZLinkSpotRoutedActorAdmission({
             serial: options.serial,
+            isSpotClosing: options.isSpotClosing,
             getTarget: options.getTarget,
             defaultAccept: options.defaultAccept,
             routedActorTransferProvider: options.routedActorTransferProvider,
@@ -61,62 +60,6 @@ class ZLinkSpotRoutedFrameDispatch {
             this.packetHandlers.set(packetName, existing);
         }
     }
-    async drain(received = undefined, retryDeadlineMs = performance.now()) {
-        if (this.routeDraining) {
-            if (received !== undefined) {
-                try {
-                    await this.dispatch(received);
-                }
-                finally {
-                    received.close();
-                }
-            }
-            return;
-        }
-        this.routeDraining = true;
-        try {
-            if (received !== undefined) {
-                try {
-                    await this.dispatch(received);
-                }
-                finally {
-                    received.close();
-                }
-                received = undefined;
-            }
-            for (;;) {
-                received ??= this.options.createReceived();
-                try {
-                    if (!this.options.nativeSpot.recvRoute(received, spot_native_flags_1.ZLINK_RECV_DONT_WAIT)) {
-                        received.close();
-                        await this.options.waitIdle();
-                        return;
-                    }
-                }
-                catch (error) {
-                    if (isRouteRecvRetryable(error)) {
-                        closeReceivedQuietly(received);
-                        if (performance.now() < retryDeadlineMs) {
-                            setTimeout(() => void this.drain(undefined, retryDeadlineMs), 10);
-                        }
-                        return;
-                    }
-                    received.close();
-                    throw error;
-                }
-                try {
-                    await this.dispatch(received);
-                }
-                finally {
-                    received.close();
-                }
-                received = this.options.createReceived();
-            }
-        }
-        finally {
-            this.routeDraining = false;
-        }
-    }
     async dispatchFromEvent(received) {
         try {
             await this.dispatch(received);
@@ -145,18 +88,7 @@ class ZLinkSpotRoutedFrameDispatch {
         if (await this.routePacketDispatch.dispatch(received)) {
             return;
         }
-        await this.routedActorAdmission.admit(received);
+        await this.options.serial.executeLifecycleOperation(() => this.routedActorAdmission.admit(received));
     }
 }
 exports.ZLinkSpotRoutedFrameDispatch = ZLinkSpotRoutedFrameDispatch;
-function isRouteRecvRetryable(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        [201, 202, 204].includes(Number(error.result)));
-}
-function closeReceivedQuietly(received) {
-    try {
-        received.close();
-    }
-    catch { }
-}

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

@@ -1,7 +1,7 @@
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId, ZLinkSpot } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
-import type { ZLinkRemoteActorPacketTarget, ZLinkRemoteBoundSessionTarget, ZLinkDeferredJoinAcceptedRoot } from '../actors';
+import type { ZLinkRemoteActorPacketTarget, ZLinkRemoteBoundSessionTarget, ZLinkDeferredJoinCompletion } from '../actors';
 import type { ZLinkActorHandoffDispatch } from '../actors/actor-handoff';
 import type { ZLinkActorResponseOptions } from './spot-actor-packet-dispatch';
 import type { ZLinkRemoteActorJoinActor, ZLinkRoutedActorTransferProvider } from './spot-remote-codec';
@@ -16,10 +16,8 @@ export interface ZLinkEntryActorRuntime {
     }>;
 }
 export interface ZLinkSpotActorTransferRuntime {
-    prepareDeferredJoinAccepted(actorId: string, operationId: ZLinkActorJoinOperationId, actorRef: ActorRef, rawReply: Uint8Array, replyContentType?: string, signal?: AbortSignal, canonicalInventoryDigest?: string): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    discardDeferredJoinAccepted(root: ZLinkDeferredJoinAcceptedRoot, signal?: AbortSignal): Promise<void>;
-    markDeferredJoinAcceptedCommitted(root: ZLinkDeferredJoinAcceptedRoot, actorRef: ActorRef, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    commitAndDeliverDeferredJoinAccepted(root: ZLinkDeferredJoinAcceptedRoot, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
+    prepareDeferredJoinAccepted(actorId: string, operationId: ZLinkActorJoinOperationId, actorRef: ActorRef, rawReply: Uint8Array, replyContentType?: string): ZLinkDeferredJoinCompletion;
+    deliverDeferredJoinAccepted(completion: ZLinkDeferredJoinCompletion, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<void>;
     getOrCreateRoutedActor(actorId: string, actorType: string, actorRef?: ActorRef, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, actorCreateRequest?: Message, signal?: AbortSignal): Promise<ZLinkRemoteActorJoinActor>;
     materializeRoutedActor: ZLinkRoutedActorTransferProvider;
     commitRoutedActorAuthority(actor: ZLinkActor, sourceActorRef: ActorRef, transferId: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, deadlineAtMs: number, signal?: AbortSignal): Promise<import('../locations/internal-location-contracts').ZLinkAuthoritySnapshot>;

package/dist/runtime/spots/spot-serial-executor.d.ts

@@ -31,6 +31,11 @@ export declare class ZLinkSpotSerialExecutor {
      * ownership turn. Already accepted work remains drainable.
      */
     close(): Promise<void>;
+    /**
+     * Closes the Actor and timer queues. The Spot queue stays open for the Spot
+     * Close lifecycle item that owns it; that Close closes it when it finishes.
+     */
+    closeChildren(): Promise<void>;
     private actorExecutor;
     private actorSerial;
     private timerSerial;

package/dist/runtime/spots/spot-serial-executor.js

@@ -70,6 +70,14 @@ class ZLinkSpotSerialExecutor {
      * ownership turn. Already accepted work remains drainable.
      */
     close() {
+        const children = this.closeChildren();
+        return Promise.all([children, this.spotSerial.close()]).then(() => undefined);
+    }
+    /**
+     * Closes the Actor and timer queues. The Spot queue stays open for the Spot
+     * Close lifecycle item that owns it; that Close closes it when it finishes.
+     */
+    closeChildren() {
         if (this.closePromise !== undefined)
             return this.closePromise;
         this.closing = true;
@@ -79,7 +87,6 @@ class ZLinkSpotSerialExecutor {
         this.timerSerials.clear();
         this.actorExecutors.clear();
         this.closePromise = Promise.all([
-            this.spotSerial.close(),
             ...childSerials.map((serial) => serial.close()),
             ...actorExecutors.map((executor) => executor.close())
         ]).then(() => undefined);

package/dist/runtime/spots/spot-serial-turn-executor.d.ts

@@ -19,6 +19,7 @@ export declare class ZLinkSpotSerialTurnExecutor {
     get currentTurn(): ZLinkSpotSerialTurn | undefined;
     /** Stops new turns while allowing turns accepted before close to complete. */
     close(): Promise<void>;
+    closeAdmission(): void;
     /** Distinguishes a gate-owning turn from a suspended AsyncLocalStorage tail. */
     isActiveTurn(turn: ZLinkSpotSerialTurn, turnId: number): boolean;
     setExecutionBarrier(barrier: ZLinkExecutionBarrier): void;
@@ -43,6 +44,8 @@ export declare class ZLinkSpotSerialTurnExecutor {
      * barrier seal after this turn finishes.
      */
     postBarrierTurn<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
+    /** Holds this Spot's lifecycle FIFO until the full operation result settles. */
+    executeLifecycleOperation<T>(operation: () => Promise<T> | T): Promise<T>;
     private enqueueApplicationTurn;
     private enqueueFrameworkTurn;
     private enqueueContinuationTurn;

package/dist/runtime/spots/spot-serial-turn-executor.js

@@ -39,6 +39,9 @@ class ZLinkSpotSerialTurnExecutor {
     close() {
         return this.scheduler.close();
     }
+    closeAdmission() {
+        this.scheduler.closeAdmission();
+    }
     /** Distinguishes a gate-owning turn from a suspended AsyncLocalStorage tail. */
     isActiveTurn(turn, turnId) {
         return (this.depth > 0 &&
@@ -109,6 +112,10 @@ class ZLinkSpotSerialTurnExecutor {
     postBarrierTurn(operation, workOptions) {
         return this.enqueueFrameworkTurn(operation, workOptions);
     }
+    /** Holds this Spot's lifecycle FIFO until the full operation result settles. */
+    executeLifecycleOperation(operation) {
+        return this.scheduler.submitLifecycleOperation(operation);
+    }
     async enqueueApplicationTurn(operation, workOptions = {}) {
         this.lastActivityAtMs = performance.now();
         let barrierClaim;
@@ -186,13 +193,10 @@ class ZLinkSpotSerialTurnExecutor {
         ]);
     }
     postResume(turn, resume, reject) {
-        const barrier = this.executionBarrier;
-        const resumeClaim = barrier?.tryEnter();
-        if (barrier !== undefined && resumeClaim === undefined) {
+        if (!turn.resumeExecutionClaim()) {
             reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'The yielded Spot turn cannot resume after its execution unit was sealed.'));
             return true;
         }
-        turn.bindExecutionClaim(resumeClaim);
         void this.enqueueContinuationTurn(async () => {
             this.resumedOwnerTurn = turn;
             try {