@zlink-systems/framework 0.25.0 → 0.26.0

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

@@ -6,7 +6,6 @@ import type { RoutingId, Type, ZLinkSpot, ZLinkSpotInfo } from '../../contracts'
 import type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
 import { ZLinkSpotCreateState, ZLinkSpotCloseReason } from '../../contracts';
 import type { ZLinkSpotActivation } from './spot-activation-state';
-import { ZLinkSpotCloseOccupiedError } from './spot-activation-state';
 import { ZLinkConfigurationException } from '../configuration';
 import { createAbortError } from '../abort';
 import { ZLinkSpotLifecycleMetrics } from './spot-lifecycle-metrics';
@@ -40,7 +39,11 @@ export class ZLinkSpotActivationRegistry {
   private readonly lifecycleMetrics: ZLinkSpotLifecycleMetrics;
   private activeScan: Iterator<ZLinkSpotActivation> | undefined;
 
-  constructor(metrics?: import('../diagnostics').ZLinkRuntimeMetrics) {
+  constructor(
+    metrics?: import('../diagnostics').ZLinkRuntimeMetrics,
+    private readonly isCommittedClose: (meshName: string, spotId: RoutingId) => boolean = () =>
+      false
+  ) {
     this.lifecycleMetrics = new ZLinkSpotLifecycleMetrics(metrics);
   }
 
@@ -55,7 +58,10 @@ export class ZLinkSpotActivationRegistry {
 
   resolve(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
     const key = spotActivationKey(meshName, spotId);
-    return this.closing.has(key) || this.failedClose.has(key) || this.staged.has(key)
+    return this.isCommittedClose(meshName, spotId) ||
+      this.closing.has(key) ||
+      this.failedClose.has(key) ||
+      this.staged.has(key)
       ? undefined
       : this.activations.get(key);
   }
@@ -64,6 +70,7 @@ export class ZLinkSpotActivationRegistry {
     const matches = [...this.activations.values()].filter(
       (activation) =>
         String(activation.spotId) === String(spotId) &&
+        !this.isCommittedClose(activation.meshName, activation.spotId) &&
         !this.staged.has(spotActivationKey(activation.meshName, activation.spotId)) &&
         !this.closing.has(spotActivationKey(activation.meshName, activation.spotId)) &&
         !this.failedClose.has(spotActivationKey(activation.meshName, activation.spotId))
@@ -74,6 +81,7 @@ export class ZLinkSpotActivationRegistry {
   has(meshName: string, spotId: RoutingId): boolean {
     const key = spotActivationKey(meshName, spotId);
     return (
+      !this.isCommittedClose(meshName, spotId) &&
       !this.staged.has(key) &&
       !this.closing.has(key) &&
       !this.failedClose.has(key) &&
@@ -81,22 +89,17 @@ export class ZLinkSpotActivationRegistry {
     );
   }
 
-  canClose(meshName: string, spotId: RoutingId): boolean {
-    const key = spotActivationKey(meshName, spotId);
-    return (
-      !this.staged.has(key) &&
-      !this.closing.has(key) &&
-      !this.failedClose.has(key) &&
-      this.activations.get(key)?.canClose() === true
-    );
-  }
-
   list(meshName: string): readonly ZLinkSpotInfo[] {
     return [...this.activations.values()]
       .filter((activation) => {
         if (activation.meshName !== meshName) return false;
         const key = spotActivationKey(activation.meshName, activation.spotId);
-        return !this.staged.has(key) && !this.closing.has(key) && !this.failedClose.has(key);
+        return (
+          !this.isCommittedClose(meshName, activation.spotId) &&
+          !this.staged.has(key) &&
+          !this.closing.has(key) &&
+          !this.failedClose.has(key)
+        );
       })
       .map((activation) => String(activation.spotId))
       .sort((left, right) => left.localeCompare(right))
@@ -107,6 +110,18 @@ export class ZLinkSpotActivationRegistry {
     return [...this.activations.values()];
   }
 
+  activationForClose(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
+    return this.activations.get(spotActivationKey(meshName, spotId));
+  }
+
+  finishClose(meshName: string, spotId: RoutingId): void {
+    const key = spotActivationKey(meshName, spotId);
+    if (this.activations.delete(key)) this.lifecycleMetrics.closed('user');
+    this.staged.delete(key);
+    this.failedClose.delete(key);
+    this.resolveEmptyWaiters();
+  }
+
   hasActiveActivations(): boolean {
     return this.activations.size > 0;
   }
@@ -215,30 +230,14 @@ export class ZLinkSpotActivationRegistry {
     }
     const operation = {} as ZLinkSpotCloseOperation;
     let completed = false;
-    let occupiedAfterQuiescence = false;
     const ready = Promise.resolve()
       .then(() => close(activation))
       .then(() => {
         completed = true;
       })
-      .catch((error: unknown) => {
-        // The seal's post-quiescence recheck (spot-activation.ts
-        // closeAfterSeal) found a new join and released the seal instead of
-        // closing. The activation is already back to normal operation, so
-        // this is a "did not close" outcome, not a close failure.
-        if (error instanceof ZLinkSpotCloseOccupiedError) {
-          occupiedAfterQuiescence = true;
-          return;
-        }
-        throw error;
-      })
       .finally(() => {
         if (this.closing.get(key) === operation) {
           this.closing.delete(key);
-          if (occupiedAfterQuiescence) {
-            this.resolveEmptyWaiters();
-            return;
-          }
           if (completed || resourcesReleased(activation)) {
             this.activations.delete(key);
             this.staged.delete(key);
@@ -250,7 +249,7 @@ export class ZLinkSpotActivationRegistry {
           this.resolveEmptyWaiters();
         }
       })
-      .then(() => !occupiedAfterQuiescence);
+      .then(() => true);
     Object.assign(operation, { activation, ready, started: true });
     this.closing.set(key, operation);
     return operation;
@@ -263,6 +262,17 @@ export class ZLinkSpotActivationRegistry {
     create: () => Promise<ZLinkLocalSpotCreateResult>
   ): ZLinkSpotActivationOperation {
     const key = spotActivationKey(meshName, spotId);
+    if (this.isCommittedClose(meshName, spotId)) {
+      return {
+        owner: false,
+        ready: Promise.reject(
+          createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.RequestRejected,
+            `Spot '${String(spotId)}' is Closing.`
+          )
+        )
+      };
+    }
     const closing = this.closing.get(key);
     if (closing !== undefined) {
       return {

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

@@ -25,6 +25,7 @@ import type { ZLinkTimerRelocationState } from './spot-timer';
 export type ZLinkSpotActivationDomain =
   | {
       readonly kind: 'user';
+      readonly objectGeneration?: bigint;
       readonly executionMode: ZLinkUserSpotExecutionMode;
       readonly relocationCoordinationMode: ZLinkSpotRelocationCoordinationMode;
     }
@@ -56,19 +57,6 @@ export interface ZLinkSpotRelocationCapture {
   readonly timers: readonly ZLinkTimerRelocationState[];
 }
 
-/**
- * Internal signal that a close seal reached quiescence but the activation
- * became occupied again while it waited (an actor join queued ahead of the
- * close finished after the eager pre-seal occupancy check). This is not a
- * close failure: the seal is released, the Spot stays open, and the caller
- * reports `close(...)` as `false` instead of throwing.
- */
-export class ZLinkSpotCloseOccupiedError extends Error {
-  constructor(spotId: RoutingId) {
-    super(`Spot '${String(spotId)}' became occupied while its close seal reached quiescence.`);
-  }
-}
-
 export class ZLinkSpotActivation {
   readonly meshName: string;
   readonly spotId: RoutingId;
@@ -126,7 +114,7 @@ export class ZLinkSpotActivation {
   }
 
   get objectGeneration(): bigint | undefined {
-    return this.domain.kind === 'instance' ? this.domain.objectGeneration : undefined;
+    return this.domain.objectGeneration;
   }
 
   get executionMode(): ZLinkUserSpotExecutionMode {
@@ -274,8 +262,8 @@ export class ZLinkSpotActivation {
     return this.serialExecutor.admitActorDurablePrefix(actorId, records);
   }
 
-  sealExecution(): ZLinkExecutionBarrierSeal {
-    return this.executionBarrier.seal();
+  sealExecution(drainsYieldedTurns = false): ZLinkExecutionBarrierSeal {
+    return this.executionBarrier.seal(drainsYieldedTurns);
   }
 
   waitForExecutionQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void> {

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

@@ -31,8 +31,11 @@ import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import { throwIfAborted } from '../abort';
 import { ZLinkConfigurationException } from '../configuration';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import type {
-  ZLinkBackendReceived,
   ZLinkBackendSpot,
   ZLinkBackendSpotNode,
   ZLinkBackendTopicMessage
@@ -77,7 +80,7 @@ import type {
 } from './spot-actor-join-dispatch';
 import { ZLinkSpotActorAdmissionCoordinator } from './spot-actor-admission-coordinator';
 import type { ZLinkRouteToActorJoinPrewarm } from './spot-actor-packet-dispatch';
-import { ZLinkSpotActivation, ZLinkSpotCloseOccupiedError } from './spot-activation-state';
+import { ZLinkSpotActivation } from './spot-activation-state';
 import type { ZLinkSpotLocationClaim } from './spot-location-claim';
 import type {
   ZLinkSpotActorHandoffRuntime,
@@ -114,6 +117,7 @@ export interface ZLinkSpotActivationLifecycleOptions {
   readonly channelMeshNameForChannel?: (channelName: string) => string | undefined;
   readonly providerResolver?: ZLinkProviderResolver;
   readonly dispatchErrors?: ZLinkDispatchErrorReporter;
+  readonly closeErrorSink?: import('../diagnostics/dispatch-error-port').ZLinkDispatchErrorSink;
   readonly runtimeEventPublisher?: ZLinkRuntimeEventPublisher;
   readonly workerRuntime: ZLinkWorkerRuntime;
   readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
@@ -123,7 +127,6 @@ export interface ZLinkSpotActivationLifecycleOptions {
     spotId: RoutingId,
     authority?: ZLinkNativeSpotAuthority
   ) => ZLinkBackendSpot | undefined;
-  readonly createReceived?: () => ZLinkBackendReceived;
   readonly createTopicMessage?: () => ZLinkBackendTopicMessage;
   readonly nativeSpotNodeProvider?: (meshName: string) => ZLinkBackendSpotNode | undefined;
   readonly actorResolver?: (actorId: string) => ZLinkActor | undefined;
@@ -139,12 +142,13 @@ export interface ZLinkSpotActivationLifecycleOptions {
     signal?: AbortSignal,
     meshName?: string
   ) => Promise<void>;
-  readonly closeSpot: (
-    meshName: string,
-    spotId: RoutingId,
-    signal?: AbortSignal,
-    reason?: ZLinkSpotCloseReason
+  /** Starts a context Close request after its calling turn has ended. */
+  readonly requestContextClose: (
+    activation: ZLinkSpotActivation,
+    objectGeneration: bigint,
+    signal?: AbortSignal
   ) => Promise<boolean>;
+  readonly isSpotClosing: (activation: ZLinkSpotActivation) => boolean;
   readonly registerActivation: (activation: ZLinkSpotActivation) => void;
   readonly routeToActorJoinPrewarm?: ZLinkRouteToActorJoinPrewarm;
   readonly releaseLocation: (
@@ -173,10 +177,12 @@ export class ZLinkSpotActivationLifecycle {
     {
       closingAttempted: boolean;
       timersDisposed: boolean;
+      serialDisposed: boolean;
       handlersDisposed: boolean;
+      actorDispatchDisposed: boolean;
       nativeDisposed: boolean;
       locationReleased: boolean;
-      inFlight?: Promise<void>;
+      inFlight?: Promise<unknown>;
     }
   >();
 
@@ -259,7 +265,7 @@ export class ZLinkSpotActivationLifecycle {
       providerResolver: this.options.providerResolver,
       runtimeEventPublisher: this.options.runtimeEventPublisher,
       workerRuntime: this.options.workerRuntime,
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(objectGeneration, () => activation)
     };
     const context =
       objectKind === 'user_spot'
@@ -314,6 +320,7 @@ export class ZLinkSpotActivationLifecycle {
           objectKind === 'user_spot'
             ? {
                 kind: 'user',
+                objectGeneration,
                 executionMode,
                 relocationCoordinationMode:
                   this.options.userSpotRelocationCoordinationMode?.(
@@ -398,7 +405,7 @@ export class ZLinkSpotActivationLifecycle {
       providerResolver: this.options.providerResolver,
       runtimeEventPublisher: this.options.runtimeEventPublisher,
       workerRuntime: this.options.workerRuntime,
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(objectGeneration, () => activation)
     });
     instance = await createFreshProviderInstance(
       implementation,
@@ -487,16 +494,6 @@ export class ZLinkSpotActivationLifecycle {
     }
   }
 
-  resourcesReleased(activation: ZLinkSpotActivation): boolean {
-    const state = this.cleanupStates.get(activation);
-    return (
-      state?.timersDisposed === true &&
-      state.handlersDisposed === true &&
-      state.nativeDisposed === true &&
-      state.locationReleased === true
-    );
-  }
-
   async create<TSpot extends ZLinkSpot>(
     meshName: string,
     spotType: Type<TSpot>,
@@ -607,7 +604,7 @@ export class ZLinkSpotActivationLifecycle {
       ensureOperationAllowed: () => activation?.ensureContextOperationAllowed(),
       leaveActor: (actor, contextSignal) =>
         this.options.leaveActor(spotId, actor, contextSignal, meshName),
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(spotGeneration, () => activation)
     });
     try {
       spot = await createFreshProviderInstance(spotType, this.options.providerResolver, context);
@@ -624,6 +621,7 @@ export class ZLinkSpotActivationLifecycle {
         spotId,
         domain: {
           kind: 'user',
+          objectGeneration: spotGeneration,
           executionMode,
           relocationCoordinationMode:
             this.options.userSpotRelocationCoordinationMode?.(meshName, spotType) ??
@@ -738,7 +736,7 @@ export class ZLinkSpotActivationLifecycle {
       ensureOperationAllowed: () => activation?.ensureContextOperationAllowed(),
       leaveActor: (actor, contextSignal) =>
         this.options.leaveActor(spotId, actor, contextSignal, meshName),
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(objectGeneration, () => activation)
     });
     spot = await createFreshProviderInstance(spotType, this.options.providerResolver, context);
     Object.defineProperty(spot, 'context', {
@@ -751,6 +749,7 @@ export class ZLinkSpotActivationLifecycle {
       spotId,
       domain: {
         kind: 'user',
+        objectGeneration,
         executionMode,
         relocationCoordinationMode:
           this.options.userSpotRelocationCoordinationMode?.(meshName, spotType) ??
@@ -777,47 +776,25 @@ export class ZLinkSpotActivationLifecycle {
   }
 
   private contextClose(
-    meshName: string,
-    spotId: RoutingId,
+    objectGeneration: bigint,
     activationProvider: () => ZLinkSpotActivation | undefined
   ): (signal?: AbortSignal) => Promise<boolean> {
-    return async (signal) => {
+    return (signal) => {
       const activation = activationProvider();
-      // Native callbacks can cross a promise boundary that does not retain
-      // the serial turn context. Queue the close before calling the manager
-      // so the callback never waits for work behind its own serial turn.
-      if (activation?.serial.isExecuting === true && !activation.serial.isCurrentTurn) {
-        activation.requestClose();
-        const retry = activation.serial.post(() =>
-          this.options.closeSpot(meshName, spotId, signal)
+      if (activation === undefined) {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.InvalidOperation,
+          'Spot context Close requires its active generation.'
         );
-        this.options.detachedTaskRunner?.runDetached(`spot close ${String(spotId)}`, async () => {
-          await retry;
-        });
-        if (this.options.detachedTaskRunner === undefined) {
-          void retry.catch(() => undefined);
-        }
-        return true;
       }
-      return await this.options.closeSpot(meshName, spotId, signal);
+      return this.options.requestContextClose(activation, objectGeneration, signal);
     };
   }
 
-  async close(
-    activation: ZLinkSpotActivation,
-    signal?: AbortSignal,
-    reason = ZLinkSpotCloseReason.ExplicitClose
-  ): Promise<void> {
-    const seal = activation.sealExecution();
-    await this.closeAfterSeal(activation, seal, signal, reason);
-  }
-
-  async closeAfterSeal(
+  async sealForClose(
     activation: ZLinkSpotActivation,
     seal: import('../execution').ZLinkExecutionBarrierSeal,
-    signal?: AbortSignal,
-    reason = ZLinkSpotCloseReason.ExplicitClose,
-    deadline?: Date
+    signal?: AbortSignal
   ): Promise<void> {
     try {
       await activation.waitForExecutionQuiescence(seal, signal);
@@ -825,19 +802,26 @@ export class ZLinkSpotActivationLifecycle {
       activation.abortExecutionSeal(seal);
       throw error;
     }
-    // The eager occupancy check that authorized this seal (startClose ->
-    // canClose()) ran before quiescence, so it can miss an actor join that
-    // was already queued on the serial executor at that moment. Recheck now
-    // that every turn admitted before the seal has finished, and release the
-    // seal instead of closing an occupied Spot.
-    if (!activation.canClose(reason)) {
-      activation.abortExecutionSeal(seal);
-      throw new ZLinkSpotCloseOccupiedError(activation.spotId);
-    }
     if (!activation.commitExecutionSeal(seal)) {
       throw new Error(`Spot '${String(activation.spotId)}' close seal is stale.`);
     }
-    await this.cleanupActivation(activation, activation.meshName, true, signal, reason, deadline);
+  }
+
+  /** Returns the OnClosing failure, which cleanup records and does not rethrow. */
+  async cleanupClosedActivation(
+    activation: ZLinkSpotActivation,
+    reason = ZLinkSpotCloseReason.ExplicitClose,
+    deadline?: Date
+  ): Promise<unknown> {
+    return await this.cleanupActivation(
+      activation,
+      activation.meshName,
+      true,
+      undefined,
+      reason,
+      deadline,
+      true
+    );
   }
 
   async dispatchActorPacket(
@@ -961,13 +945,16 @@ export class ZLinkSpotActivationLifecycle {
     notifyClosing: boolean,
     signal?: AbortSignal,
     reason = ZLinkSpotCloseReason.ExplicitClose,
-    deadline?: Date
-  ): Promise<void> {
+    deadline?: Date,
+    owningLifecycle = false
+  ): Promise<unknown> {
     throwIfAborted(signal);
     const state = this.cleanupStates.get(activation) ?? {
       closingAttempted: false,
       timersDisposed: false,
+      serialDisposed: false,
       handlersDisposed: false,
+      actorDispatchDisposed: false,
       nativeDisposed: false,
       locationReleased: false
     };
@@ -979,7 +966,8 @@ export class ZLinkSpotActivationLifecycle {
       notifyClosing,
       reason,
       state,
-      deadline
+      deadline,
+      owningLifecycle
     ).finally(() => {
       state.inFlight = undefined;
     });
@@ -994,13 +982,17 @@ export class ZLinkSpotActivationLifecycle {
     state: {
       closingAttempted: boolean;
       timersDisposed: boolean;
+      serialDisposed: boolean;
       handlersDisposed: boolean;
+      actorDispatchDisposed: boolean;
       nativeDisposed: boolean;
       locationReleased: boolean;
     },
-    deadline?: Date
-  ): Promise<void> {
+    deadline?: Date,
+    owningLifecycle = false
+  ): Promise<unknown> {
     const errors: unknown[] = [];
+    let closingFailure: unknown;
     const cleanup = async (operation: () => Promise<void> | void, completed: () => void) => {
       try {
         await operation();
@@ -1011,10 +1003,21 @@ export class ZLinkSpotActivationLifecycle {
     };
     if (notifyClosing && !state.closingAttempted) {
       state.closingAttempted = true;
-      await cleanup(
-        () => invokeSpotClosing(activation.spot.onClosing?.bind(activation.spot), reason, deadline),
-        () => undefined
-      );
+      try {
+        // OnClosing is user code: it runs as a Framework turn through the
+        // execution gate while the Close lifecycle item keeps its FIFO slot.
+        await activation.serial.postBarrierTurn(() =>
+          invokeSpotClosing(activation.spot.onClosing?.bind(activation.spot), reason, deadline)
+        );
+      } 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
+        );
+        closingFailure = error;
+      }
     }
     if (!state.timersDisposed) {
       await cleanup(
@@ -1024,10 +1027,17 @@ export class ZLinkSpotActivationLifecycle {
         }
       );
     }
-    await cleanup(
-      () => activation.serialExecutor.close(),
-      () => undefined
-    );
+    if (!state.serialDisposed && state.timersDisposed) {
+      await cleanup(
+        () =>
+          owningLifecycle
+            ? activation.serialExecutor.closeChildren()
+            : activation.serialExecutor.close(),
+        () => {
+          state.serialDisposed = true;
+        }
+      );
+    }
     if (!state.handlersDisposed) {
       await cleanup(
         () => disposeLifecycleHandlers(activation.spot),
@@ -1036,11 +1046,15 @@ export class ZLinkSpotActivationLifecycle {
         }
       );
     }
-    if (!state.nativeDisposed) {
+    if (!state.actorDispatchDisposed) {
       await cleanup(
         () => activation.actorDispatch?.dispose(),
-        () => undefined
+        () => {
+          state.actorDispatchDisposed = true;
+        }
       );
+    }
+    if (!state.nativeDisposed) {
       await cleanup(
         () => activation.nativeSpot?.dispose(),
         () => {
@@ -1048,7 +1062,14 @@ export class ZLinkSpotActivationLifecycle {
         }
       );
     }
-    if (!state.locationReleased) {
+    if (
+      !state.locationReleased &&
+      state.timersDisposed &&
+      state.serialDisposed &&
+      state.handlersDisposed &&
+      state.actorDispatchDisposed &&
+      state.nativeDisposed
+    ) {
       await cleanup(
         () => this.options.releaseLocation(activation, locationMeshName, activation.spotId),
         () => {
@@ -1060,6 +1081,7 @@ export class ZLinkSpotActivationLifecycle {
     if (errors.length > 1) {
       throw new AggregateError(errors, `Spot '${activation.spotId}' cleanup failed.`);
     }
+    return closingFailure;
   }
 
   private decodeCreateReply(reply: unknown): unknown {

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

@@ -30,11 +30,11 @@ type AdmissionOptions = Pick<
   | 'locationClaim'
   | 'messageSerializers'
   | 'nativeSpotNodeProvider'
-  | 'createReceived'
   | 'createTopicMessage'
   | 'providerResolver'
   | 'runtimeEventPublisher'
   | 'routeToActorJoinPrewarm'
+  | 'isSpotClosing'
 >;
 
 export class ZLinkSpotActorAdmissionCoordinator {
@@ -92,12 +92,12 @@ export class ZLinkSpotActorAdmissionCoordinator {
     if (nativeSpot === undefined) return undefined;
     const nativeDispatch = new ZLinkSpotActorJoinDispatch({
       nativeSpot,
-      createReceived: requireBackendValueFactory(this.options.createReceived, 'Received'),
       createTopicMessage: requireBackendValueFactory(
         this.options.createTopicMessage,
         'TopicMessage'
       ),
       serial: activation.serial,
+      isSpotClosing: () => this.options.isSpotClosing(activation),
       actors: {
         resolveActor: (actorId) =>
           activation.hasDepartedActor(actorId)

package/src/runtime/spots/spot-actor-join-dispatch.ts

@@ -11,7 +11,6 @@ import { ZLinkBackendSpotDispatchEvent } from '../backend/contracts';
 import type {
   ZLinkBackendActorRef,
   ZLinkBackendActorRecvInfo,
-  ZLinkBackendReceived,
   ZLinkBackendSpot,
   ZLinkBackendTopicMessage
 } from '../backend/contracts';
@@ -92,9 +91,9 @@ export interface ZLinkDetachedTaskRunner {
 
 interface ZLinkSpotActorJoinDispatchOptions {
   readonly nativeSpot: ZLinkBackendSpot;
-  readonly createReceived: () => ZLinkBackendReceived;
   readonly createTopicMessage: () => ZLinkBackendTopicMessage;
   readonly serial: ZLinkSpotSerialTurnExecutor;
+  readonly isSpotClosing?: () => boolean;
   readonly actors: ZLinkSpotActorAdmissionRuntime;
   readonly packets?: ZLinkSpotActorPacketRuntime;
   readonly boundSessionRuntime?: ZLinkSpotBoundSessionRuntime;
@@ -148,10 +147,9 @@ export class ZLinkSpotActorJoinDispatch {
       dispatchErrors: options.dispatchErrors
     });
     this.routedFrames = new ZLinkSpotRoutedFrameDispatch({
-      nativeSpot: options.nativeSpot,
-      createReceived: options.createReceived,
       nativeSpotId: this.nativeSpotId,
       serial: options.serial,
+      isSpotClosing: options.isSpotClosing,
       resolveActor: actors.resolveActor,
       getTarget: () => actors.getTarget() as ZLinkActorJoinAdmissionTarget & ZLinkSpot,
       defaultAccept: actors.defaultAccept,
@@ -189,8 +187,7 @@ export class ZLinkSpotActorJoinDispatch {
       messageSerializers: options.messageSerializers,
       providerResolver: options.providerResolver,
       dispatchErrors: options.dispatchErrors,
-      claimApplicationWork: options.claimApplicationWork,
-      waitIdle: waitSpotDispatchIdle
+      claimApplicationWork: options.claimApplicationWork
     });
     this.subscriptions = new ZLinkSpotSubscriptionDispatch({
       nativeSpot: options.nativeSpot,
@@ -309,7 +306,9 @@ export class ZLinkSpotActorJoinDispatch {
         await waitSpotDispatchIdle();
         return;
       }
-      await this.nativeActorJoinAdmission.admit(request);
+      await this.options.serial.executeLifecycleOperation(() =>
+        this.nativeActorJoinAdmission.admit(request, this.options.isSpotClosing?.() === true)
+      );
     }
   }
 }