@zlink-systems/framework 0.21.0 → 0.22.0

package/src/runtime/actors/index.ts

@@ -11,20 +11,14 @@ import type {
   ZLinkActorCreateCall,
   ZLinkActorCreateResult,
   ZLinkActorGetOrCreateCall,
-  ZLinkActorManager,
-} from '../../contracts';
-import {
-  ZLinkEncodedPayload,
-  ZLinkFrameworkException
+  ZLinkActorManager
 } from '../../contracts';
+import { ZLinkEncodedPayload, ZLinkFrameworkException } from '../../contracts';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import { ZLinkMessage } from '../../contracts';
 import { ZLinkConfigurationException } from '../configuration';
 import { throwIfAborted } from '../abort';
-import type {
-  ZLinkBackendActorRef,
-  ZLinkBackendSpotNode
-} from '../backend/contracts';
+import type { ZLinkBackendActorRef, ZLinkBackendSpotNode } from '../backend/contracts';
 import { closeMeshCompletion } from '../backend/mesh-completion-table';
 import {
   captureZLinkSpotSerialTurn,
@@ -39,20 +33,10 @@ export {
   type ZLinkActorClientOptions
 } from './actor-client';
 
-import {
-  encodeFrameworkPayloadMessage
-} from '../messaging/payload-codec';
-export {
-  DefaultZLinkActorContext,
-  ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME
-} from './actor-context';
-import {
-  ZLinkActorCreationCoordinator,
-  type ZLinkActorCreateRequest
-} from './actor-creation';
-export {
-  ZLinkActorSerialExecutor
-} from './actor-mailbox';
+import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
+export { DefaultZLinkActorContext, ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME } from './actor-context';
+import { ZLinkActorCreationCoordinator, type ZLinkActorCreateRequest } from './actor-creation';
+export { ZLinkActorSerialExecutor } from './actor-mailbox';
 export {
   DEFAULT_MESSAGE_FOLLOW_DURATION_MS,
   ZLinkActorHandoffCoordinator,
@@ -164,12 +148,15 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
 
   constructor(private readonly options: ZLinkActorManagerOptions) {
     this.creation = new ZLinkActorCreationCoordinator(options);
-    this.transferredActorRollback = new ZLinkTransferredActorRollbackCoordinator(this.states, options);
+    this.transferredActorRollback = new ZLinkTransferredActorRollbackCoordinator(
+      this.states,
+      options
+    );
   }
 
   create(actorId: string, actorType: string): ZLinkActorCreateCall {
-    return new ZLinkActorCreateCallRuntime(
-      (options, signal) => this.submitCreate(actorId, actorType, true, options, signal)
+    return new ZLinkActorCreateCallRuntime((options, signal) =>
+      this.submitCreate(actorId, actorType, true, options, signal)
     );
   }
 
@@ -184,8 +171,8 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
   }
 
   getOrCreate(actorId: string, actorType: string): ZLinkActorGetOrCreateCall {
-    return new ZLinkActorGetOrCreateCallRuntime(
-      (options, signal) => this.submitCreate(actorId, actorType, false, options, signal)
+    return new ZLinkActorGetOrCreateCallRuntime((options, signal) =>
+      this.submitCreate(actorId, actorType, false, options, signal)
     );
   }
 
@@ -227,10 +214,7 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
     if (node === undefined || completions === undefined) return false;
     const destroyTask = state.getOrStartDestroy(entryNodeRid, async (nativeRef) => {
       if (nativeRef !== undefined) {
-        const completion = await completions.submit(
-          () => node.destroyActor(nativeRef, 0),
-          signal
-        );
+        const completion = await completions.submit(() => node.destroyActor(nativeRef, 0), signal);
         try {
           if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
             //  Classify the (terminal, fine) pair via the shared translator
@@ -284,10 +268,8 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       await disposeLifecycleHandlers(state.actor);
     }
     state.prepareForRemoteReentry();
-    const operation = state.getOrStartCreation(
-      actorType,
-      false,
-      () => this.creation.materializeTransferredActor(
+    const operation = state.getOrStartCreation(actorType, false, () =>
+      this.creation.materializeTransferredActor(
         actorId,
         actorType,
         state,
@@ -339,13 +321,7 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
     requireActorMeshName(meshName);
     this.ensureActorTypeBelongsToMesh(meshName, actorType);
     if (this.options.placementCreate !== undefined) {
-      return await this.options.placementCreate(
-        actorId,
-        actorType,
-        failIfExists,
-        options,
-        signal
-      );
+      return await this.options.placementCreate(actorId, actorType, failIfExists, options, signal);
     }
     const localState = this.states.get(actorId);
     if (localState?.actorType !== undefined && localState.actorType !== actorType) {
@@ -467,15 +443,8 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       this.rememberActorMeshFromType(actorId, actorType);
       const state = this.getOrCreateState(actorId);
       state.setNativeActorRef(nativeRef);
-      const operation = state.getOrStartCreation(
-        actorType,
-        false,
-        () => this.creation.materializeTransferredActor(
-          actorId,
-          actorType,
-          state,
-          undefined
-        )
+      const operation = state.getOrStartCreation(actorType, false, () =>
+        this.creation.materializeTransferredActor(actorId, actorType, state, undefined)
       );
       const result = await operation.task;
       if (result.status !== 'created') {
@@ -487,12 +456,7 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
         if (registry === undefined) {
           throw new ZLinkConfigurationException('Actor transfer registry is not configured.');
         }
-        await registry.restore(
-          transfer.adapterKey,
-          actor,
-          transfer.state,
-          signal
-        );
+        await registry.restore(transfer.adapterKey, actor, transfer.state, signal);
       }
       state.setLocationGeneration(authorityOwnerGeneration);
       state.setJoinedSpot(spotId, undefined, membershipEpoch);
@@ -559,7 +523,11 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
     this.relocationStaged.delete(actorId);
   }
 
-  async getOrCreateActor(actorId: string, actorType: string, signal?: AbortSignal): Promise<ZLinkActor> {
+  async getOrCreateActor(
+    actorId: string,
+    actorType: string,
+    signal?: AbortSignal
+  ): Promise<ZLinkActor> {
     this.rememberActorMeshFromType(actorId, actorType);
     const result = await this.createOrGet(actorId, actorType, false, undefined, signal);
     return requireCreatedActor(result, actorId);
@@ -632,8 +600,8 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
   }
 
   activeActorCount(meshName: string): number {
-    return [...this.states.values()].filter((state) =>
-      state.meshName === meshName && state.actor !== undefined
+    return [...this.states.values()].filter(
+      (state) => state.meshName === meshName && state.actor !== undefined
     ).length;
   }
 
@@ -656,9 +624,8 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       );
     }
     const destroyTask = state.getOrStartDestroy(entryNodeRid, async (actorRef) => {
-      const destroyedActorRef = actorRef === undefined
-        ? undefined
-        : toFrameworkActorRef(actorRef, state.meshName ?? '');
+      const destroyedActorRef =
+        actorRef === undefined ? undefined : toFrameworkActorRef(actorRef, state.meshName ?? '');
       if (actorRef !== undefined) {
         await node.destroyActor(actorRef, 0, destroySignal);
         state.markNativeActorDestroyed(actorRef);
@@ -720,17 +687,8 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       if (request !== undefined && createRequest.nativeRequest !== undefined) {
         state.setCreateRequestPayload(createRequest.nativeRequest.data());
       }
-      const operation = state.getOrStartCreation(
-        actorType,
-        failIfExists,
-        () => this.creation.createActor(
-          actorId,
-          actorType,
-          state,
-          createRequest,
-          claimLocation,
-          signal
-        )
+      const operation = state.getOrStartCreation(actorType, failIfExists, () =>
+        this.creation.createActor(actorId, actorType, state, createRequest, claimLocation, signal)
       );
       if (operation.created) {
         void operation.task.then(
@@ -839,11 +797,9 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       actorId: state.actorId,
       objectGeneration: 1n,
       meshName: state.meshName ?? '',
-      nodeRid: this.options.actorCreatedNodeRidProvider?.()
-        ?? 'local'
+      nodeRid: this.options.actorCreatedNodeRidProvider?.() ?? 'local'
     };
   }
-
 }
 
 interface ZLinkActorCreateCallOptions {
@@ -911,11 +867,14 @@ class ZLinkActorCreateCallRuntime implements ZLinkActorCreateCall {
   private executeOnce(signal?: AbortSignal): Promise<ZLinkActorCreateResult> {
     this.requireMutable();
     this.submitted = true;
-    return this.execute({
-      ...(this.meshNameValue === undefined ? {} : { meshName: this.meshNameValue }),
-      ...(this.requestConfigured ? { request: this.requestValue } : {}),
-      timeoutMs: this.timeoutMsValue
-    }, signal);
+    return this.execute(
+      {
+        ...(this.meshNameValue === undefined ? {} : { meshName: this.meshNameValue }),
+        ...(this.requestConfigured ? { request: this.requestValue } : {}),
+        timeoutMs: this.timeoutMsValue
+      },
+      signal
+    );
   }
 
   private requireMutable(): void {
@@ -993,8 +952,6 @@ async function waitForCreationRetry(signal?: AbortSignal): Promise<void> {
 
 function requireActorMeshName(meshName: string): void {
   if (meshName.length === 0 || meshName !== meshName.trim()) {
-    throw new ZLinkConfigurationException(
-      'Actor RouteMesh name must not be empty or padded.'
-    );
+    throw new ZLinkConfigurationException('Actor RouteMesh name must not be empty or padded.');
   }
 }

package/src/runtime/actors/post-commit-actor-binder.ts

@@ -24,12 +24,14 @@ export class ZLinkPostCommitActorBinder {
     const existing = this.tasks.get(actorRef.actorId);
     if (existing !== undefined) return existing;
     let task!: Promise<void>;
-    task = this.run(actorRef.actorId)
-      .finally(async () => await this.lane.run(() => {
-        if (this.tasks.get(actorRef.actorId) === task) {
-          this.tasks.delete(actorRef.actorId);
-        }
-      }));
+    task = this.run(actorRef.actorId).finally(
+      async () =>
+        await this.lane.run(() => {
+          if (this.tasks.get(actorRef.actorId) === task) {
+            this.tasks.delete(actorRef.actorId);
+          }
+        })
+    );
     this.tasks.set(actorRef.actorId, task);
     return task;
   }
@@ -51,15 +53,13 @@ export class ZLinkPostCommitActorBinder {
         retryDelay.reset();
       } catch (error) {
         this.options.reportError?.(error);
-        if (!await retryDelay.wait(signal)) return;
+        if (!(await retryDelay.wait(signal))) return;
       }
     }
   }
 
   private signal(): AbortSignal | undefined {
-    return typeof this.options.signal === 'function'
-      ? this.options.signal()
-      : this.options.signal;
+    return typeof this.options.signal === 'function' ? this.options.signal() : this.options.signal;
   }
 
   private completeBindCore(actorId: string, actorRef: ActorRef): boolean {

package/src/runtime/actors/post-commit-actor-location.ts

@@ -31,15 +31,17 @@ export class ZLinkPostCommitActorLocation {
     membershipEpoch: bigint,
     ownerNodeGeneration: bigint
   ): void {
-    this.enqueue(actorId, () => this.options.lifecycle.notifyActorJoinedSpot(
-      actorType,
-      actorId,
-      meshName,
-      spotId,
-      spotGeneration,
-      membershipEpoch,
-      ownerNodeGeneration
-    ));
+    this.enqueue(actorId, () =>
+      this.options.lifecycle.notifyActorJoinedSpot(
+        actorType,
+        actorId,
+        meshName,
+        spotId,
+        spotGeneration,
+        membershipEpoch,
+        ownerNodeGeneration
+      )
+    );
   }
 
   leftEventually(
@@ -50,14 +52,16 @@ export class ZLinkPostCommitActorLocation {
     membershipEpoch: bigint,
     ownerNodeGeneration: bigint
   ): void {
-    this.enqueue(actorId, () => this.options.lifecycle.notifyActorLeftSpot(
-      actorType,
-      actorId,
-      entrySpotId,
-      entrySpotGeneration,
-      membershipEpoch,
-      ownerNodeGeneration
-    ));
+    this.enqueue(actorId, () =>
+      this.options.lifecycle.notifyActorLeftSpot(
+        actorType,
+        actorId,
+        entrySpotId,
+        entrySpotGeneration,
+        membershipEpoch,
+        ownerNodeGeneration
+      )
+    );
   }
 
   private enqueue(actorId: string, operation: () => Promise<void>): void {
@@ -69,11 +73,14 @@ export class ZLinkPostCommitActorLocation {
       return;
     }
     let task!: Promise<void>;
-    task = this.run(actorId).finally(async () => await this.lane.run(() => {
-      if (this.tasks.get(actorId) === task) {
-        this.tasks.delete(actorId);
-      }
-    }));
+    task = this.run(actorId).finally(
+      async () =>
+        await this.lane.run(() => {
+          if (this.tasks.get(actorId) === task) {
+            this.tasks.delete(actorId);
+          }
+        })
+    );
     this.tasks.set(actorId, task);
   }
 
@@ -92,7 +99,7 @@ export class ZLinkPostCommitActorLocation {
         retryDelay.reset();
       } catch (error) {
         this.options.reportError?.(error);
-        if (!await retryDelay.wait(this.options.signal)) {
+        if (!(await retryDelay.wait(this.options.signal))) {
           return;
         }
       }

package/src/runtime/actors/spot-actor-dispatch.ts

@@ -1,4 +1,7 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } from '../framework-errors-internal';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import type {
   Type,
   ZLinkActor,
@@ -10,10 +13,7 @@ import type {
   ZLinkSpotActorSendHandler
 } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import {
-  ZLinkFrameworkException,
-  ZLinkMessageMetadataEmpty
-} from '../../contracts';
+import { ZLinkFrameworkException, ZLinkMessageMetadataEmpty } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkConfigurationException } from '../configuration';
 import { readZLinkDecoratorMetadata } from '../../contracts/Handlers/Attributes';
@@ -40,8 +40,9 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
   private readonly packets = new Map<string, ZLinkActorPacketDescriptor>();
 
   addHandler<THandler>(handlerType: Type<THandler>, packetName?: string): this {
-    const metadata = readZLinkDecoratorMetadata(handlerType).find((entry) =>
-      entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
+    const metadata = readZLinkDecoratorMetadata(handlerType).find(
+      (entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest'
+    );
     const resolvedPacketName = packetName ?? metadata?.packetName;
     if (metadata === undefined || resolvedPacketName === undefined) {
       throw new ZLinkConfigurationException(
@@ -49,9 +50,10 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
       );
     }
     return this.addPacket({
-      kind: metadata.kind === 'spotActorSend'
-        ? ZLinkActorPacketKind.Send
-        : ZLinkActorPacketKind.Request,
+      kind:
+        metadata.kind === 'spotActorSend'
+          ? ZLinkActorPacketKind.Send
+          : ZLinkActorPacketKind.Request,
       packetName: resolvedPacketName,
       actorType: Object as unknown as Type<ZLinkActor>,
       handlerType
@@ -79,23 +81,24 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
     if (exact !== undefined) {
       return exact;
     }
-    const wildcard = this.packets.get(packetKey(kind, Object as unknown as Type<ZLinkActor>, packetName));
+    const wildcard = this.packets.get(
+      packetKey(kind, Object as unknown as Type<ZLinkActor>, packetName)
+    );
     if (wildcard !== undefined) {
       return wildcard;
     }
 
     for (const descriptor of this.packets.values()) {
       if (
-        descriptor.kind === kind
-        && descriptor.packetName === packetName
-        && actor instanceof descriptor.actorType
+        descriptor.kind === kind &&
+        descriptor.packetName === packetName &&
+        actor instanceof descriptor.actorType
       ) {
         return descriptor;
       }
     }
     return undefined;
   }
-
 }
 
 export interface ZLinkSpotActorDispatcherOptions {
@@ -138,17 +141,19 @@ export class ZLinkSpotActorDispatcher {
       const descriptor = this.requirePacket(ZLinkActorPacketKind.Send, actor, packetName);
       const message = decode();
       this.options.onHandlerStart?.();
-      await this.invokeHandler<
-        ZLinkSpotActorSendHandler<ZLinkSpot, ZLinkActor, TMessage>,
-        void
-      >(actor, descriptor, (handler) =>
-        runActorHandlerWithDeferredJoins(() =>
-          handler.handle(
-            this.options.spot,
-            actor,
-            this.createContext(packetName, context),
-            message
-          )));
+      await this.invokeHandler<ZLinkSpotActorSendHandler<ZLinkSpot, ZLinkActor, TMessage>, void>(
+        actor,
+        descriptor,
+        (handler) =>
+          runActorHandlerWithDeferredJoins(() =>
+            handler.handle(
+              this.options.spot,
+              actor,
+              this.createContext(packetName, context),
+              message
+            )
+          )
+      );
     });
   }
 
@@ -187,8 +192,14 @@ export class ZLinkSpotActorDispatcher {
     packetName: string,
     request: TRequest,
     context: Partial<ZLinkMessageContext> = {},
-    afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult,
-    beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void
+    afterReply: (
+      reply: TReply,
+      options: ZLinkSpotActorReplyOptionsSnapshot
+    ) => Promise<TResult> | TResult,
+    beforeReply?: (
+      reply: TReply,
+      options: ZLinkSpotActorReplyOptionsSnapshot
+    ) => Promise<void> | void
   ): Promise<TResult> {
     return this.dispatchRequestThenDecoded(
       actor,
@@ -205,8 +216,14 @@ export class ZLinkSpotActorDispatcher {
     packetName: string,
     decode: () => TRequest,
     context: Partial<ZLinkMessageContext> = {},
-    afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult,
-    beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void
+    afterReply: (
+      reply: TReply,
+      options: ZLinkSpotActorReplyOptionsSnapshot
+    ) => Promise<TResult> | TResult,
+    beforeReply?: (
+      reply: TReply,
+      options: ZLinkSpotActorReplyOptionsSnapshot
+    ) => Promise<void> | void
   ): Promise<TResult> {
     return this.execute(async () => {
       const descriptor = this.requirePacket(ZLinkActorPacketKind.Request, actor, packetName);
@@ -217,23 +234,27 @@ export class ZLinkSpotActorDispatcher {
         TResult
       >(actor, descriptor, (handler) =>
         runActorHandlerWithDeferredJoins(
-          () => handler.handle(
-            this.options.spot,
-            actor,
-            this.createContext(packetName, context),
-            request
-          ),
-          (reply) => afterReply(reply, {
-            metadata: new Map<string, string>(),
-            compressPayload: false
-          }),
+          () =>
+            handler.handle(
+              this.options.spot,
+              actor,
+              this.createContext(packetName, context),
+              request
+            ),
+          (reply) =>
+            afterReply(reply, {
+              metadata: new Map<string, string>(),
+              compressPayload: false
+            }),
           beforeReply === undefined
             ? undefined
-            : (reply) => beforeReply(reply, {
-                metadata: new Map<string, string>(),
-                compressPayload: false
-              })
-        ));
+            : (reply) =>
+                beforeReply(reply, {
+                  metadata: new Map<string, string>(),
+                  compressPayload: false
+                })
+        )
+      );
     });
   }
 
@@ -268,10 +289,7 @@ export class ZLinkSpotActorDispatcher {
     });
   }
 
-  commitActorJoin(
-    actor: ZLinkActor,
-    commit: () => Promise<void> | void
-  ): Promise<void> {
+  commitActorJoin(actor: ZLinkActor, commit: () => Promise<void> | void): Promise<void> {
     return this.execute(async () => {
       await commit();
       await this.options.spot.onJoinedActor(actor);
@@ -297,7 +315,9 @@ export class ZLinkSpotActorDispatcher {
   ): ZLinkActorPacketDescriptor {
     const descriptor = this.options.registry.resolvePacket(kind, actor, packetName);
     if (descriptor === undefined) {
-      throw actorDispatchHandlerNotFound(`No Spot actor ${kind} handler is registered for '${packetName}'.`);
+      throw actorDispatchHandlerNotFound(
+        `No Spot actor ${kind} handler is registered for '${packetName}'.`
+      );
     }
     this.ensureActorType(descriptor, actor);
     return descriptor;
@@ -329,8 +349,9 @@ export class ZLinkSpotActorDispatcher {
   }
 
   private execute<T>(operation: () => Promise<T> | T): Promise<T> {
-    const pending = this.options.serial?.execute(operation, this.options.serialWorkOptions)
-      ?? Promise.resolve().then(operation);
+    const pending =
+      this.options.serial?.execute(operation, this.options.serialWorkOptions) ??
+      Promise.resolve().then(operation);
     this.options.onAdmitted?.();
     return pending;
   }
@@ -350,7 +371,11 @@ export class ZLinkSpotActorDispatcher {
   }
 }
 
-function packetKey(kind: ZLinkActorPacketKind, actorType: Type<ZLinkActor>, packetName: string): string {
+function packetKey(
+  kind: ZLinkActorPacketKind,
+  actorType: Type<ZLinkActor>,
+  packetName: string
+): string {
   return `${kind}:${actorType.name}:${packetName}`;
 }
 

package/src/runtime/actors/transferred-actor-rollback.ts

@@ -1,8 +1,5 @@
 import type { ZLinkActor } from '../../contracts';
-import type {
-  ZLinkBackendActorRef,
-  ZLinkBackendMeshNode
-} from '../backend/contracts';
+import type { ZLinkBackendActorRef, ZLinkBackendMeshNode } from '../backend/contracts';
 import { closeMeshCompletion } from '../backend';
 import { RequestResult } from '../backend/runtime-values';
 import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
@@ -60,8 +57,9 @@ export class ZLinkTransferredActorRollbackCoordinator {
     if (this.tasks.has(actor.context.actorId)) {
       return;
     }
-    const task = this.retry(actor, state, node, actorRef)
-      .finally(() => this.tasks.delete(actor.context.actorId));
+    const task = this.retry(actor, state, node, actorRef).finally(() =>
+      this.tasks.delete(actor.context.actorId)
+    );
     this.tasks.set(actor.context.actorId, task);
   }
 
@@ -72,8 +70,11 @@ export class ZLinkTransferredActorRollbackCoordinator {
     actorRef: ZLinkBackendActorRef | undefined
   ): Promise<void> {
     const retryDelay = new ZLinkActorRetryDelay();
-    while (this.states.get(actor.context.actorId) === state && this.options.shutdownSignal?.aborted !== true) {
-      if (!await retryDelay.wait(this.options.shutdownSignal)) return;
+    while (
+      this.states.get(actor.context.actorId) === state &&
+      this.options.shutdownSignal?.aborted !== true
+    ) {
+      if (!(await retryDelay.wait(this.options.shutdownSignal))) return;
       try {
         if (node !== undefined && actorRef !== undefined) {
           await this.destroyNativeActor(node, actorRef);
@@ -95,11 +96,15 @@ export class ZLinkTransferredActorRollbackCoordinator {
     if (completions === undefined) {
       throw new Error('Actor rollback requires a running MeshNode completion table.');
     }
-    const completion = await completions.submit(() => node.destroyActor({
-      nodeRid: actorRef.nodeRid,
-      actorId: actorRef.actorId,
-      generation: actorRef.generation
-    }), signal);
+    const completion = await completions.submit(
+      () =>
+        node.destroyActor({
+          nodeRid: actorRef.nodeRid,
+          actorId: actorRef.actorId,
+          generation: actorRef.generation
+        }),
+      signal
+    );
     try {
       if (completion.terminalResult !== RequestResult.Ok) {
         throw new Error(