@zlink-systems/framework 0.25.0 → 0.26.0

package/src/runtime/spots/spot-actor-lifecycle-drain.ts

@@ -53,25 +53,27 @@ export class ZLinkSpotActorLifecycleDrain {
         continue;
       }
       if (actorRef === null || actorRef === undefined) continue;
-      await this.options.serial.execute(() => {
-        const actor = this.options.resolveActor(actorId);
-        if (actor === undefined) {
+      await this.options.serial.executeLifecycleOperation(() =>
+        this.options.serial.execute(() => {
+          const actor = this.options.resolveActor(actorId);
+          if (actor === undefined) {
+            return undefined;
+          }
+          const target = this.options.getTarget();
+          if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_JOINED) {
+            return target.onJoinedActor?.(actor);
+          }
+          if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_LEFT) {
+            return Promise.resolve(target.onLeaveActor?.(actor)).then(() => {
+              this.options.commitActorDeparture?.(actorId);
+            });
+          }
+          if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_DISCONNECTED) {
+            return target.onDisconnectActor?.(actor);
+          }
           return undefined;
-        }
-        const target = this.options.getTarget();
-        if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_JOINED) {
-          return target.onJoinedActor?.(actor);
-        }
-        if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_LEFT) {
-          return Promise.resolve(target.onLeaveActor?.(actor)).then(() => {
-            this.options.commitActorDeparture?.(actorId);
-          });
-        }
-        if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_DISCONNECTED) {
-          return target.onDisconnectActor?.(actor);
-        }
-        return undefined;
-      });
+        })
+      );
     }
   }
 }

package/src/runtime/spots/spot-actor-membership.ts

@@ -11,6 +11,10 @@ import { throwIfAborted } from '../abort';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import { ZLinkConfigurationException } from '../configuration';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import { ZLinkDispatchErrorReporter } from '../channels';
 import { ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME, ZLinkSpotActorDispatcher } from '../actors';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
@@ -37,6 +41,7 @@ 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;
@@ -57,6 +62,36 @@ export class ZLinkSpotActorMembership {
   ): Promise<ZLinkSpotActorJoinResult> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
+    return await this.runLifecycleOperation(activation, async () => {
+      if (this.options.isSpotClosing?.(activation) === true) {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.RequestRejected,
+          `User Spot '${String(spotId)}' is closing.`
+        );
+      }
+      return await this.admitActorJoinCore(
+        activation,
+        actor,
+        request,
+        commit,
+        signal,
+        leaveSource,
+        contentType
+      );
+    });
+  }
+
+  private async admitActorJoinCore(
+    activation: ZLinkSpotActivation,
+    actor: ZLinkActor,
+    request: Message,
+    commit: (
+      spot: ZLinkSpot
+    ) => Promise<ZLinkActorJoinRollback | void> | ZLinkActorJoinRollback | void,
+    signal: AbortSignal | undefined,
+    leaveSource: (() => Promise<void>) | undefined,
+    contentType: string
+  ): Promise<ZLinkSpotActorJoinResult> {
     const dispatcher = this.createActorDispatcher(activation);
     const transaction: {
       rollbackExternal?: ZLinkActorJoinRollback;
@@ -103,6 +138,17 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId, meshName);
+    await this.runLifecycleOperation(activation, () =>
+      this.leaveActorCore(activation, actor, signal, meshName)
+    );
+  }
+
+  private async leaveActorCore(
+    activation: ZLinkSpotActivation,
+    actor: ZLinkActor,
+    signal?: AbortSignal,
+    meshName?: string
+  ): Promise<void> {
     const localEntryNodeRid =
       (meshName === undefined ? undefined : this.options.nodeRidProvider?.(meshName)) ??
       this.options.entryNodeRidProvider?.() ??
@@ -177,11 +223,13 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(async () => {
-      activation.beginActorTransfer(actor.context.actorId);
-      await activation.spot.onLeaveActor(actor);
-      activation.commitActorDeparture(actor.context.actorId);
-    });
+    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(
@@ -191,12 +239,16 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     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: RoutingId, actorId: string): Promise<void> {
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(() => activation.commitActorDeparture(actorId));
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(() => activation.commitActorDeparture(actorId))
+    );
   }
 
   async restoreActorAfterFailedTransfer(
@@ -206,24 +258,26 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(async () => {
-      activation.cancelActorTransfer(actor.context.actorId);
-      await activation.spot.onJoinedActor(actor);
-    });
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(async () => {
+        activation.cancelActorTransfer(actor.context.actorId);
+        await activation.spot.onJoinedActor(actor);
+      })
+    );
   }
 
   async beginActorTransfer(spotId: RoutingId, actorId: string): Promise<void> {
     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: RoutingId, actorId: string): Promise<void> {
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(() => {
-      activation.cancelActorTransfer(actorId);
-    });
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(() => activation.cancelActorTransfer(actorId))
+    );
   }
 
   async notifyJoinedActorDisconnected(
@@ -252,6 +306,16 @@ export class ZLinkSpotActorMembership {
     return activation;
   }
 
+  private async runLifecycleOperation<T>(
+    activation: ZLinkSpotActivation,
+    operation: () => Promise<T> | T
+  ): Promise<T> {
+    const pending = activation.serial.executeLifecycleOperation(operation);
+    return activation.serial.isCurrentTurn
+      ? await activation.serial.currentTurn!.yieldFrameworkPromise(pending)
+      : await pending;
+  }
+
   private createActorDispatcher(activation: ZLinkSpotActivation): ZLinkSpotActorDispatcher {
     return new ZLinkSpotActorDispatcher({
       registry: activation.actorHandlers,

package/src/runtime/spots/spot-entry-activation.ts

@@ -29,7 +29,6 @@ import { routingIdsEqual } from '../routing-id';
 import { ZLinkSpotActorHandlerRegistryRuntime } from '../actors';
 import type {
   ZLinkBackendActorRecvInfo,
-  ZLinkBackendReceived,
   ZLinkBackendSpot,
   ZLinkBackendSpotNode,
   ZLinkBackendTopicMessage
@@ -81,7 +80,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;
@@ -382,7 +380,6 @@ export class ZLinkEntrySpotActivation {
   private attachActorJoinDispatch(): void {
     const dispatch = new ZLinkSpotActorJoinDispatch({
       nativeSpot: this.options.nativeSpot,
-      createReceived: this.options.createReceived,
       createTopicMessage: this.options.createTopicMessage,
       serial: this.serial,
       actors: {

package/src/runtime/spots/spot-manager-public.ts

@@ -100,10 +100,14 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
     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)
+        (local, beginAuthority) =>
+          this.options.local.closeUserWithAuthority(
+            local.meshName,
+            local.spotId,
+            beginAuthority,
+            signal
+          ),
+        signal
       );
       if (closed) this.options.resolver()?.invalidate?.(spot.spotId);
       return closed;

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

@@ -40,7 +40,7 @@ interface ZLinkSpotNativeActorJoinAdmissionOptions {
 export class ZLinkSpotNativeActorJoinAdmission {
   constructor(private readonly options: ZLinkSpotNativeActorJoinAdmissionOptions) {}
 
-  async admit(request: ZLinkBackendActorJoinRequest): Promise<void> {
+  async admit(request: ZLinkBackendActorJoinRequest, rejectClosing = false): Promise<void> {
     const actorId = request.info.targetActor.actorId;
     let accepted = false;
     let acceptedActor: ZLinkActor | undefined;
@@ -51,7 +51,7 @@ export 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 = wrapFrameworkPayloadMessage(

package/src/runtime/spots/spot-node-runtime-manager.ts

@@ -1,3 +1,4 @@
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
@@ -88,6 +89,7 @@ import type {
   ZLinkSpotBoundSessionRuntime
 } from './spot-runtime-ports';
 import { createAbortError } from '../abort';
+import type { ZLinkActivationConcurrency } from '../activation-admission';
 import type { ServiceMessageFollowRecord } from '../foundation/service-stateful-wire-codec';
 import {
   ApplicationJobQueue,
@@ -101,6 +103,7 @@ const ZLINK_SEND_DONT_WAIT = 1;
 const EMPTY_SPOT_METADATA: ReadonlyMap<string, string> = new Map();
 
 export interface ZLinkSpotNodeRuntimeManagerOptions {
+  readonly listenerRecords?: ZLinkListenerRecords;
   readonly registration: ZLinkFrameworkRegistration;
   readonly primaryMeshName?: string;
   readonly backendAdapterFactory: ZLinkBackendAdapterFactory;
@@ -130,10 +133,8 @@ export interface ZLinkSpotNodeRuntimeManagerOptions {
     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 class ZLinkSpotNodeRuntimeManager {
@@ -168,10 +169,6 @@ export class ZLinkSpotNodeRuntimeManager {
       new ApplicationJobQueue(resolveApplicationJobQueueConfiguration());
   }
 
-  createReceived() {
-    return this.options.backendAdapterFactory.createReceived();
-  }
-
   createTopicMessage() {
     return this.options.backendAdapterFactory.createTopicMessage();
   }
@@ -378,6 +375,10 @@ export 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);
         this.publishers.get(spotNodeName)?.close();
@@ -488,15 +489,9 @@ export 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]) => [
@@ -975,7 +970,6 @@ export class ZLinkSpotNodeRuntimeManager {
       entrySpotType: spotNode.entrySpotType,
       nativeSpot: node.entrySpot() as never,
       nativeNode: node as unknown as ZLinkBackendSpotNode,
-      createReceived: () => this.options.backendAdapterFactory.createReceived(),
       createTopicMessage: () => this.options.backendAdapterFactory.createTopicMessage(),
       nodeRid: String(node.status().routingId),
       spotNodeName,

package/src/runtime/spots/spot-outbound.ts

@@ -1,10 +1,8 @@
 import {
   ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException,
-  internalFrameworkErrorKind
+  createInternalFrameworkException
 } from '../framework-errors-internal';
-import { ZLinkFrameworkRuntimeState, ZLinkSpotKind } from '../../contracts';
-import { ZLinkFrameworkException } from '../../contracts/Errors';
+import { ZLinkSpotKind } from '../../contracts';
 import type {
   RoutingId,
   ZLinkChannelClient,
@@ -31,12 +29,7 @@ import { requireZLinkYieldTurn } from '../execution';
 import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import type { ZLinkSpotRouteTarget } from './spot-routing-internal';
 import { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import {
-  resolveSpotHandle,
-  refreshSpotHandle,
-  type SpotHandle,
-  type ResolvedSpotHandle
-} from './spot-handle';
+import { resolveSpotHandle, type SpotHandle, type ResolvedSpotHandle } from './spot-handle';
 
 export interface DefaultZLinkSpotOutboundOptions {
   readonly serial: ZLinkSpotSerialTurnExecutor;
@@ -680,29 +673,7 @@ export async function requestToSpotHandle<TReply = unknown>(
     return transport.requestToSpot<TReply>(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: ResolvedSpotHandle | undefined;
-    try {
-      refreshed = await refreshSpotHandle(spot, options.signal);
-    } catch {
-      throw error;
-    }
-    if (isShutdownTargetState(refreshed?.targetNodeState)) {
-      throw createInternalFrameworkException(
-        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(
@@ -730,20 +701,6 @@ function spotRefToSpotRouteTarget(
   };
 }
 
-function shouldRefreshAfterRouteDisconnect(target: ResolvedSpotHandle, error: unknown): boolean {
-  return (
-    target.targetNodeState === ZLinkFrameworkRuntimeState.Serving &&
-    error instanceof ZLinkFrameworkException &&
-    internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.RouteNotConnected
-  );
-}
-
-function isShutdownTargetState(state: ResolvedSpotHandle['targetNodeState']): boolean {
-  return (
-    state === ZLinkFrameworkRuntimeState.Draining || state === ZLinkFrameworkRuntimeState.Stopped
-  );
-}
-
 function normalizeSpotRefRoutingId(routingId: RoutingId): RoutingId {
   return normalizeOpaqueRoutingId(routingId);
 }

package/src/runtime/spots/spot-routed-actor-admission.ts

@@ -29,6 +29,10 @@ import {
 import { submitRoutedActorJoinError, submitRoutedActorJoinReply } from './spot-route-replies';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import type { ZLinkActorHandoffPacket, ZLinkActorHandoffResult } from '../actors/actor-handoff';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 
 interface ZLinkRoutedActorAdmissionTarget {
   onActorJoin?(actorId: string, request: ZLinkMessage): Promise<ZLinkSpotActorJoinResult>;
@@ -36,6 +40,7 @@ interface ZLinkRoutedActorAdmissionTarget {
 
 interface ZLinkSpotRoutedActorAdmissionOptions {
   readonly serial: ZLinkSpotSerialTurnExecutor;
+  readonly isSpotClosing?: () => boolean;
   readonly getTarget: () => ZLinkRoutedActorAdmissionTarget;
   readonly defaultAccept: boolean;
   readonly routedActorTransferProvider?: ZLinkRoutedActorTransferProvider;
@@ -73,6 +78,21 @@ export class ZLinkSpotRoutedActorAdmission {
     if (decoded === undefined) {
       return false;
     }
+    if (this.options.isSpotClosing?.() === true) {
+      try {
+        submitRoutedActorJoinError(
+          received,
+          decoded,
+          createInternalFrameworkException(
+            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/src/runtime/spots/spot-routed-frame-dispatch.ts

@@ -9,11 +9,10 @@ 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 { ZLinkChannelEnvelopeCodecRegistry } from '../channels/channel-envelope';
 import { decodeRemoteActorPacketRelay } from './spot-remote-route-codec';
-import { ZLINK_RECV_DONT_WAIT } from './spot-native-flags';
 import { ZLinkSpotActorPacketRelayDispatch } from './spot-actor-packet-relay-dispatch';
 import type {
   ZLinkActorPacketDelivery,
@@ -33,10 +32,9 @@ interface ZLinkRoutedFrameAdmissionTarget {
 }
 
 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;
@@ -86,11 +84,9 @@ interface ZLinkSpotRoutedFrameDispatchOptions {
   readonly providerResolver?: ZLinkProviderResolver;
   readonly dispatchErrors?: ZLinkDispatchErrorReporter;
   readonly claimApplicationWork?: () => ZLinkApplicationWorkClaim;
-  readonly waitIdle: () => Promise<void>;
 }
 
 export class ZLinkSpotRoutedFrameDispatch {
-  private routeDraining = false;
   private readonly packetHandlers = new Map<string, ZLinkSpotHandlerRegistration[]>();
   private readonly routedBoundSessionDispatch: ZLinkSpotRoutedBoundSessionDispatch;
   private readonly actorPacketRelayDispatch: ZLinkSpotActorPacketRelayDispatch;
@@ -123,6 +119,7 @@ export class ZLinkSpotRoutedFrameDispatch {
     });
     this.routedActorAdmission = new ZLinkSpotRoutedActorAdmission({
       serial: options.serial,
+      isSpotClosing: options.isSpotClosing,
       getTarget: options.getTarget,
       defaultAccept: options.defaultAccept,
       routedActorTransferProvider: options.routedActorTransferProvider,
@@ -144,61 +141,6 @@ export class ZLinkSpotRoutedFrameDispatch {
     }
   }
 
-  async drain(
-    received: ZLinkBackendReceived | undefined = undefined,
-    retryDeadlineMs = performance.now()
-  ): Promise<void> {
-    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, 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: ZLinkBackendReceived): Promise<void> {
     try {
       await this.dispatch(received);
@@ -234,20 +176,8 @@ export class ZLinkSpotRoutedFrameDispatch {
     if (await this.routePacketDispatch.dispatch(received)) {
       return;
     }
-    await this.routedActorAdmission.admit(received);
+    await this.options.serial.executeLifecycleOperation(() =>
+      this.routedActorAdmission.admit(received)
+    );
   }
 }
-
-function isRouteRecvRetryable(error: unknown): boolean {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    [201, 202, 204].includes(Number((error as { result?: unknown }).result))
-  );
-}
-
-function closeReceivedQuietly(received: ZLinkBackendReceived): void {
-  try {
-    received.close();
-  } catch {}
-}

package/src/runtime/spots/spot-runtime-ports.ts

@@ -10,7 +10,7 @@ import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-con
 import type {
   ZLinkRemoteActorPacketTarget,
   ZLinkRemoteBoundSessionTarget,
-  ZLinkDeferredJoinAcceptedRoot
+  ZLinkDeferredJoinCompletion
 } from '../actors';
 import type { ZLinkActorHandoffDispatch } from '../actors/actor-handoff';
 import type { ZLinkActorResponseOptions } from './spot-actor-packet-dispatch';
@@ -44,26 +44,15 @@ export interface ZLinkSpotActorTransferRuntime {
     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,
+    replyContentType?: string
+  ): ZLinkDeferredJoinCompletion;
+  deliverDeferredJoinAccepted(
+    completion: ZLinkDeferredJoinCompletion,
     actor: ZLinkActor,
     actorRef: ActorRef,
     submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>,
     signal?: AbortSignal
-  ): Promise<ZLinkDeferredJoinAcceptedRoot>;
+  ): Promise<void>;
   getOrCreateRoutedActor(
     actorId: string,
     actorType: string,

package/src/runtime/spots/spot-serial-executor.ts

@@ -107,6 +107,15 @@ export class ZLinkSpotSerialExecutor {
    * ownership turn. Already accepted work remains drainable.
    */
   close(): Promise<void> {
+    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(): Promise<void> {
     if (this.closePromise !== undefined) return this.closePromise;
     this.closing = true;
     const childSerials = [...this.actorSerials.values(), ...this.timerSerials.values()];
@@ -115,7 +124,6 @@ export 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);