@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -62,29 +62,27 @@ export class ZLinkSpotActivationRegistry {
 
   resolve(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
     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: RoutingId): ZLinkSpotActivation | undefined {
     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: string, spotId: RoutingId): boolean {
-    const key = spotActivationKey(meshName, spotId);
-    return !this.staged.has(key) && this.activations.has(key);
+    return this.resolve(meshName, spotId) !== undefined;
   }
 
   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);
+        return this.has(activation.meshName, activation.spotId);
       })
       .map((activation) => String(activation.spotId))
       .sort((left, right) => left.localeCompare(right))
@@ -155,24 +153,38 @@ export class ZLinkSpotActivationRegistry {
     });
   }
 
-  register(activation: ZLinkSpotActivation): void {
+  registerPreparing(activation: ZLinkSpotActivation): void {
+    this.registerIncarnation(activation);
+  }
+
+  register(activation: ZLinkSpotActivation): ZLinkSpotActivation | undefined {
+    return this.registerIncarnation(activation);
+  }
+
+  private registerIncarnation(activation: ZLinkSpotActivation): ZLinkSpotActivation | undefined {
     const key = spotActivationKey(activation.meshName, activation.spotId);
-    if (this.activations.has(key)) {
+    const existing = this.activations.get(key);
+    if (existing !== undefined && existing !== activation) {
       throw createInternalFrameworkException(
         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: string, spotId: RoutingId): void {
     this.staged.add(spotActivationKey(meshName, spotId));
   }
 
-  publish(meshName: string, spotId: RoutingId): void {
-    this.staged.delete(spotActivationKey(meshName, spotId));
+  publish(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
+    const key = spotActivationKey(meshName, spotId);
+    this.staged.delete(key);
+    return this.activations.get(key);
   }
 
   detachRelocated(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined {
@@ -250,7 +262,7 @@ export class ZLinkSpotActivationRegistry {
   ): ZLinkSpotActivationOperation {
     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/src/runtime/spots/spot-activation-state.ts

@@ -16,7 +16,7 @@ import type { ZLinkBackendSpot } from '../backend/contracts';
 import type { ZLinkSpotActorHandlerRegistryRuntime } from '../actors';
 import type { DefaultZLinkSpotHandlerRegistry } from './spot-handler-registry';
 import { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import { ZLinkSpotSerialExecutor } from './spot-serial-executor';
+import { ZLinkSpotSerialExecutor, type ZLinkActorPacketTurnDispatch } from './spot-serial-executor';
 import type { ZLinkSpotTimerRegistry } from './spot-timer';
 import type { ZLinkSpotActorJoinDispatch } from './spot-actor-join-dispatch';
 import { ZLinkExecutionBarrier, type ZLinkExecutionBarrierSeal } from '../execution';
@@ -229,37 +229,30 @@ export class ZLinkSpotActivation {
     if (!this.relocationBoundaryConsumed) return;
     this.relocationBoundaryConsumed = false;
     this.relocationReadyDeferredTurnId = undefined;
-    await this.serial.post(() => this.notifyRelocationReadyCompleted(outcome));
+    await this.serial.postBarrierTurn(() => this.notifyRelocationReadyCompleted(outcome));
   }
 
   async notifyRelocatedBoundary(): Promise<void> {
-    await this.serial.post(() =>
+    await this.serial.postBarrierTurn(() =>
       this.notifyRelocationReadyCompleted(ZLinkSpotRelocationReadyOutcome.Relocated)
     );
   }
 
   executeActor<T>(
     actorId: string,
-    operation: (serial: ZLinkSpotSerialTurnExecutor) => Promise<T> | T
+    operation: (serial: ZLinkSpotSerialTurnExecutor) => Promise<T> | T,
+    workOptions?: import('../execution/serial-execution-queue').ZLinkSerialWorkOptions
   ): Promise<T> {
-    return this.serialExecutor.executeActor(actorId, operation);
+    return this.serialExecutor.executeActor(actorId, operation, workOptions);
   }
 
   /** @internal Restores a non-executing durable prefix into one Actor FIFO. */
-  admitActorDurablePrefix(
+  admitActorPacketPrefix(
     actorId: string,
-    records: readonly {
-      readonly operation: (
-        executeChild: <TChild>(
-          child: (
-            serial: import('./spot-serial-turn-executor').ZLinkSpotSerialTurnExecutor
-          ) => Promise<TChild> | TChild
-        ) => Promise<TChild>
-      ) => Promise<void>;
-      readonly workOptions?: import('../execution/serial-execution-queue').ZLinkSerialWorkOptions;
-    }[]
-  ): readonly Promise<void>[] {
-    return this.serialExecutor.admitActorDurablePrefix(actorId, records);
+    records: readonly import('../actors/actor-handoff').ZLinkActorHandoffPrefixRecord[],
+    dispatch: ZLinkActorPacketTurnDispatch
+  ): import('../actors/actor-handoff').ZLinkActorHandoffPrefixAdmission {
+    return this.serialExecutor.admitActorPacketPrefix(actorId, records, dispatch);
   }
 
   sealExecution(kind: ZLinkExecutionBarrierSeal['kind'] = 'relocation'): ZLinkExecutionBarrierSeal {
@@ -294,7 +287,7 @@ export class ZLinkSpotActivation {
 
   abortRelocation(capture: ZLinkSpotRelocationCapture): boolean {
     if (!this.executionBarrier.isCurrent(capture.seal)) return false;
-    this.timers.abortRelocation(capture.timers);
+    this.timers.abortRelocation();
     return this.abortExecutionSeal(capture.seal);
   }
 

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

@@ -30,7 +30,7 @@ import {
 } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
-import { throwIfAborted } from '../abort';
+import { createAbortError, isAbortError, throwIfAborted } from '../abort';
 import { ZLinkConfigurationException } from '../configuration';
 import {
   ZLinkFrameworkInternalErrorKind,
@@ -70,7 +70,8 @@ import {
 import {
   addSpotTimerRegistrations,
   ZLinkSpotTimerRegistry,
-  type ZLinkTimerClock
+  type ZLinkTimerClock,
+  type ZLinkTimerRelocationState
 } from './spot-timer';
 import { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import { ZLinkSpotSerialExecutor } from './spot-serial-executor';
@@ -101,6 +102,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>
@@ -148,7 +150,9 @@ export interface ZLinkSpotActivationLifecycleOptions {
     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,
@@ -200,6 +204,7 @@ export class ZLinkSpotActivationLifecycle {
     spotId: RoutingId,
     objectGeneration: bigint,
     authorityOwnerGeneration: bigint,
+    restoredTimers: readonly ZLinkTimerRelocationState[],
     signal?: AbortSignal
   ): Promise<ZLinkSpotActivation> {
     const executionMode =
@@ -215,7 +220,10 @@ export class ZLinkSpotActivationLifecycle {
     );
     const serialExecutor = new ZLinkSpotSerialExecutor(serial, executionMode, spotId);
     const actorHandlers = new ZLinkSpotActorHandlerRegistryRuntime();
-    const handlers = new DefaultZLinkSpotHandlerRegistry(actorHandlers);
+    const handlers = new DefaultZLinkSpotHandlerRegistry(
+      actorHandlers,
+      this.options.providerResolver
+    );
     applySpotHandlerRegistrations(
       handlers,
       implementation as unknown as Type<ZLinkSpot>,
@@ -237,6 +245,9 @@ export class ZLinkSpotActivationLifecycle {
       (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 DefaultZLinkSpotOutbound({
       serial,
       channelClient: this.options.channelClient,
@@ -301,20 +312,6 @@ export class ZLinkSpotActivationLifecycle {
         enumerable: false,
         value: context
       });
-      await instance.configure?.();
-      await addSpotTimerRegistrations(
-        timers,
-        implementation as unknown as Type<ZLinkSpot>,
-        spotId,
-        instance as unknown as ZLinkSpot,
-        serial,
-        { timerHandlers: this.options.spotTimerHandlers },
-        {
-          providerResolver: this.options.providerResolver,
-          runtimeEventPublisher: this.options.runtimeEventPublisher,
-          signal
-        }
-      );
       activation = new ZLinkSpotActivation({
         meshName,
         spotId,
@@ -342,9 +339,42 @@ export 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 addSpotTimerRegistrations(
+            timers,
+            implementation as unknown as Type<ZLinkSpot>,
+            spotId,
+            configured as unknown as ZLinkSpot,
+            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 as never, 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
@@ -352,7 +382,7 @@ export class ZLinkSpotActivationLifecycle {
           : [disposeLifecycleHandlers(instance, this.options.detachedTaskRunner)]),
         ...(nativeSpot === undefined ? [] : [Promise.resolve().then(() => nativeSpot.dispose())])
       ]);
-      const cleanupErrors = cleanup
+      const cleanupErrors = [...preparation, ...cleanup]
         .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
         .map((result) => result.reason);
       if (cleanupErrors.length > 0) {
@@ -374,6 +404,7 @@ export class ZLinkSpotActivationLifecycle {
     signal?: AbortSignal,
     serialOwner?: ZLinkSpotActivation
   ): Promise<ZLinkSpotActivation> {
+    throwIfAborted(signal);
     const serial = serialOwner?.serial ?? new ZLinkSpotSerialTurnExecutor(true, spotId);
     const serialExecutor = new ZLinkSpotSerialExecutor(
       serial,
@@ -381,7 +412,10 @@ export class ZLinkSpotActivationLifecycle {
       spotId
     );
     const actorHandlers = new ZLinkSpotActorHandlerRegistryRuntime();
-    const handlers = new DefaultZLinkSpotHandlerRegistry(actorHandlers);
+    const handlers = new DefaultZLinkSpotHandlerRegistry(
+      actorHandlers,
+      this.options.providerResolver
+    );
     const instanceHandlers = new DefaultZLinkInstanceSpotHandlerRegistry(handlers);
     applySpotHandlerRegistrations(handlers, implementation as unknown as Type<ZLinkSpot>, {
       packetHandlers: this.options.spotPacketHandlers
@@ -446,35 +480,52 @@ export class ZLinkSpotActivationLifecycle {
       externalActorCount: () => this.options.actorCountProvider?.(spotId) ?? 0
     });
     try {
-      await instance.configure?.();
-      await addSpotTimerRegistrations(
-        timers,
-        implementation as unknown as Type<ZLinkSpot>,
-        spotId,
-        instance as unknown as ZLinkSpot,
-        serial,
-        { timerHandlers: this.options.spotTimerHandlers },
-        {
-          providerResolver: this.options.providerResolver,
-          runtimeEventPublisher: this.options.runtimeEventPublisher,
-          signal
-        }
-      );
-      await (serialOwner === undefined
-        ? serial.execute(() => instance!.onInitialize?.())
-        : serial.postBarrierTurn(() => instance!.onInitialize?.()));
-      this.options.registerActivation(activation);
+      if (serialOwner === undefined) serialExecutor.beginPreparation();
+      await serial.postBarrierTurn(async () => {
+        throwIfAborted(signal);
+        await instance.configure?.();
+        await addSpotTimerRegistrations(
+          timers,
+          implementation as unknown as Type<ZLinkSpot>,
+          spotId,
+          instance as unknown as ZLinkSpot,
+          serial,
+          { timerHandlers: this.options.spotTimerHandlers },
+          {
+            providerResolver: this.options.providerResolver,
+            runtimeEventPublisher: this.options.runtimeEventPublisher,
+            signal
+          }
+        );
+        throwIfAborted(signal);
+        await instance!.onInitialize?.(signal);
+      });
+      throwIfAborted(signal);
+      await this.options.registerActivation(activation);
       return activation;
     } catch (error) {
-      const cleanup = await Promise.allSettled([
-        timers.dispose(),
-        disposeLifecycleHandlers(instance, this.options.detachedTaskRunner)
-      ]);
-      const cleanupErrors = cleanup
-        .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
-        .map((result) => result.reason);
+      const failure = signal?.aborted === true ? createAbortError() : error;
+      const cancelled = isAbortError(failure);
+      if (cancelled && serialOwner === undefined) serial.closeAdmission();
+      const cleanupErrors: unknown[] = [];
+      try {
+        await serialExecutor.finishPreparation(async () => {
+          const cleanup = await Promise.allSettled([
+            timers.dispose(),
+            disposeLifecycleHandlers(instance, this.options.detachedTaskRunner)
+          ]);
+          cleanupErrors.push(
+            ...cleanup
+              .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+              .map((result) => result.reason)
+          );
+        });
+      } catch (cleanupError) {
+        cleanupErrors.push(cleanupError);
+      }
+      if (cancelled && cleanupErrors.length === 0) throw failure;
       throw new AggregateError(
-        [error, ...cleanupErrors],
+        [failure, ...cleanupErrors],
         `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`
       );
     }
@@ -482,6 +533,11 @@ export class ZLinkSpotActivationLifecycle {
 
   async discardInstance(activation: ZLinkSpotActivation): Promise<void> {
     const errors: unknown[] = [];
+    try {
+      await this.discardPreparation(activation);
+    } catch (error) {
+      errors.push(error);
+    }
     try {
       await activation.serial.execute(() =>
         invokeSpotClosing(
@@ -524,6 +580,7 @@ export class ZLinkSpotActivationLifecycle {
     signal?: AbortSignal,
     authority?: ZLinkNativeSpotAuthority
   ): Promise<ZLinkLocalSpotCreateResult> {
+    throwIfAborted(signal);
     const executionMode =
       this.options.userSpotExecutionMode?.(meshName, spotType) ??
       ZLinkUserSpotExecutionMode.SpotWide;
@@ -533,7 +590,10 @@ export class ZLinkSpotActivationLifecycle {
     );
     const serialExecutor = new ZLinkSpotSerialExecutor(serial, executionMode, spotId);
     const actorHandlers = new ZLinkSpotActorHandlerRegistryRuntime();
-    const handlers = new DefaultZLinkSpotHandlerRegistry(actorHandlers);
+    const handlers = new DefaultZLinkSpotHandlerRegistry(
+      actorHandlers,
+      this.options.providerResolver
+    );
     applySpotHandlerRegistrations(handlers, spotType, {
       actorSendHandlers: this.options.spotActorSendHandlers,
       actorRequestHandlers: this.options.spotActorRequestHandlers,
@@ -678,12 +738,8 @@ export class ZLinkSpotActivationLifecycle {
       const cleanupErrors: unknown[] = [];
       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([
             timers.dispose(),
@@ -853,7 +909,7 @@ export class ZLinkSpotActivationLifecycle {
       undefined,
       ZLinkSpotCloseReason.ExplicitClose,
       undefined,
-      true
+      !activation.serialExecutor.isPreparing
     );
   }
 
@@ -920,59 +976,69 @@ export class ZLinkSpotActivationLifecycle {
     signal?: AbortSignal
   ): Promise<ZLinkLocalSpotCreateResult> {
     try {
-      await activation.spot.configure?.();
-      nativeDispatch?.configureSubscriptions(activation.handlers.snapshot());
-      await 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: ZLinkSpotCreateResponse | undefined;
-      await activation.serial.execute(async () => {
+      await activation.serial.postBarrierTurn(async () => {
+        throwIfAborted(signal);
+        await activation.spot.configure?.();
+        nativeDispatch?.configureSubscriptions(activation.handlers.snapshot());
+        await addSpotTimerRegistrations(
+          activation.timers,
+          spotType,
+          activation.spotId,
+          activation.spot,
+          activation.serial,
+          { timerHandlers: this.options.spotTimerHandlers },
+          {
+            providerResolver: this.options.providerResolver,
+            runtimeEventPublisher: this.options.runtimeEventPublisher,
+            signal
+          }
+        );
+        throwIfAborted(signal);
         createResponse = await activation.spot.onCreate?.(
           wrapFrameworkPayloadMessage(
             request,
             this.options.messageSerializers,
             frameworkPayloadContentType(request)
-          )
+          ),
+          signal
         );
         if (createResponse?.accepted === false) {
           return;
         }
-        await activation.spot.onInitialize?.();
+        throwIfAborted(signal);
+        await activation.spot.onInitialize?.(signal);
       });
+      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: ZLinkSpotCreateState.Rejected,
           reply: this.decodeCreateReply(createResponse.reply)
         };
       }
-      this.options.registerActivation(activation);
+      await this.options.registerActivation(activation);
       return {
         spotId: activation.spotId,
         state: ZLinkSpotCreateState.Created,
         reply: this.decodeCreateReply(createResponse?.reply)
       };
     } catch (error) {
+      const failure = signal?.aborted === true ? createAbortError() : error;
+      const cancelled = 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],
+          [failure, cleanupError],
           `Spot '${activation.spotId}' creation cleanup failed.`
         );
       }
-      throw error;
+      throw failure;
     }
   }
 
@@ -997,20 +1063,48 @@ export 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(() => {
-      state.inFlight = undefined;
-    });
+    let result: unknown;
+    const cleanup = async (ownsLifecycle: boolean) => {
+      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: ZLinkSpotActivation): Promise<void> {
+    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());
+  }
+
   private async runCleanup(
     activation: ZLinkSpotActivation,
     locationMeshName: string,
@@ -1049,10 +1143,12 @@ export 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 !== ZLinkSpotCloseReason.HostShutdown) {
+          this.options.closeErrorSink?.reportRuntimeTaskException(
+            `spot ${String(activation.spotId)} onClosing`,
+            error
+          );
+        }
         closingFailure = error;
       }
     }
@@ -1093,7 +1189,12 @@ export class ZLinkSpotActivationLifecycle {
     }
     if (!state.nativeDisposed) {
       await cleanup(
-        () => activation.nativeSpot?.dispose(),
+        async () => {
+          if (reason === ZLinkSpotCloseReason.HostShutdown) {
+            await this.options.releaseActorMembers?.(locationMeshName, activation.spotId);
+          }
+          await activation.nativeSpot?.dispose();
+        },
         () => {
           state.nativeDisposed = true;
         }
@@ -1121,8 +1222,9 @@ export class ZLinkSpotActivationLifecycle {
         }
       );
     }
-    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;