@zlink-systems/framework 0.21.0 → 0.23.0

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

@@ -18,7 +18,8 @@ import { ZLinkSpotActorPacketDispatch } from './spot-actor-packet-dispatch';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import type { ZLinkNativeActorJoinSnapshot } from './spot-runtime-ports';
 
-type AdmissionOptions = Pick<ZLinkSpotActivationLifecycleOptions,
+type AdmissionOptions = Pick<
+  ZLinkSpotActivationLifecycleOptions,
   | 'actorHandoffRuntime'
   | 'admission'
   | 'actorResolver'
@@ -57,7 +58,12 @@ export class ZLinkSpotActorAdmissionCoordinator {
       fallbackActorRef,
       undefined,
       messageFollowOrigin,
-      (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) =>
+      (
+        replayedParts,
+        replayReturnResponse,
+        replayRemoteBoundSessionTarget,
+        replayFallbackActorRef
+      ) =>
         this.dispatchActorPacketDirect(
           activation,
           actorId,
@@ -87,21 +93,29 @@ export class ZLinkSpotActorAdmissionCoordinator {
     const nativeDispatch = new ZLinkSpotActorJoinDispatch({
       nativeSpot,
       createReceived: requireBackendValueFactory(this.options.createReceived, 'Received'),
-      createTopicMessage: requireBackendValueFactory(this.options.createTopicMessage, 'TopicMessage'),
+      createTopicMessage: requireBackendValueFactory(
+        this.options.createTopicMessage,
+        'TopicMessage'
+      ),
       serial: activation.serial,
       actors: {
-        resolveActor: (actorId) => activation.hasDepartedActor(actorId)
-          ? undefined
-          : activation.resolveJoinedActor(actorId) ?? this.options.actorResolver?.(actorId),
+        resolveActor: (actorId) =>
+          activation.hasDepartedActor(actorId)
+            ? undefined
+            : (activation.resolveJoinedActor(actorId) ?? this.options.actorResolver?.(actorId)),
         getTarget: () => activation.spot,
         defaultAccept: false,
-        transfer: this.options.actorTransferRuntime === undefined ? { kind: 'disabled' } : {
-          kind: 'enabled',
-          runtime: this.options.actorTransferRuntime
-        },
+        transfer:
+          this.options.actorTransferRuntime === undefined
+            ? { kind: 'disabled' }
+            : {
+                kind: 'enabled',
+                runtime: this.options.actorTransferRuntime
+              },
         commitNativeActor: (actor) => this.commitNativeActorTransaction(activation, actor),
         commitActorDeparture: (actorId) => activation.commitActorDeparture(actorId),
-        commitTransferredActor: (actor, backlog) => this.commitTransferredActorTransaction(activation, actor, backlog)
+        commitTransferredActor: (actor, backlog) =>
+          this.commitTransferredActorTransaction(activation, actor, backlog)
       },
       packets: {
         handle: (delivery) =>
@@ -116,22 +130,31 @@ export class ZLinkSpotActorAdmissionCoordinator {
         bindRemoteSession: (actor, sourceNodeRid, sourceSessionRid) => {
           const node = this.options.nativeSpotNodeProvider?.(activation.meshName);
           if (node === undefined || routingIdsEqual(sourceNodeRid, node.routingId)) return;
-          const target = this.options.boundSessionRuntime?.resolveRemoteBoundSessionTarget(sourceNodeRid, sourceSessionRid);
+          const target = this.options.boundSessionRuntime?.resolveRemoteBoundSessionTarget(
+            sourceNodeRid,
+            sourceSessionRid
+          );
           if (target !== undefined) {
-            this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(actor.actorId, target);
+            this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(
+              actor.actorId,
+              target
+            );
           }
           node.bindRemoteActorSession(actor, sourceNodeRid, sourceSessionRid);
         },
         replyNoBind: (info, parts, result) =>
-          this.options.nativeSpotNodeProvider?.(activation.meshName)?.replyActorNoBind(info, parts, result)
+          this.options
+            .nativeSpotNodeProvider?.(activation.meshName)
+            ?.replyActorNoBind(info, parts, result)
       },
       boundSessionRuntime: this.options.boundSessionRuntime,
       messageSerializers: this.options.messageSerializers,
       providerResolver: this.options.providerResolver,
       dispatchErrors: this.options.dispatchErrors,
-      claimApplicationWork: this.options.admission === undefined
-        ? undefined
-        : () => this.options.admission!.claim(activation.meshName, 'Spot route dispatch'),
+      claimApplicationWork:
+        this.options.admission === undefined
+          ? undefined
+          : () => this.options.admission!.claim(activation.meshName, 'Spot route dispatch'),
       detachedTaskRunner: this.options.detachedTaskRunner
     });
     nativeDispatch.attach();
@@ -148,7 +171,7 @@ export class ZLinkSpotActorAdmissionCoordinator {
     fallbackActorRef?: ActorRef,
     requestTerminal?: (response: unknown) => Promise<void> | void
   ): Promise<unknown> {
-    return activation.executeActor(actorId, actorSerial =>
+    return activation.executeActor(actorId, (actorSerial) =>
       this.dispatchActorPacketInActorTurn(
         activation,
         actorSerial,
@@ -176,28 +199,29 @@ export class ZLinkSpotActorAdmissionCoordinator {
   ): ZLinkActorHandoffPrefixAdmission {
     const terminals = activation.admitActorDurablePrefix(
       actorId,
-      records.map(record => ({
-        operation: executeChild => record.drain((
-            parts,
-            returnResponse,
-            remoteBoundSessionTarget,
-            fallbackActorRef
-          ) => executeChild(actorSerial => this.dispatchActorPacketInActorTurn(
-            activation,
-            actorSerial,
-            actorId,
-            parts,
-            returnResponse,
-            remoteBoundSessionTarget,
-            fallbackActorRef
-          ))),
+      records.map((record) => ({
+        operation: (executeChild) =>
+          record.drain((parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) =>
+            executeChild((actorSerial) =>
+              this.dispatchActorPacketInActorTurn(
+                activation,
+                actorSerial,
+                actorId,
+                parts,
+                returnResponse,
+                remoteBoundSessionTarget,
+                fallbackActorRef
+              )
+            )
+          ),
         preparation: record.preparation,
         workOptions: { payloadBytes: record.payloadBytes }
       }))
     );
-    const terminal = Promise.allSettled(terminals).then(outcomes => {
-      const errors = outcomes.flatMap(outcome =>
-        outcome.status === 'rejected' ? [outcome.reason] : []);
+    const terminal = Promise.allSettled(terminals).then((outcomes) => {
+      const errors = outcomes.flatMap((outcome) =>
+        outcome.status === 'rejected' ? [outcome.reason] : []
+      );
       if (errors.length === 1) throw errors[0];
       if (errors.length > 1) {
         throw new AggregateError(errors, `Actor '${actorId}' durable prefix replay failed.`);
@@ -217,32 +241,38 @@ export class ZLinkSpotActorAdmissionCoordinator {
     requestTerminal?: (response: unknown) => Promise<void> | void
   ): Promise<unknown> {
     return new ZLinkSpotActorPacketDispatch({
-        spot: activation.spot,
-        spotId: () => String(activation.spotId),
-        registry: activation.actorHandlers,
-        serial: actorSerial,
-        resolveActor: (targetActorId) => activation.hasDepartedActor(targetActorId)
+      spot: activation.spot,
+      spotId: () => String(activation.spotId),
+      registry: activation.actorHandlers,
+      serial: actorSerial,
+      resolveActor: (targetActorId) =>
+        activation.hasDepartedActor(targetActorId)
           ? undefined
-          : activation.resolveJoinedActor(targetActorId) ?? this.options.actorResolver?.(targetActorId),
-        actorLeft: (targetActorId) => activation.hasDepartedActor(targetActorId),
-        onRemoteBoundSessionTarget: (targetActorId, target) =>
-          this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(targetActorId, target),
-        onDisconnectActor: (actor) =>
-          activation.serial.execute(() => activation.spot.onDisconnectActor?.(actor)),
-        actorResponseSender: this.options.boundSessionRuntime?.sendActorResponse.bind(this.options.boundSessionRuntime),
-        actorErrorSender: this.options.boundSessionRuntime?.sendActorError.bind(this.options.boundSessionRuntime),
-        providerResolver: this.options.providerResolver,
-        messageSerializers: this.options.messageSerializers,
-        dispatchErrors: this.options.dispatchErrors,
-        routeToActorJoinPrewarm: this.options.routeToActorJoinPrewarm
-      }).dispatch(
-        actorId,
-        parts,
-        returnResponse,
-        remoteBoundSessionTarget,
-        fallbackActorRef,
-        requestTerminal
-      );
+          : (activation.resolveJoinedActor(targetActorId) ??
+            this.options.actorResolver?.(targetActorId)),
+      actorLeft: (targetActorId) => activation.hasDepartedActor(targetActorId),
+      onRemoteBoundSessionTarget: (targetActorId, target) =>
+        this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(targetActorId, target),
+      onDisconnectActor: (actor) =>
+        activation.serial.execute(() => activation.spot.onDisconnectActor?.(actor)),
+      actorResponseSender: this.options.boundSessionRuntime?.sendActorResponse.bind(
+        this.options.boundSessionRuntime
+      ),
+      actorErrorSender: this.options.boundSessionRuntime?.sendActorError.bind(
+        this.options.boundSessionRuntime
+      ),
+      providerResolver: this.options.providerResolver,
+      messageSerializers: this.options.messageSerializers,
+      dispatchErrors: this.options.dispatchErrors,
+      routeToActorJoinPrewarm: this.options.routeToActorJoinPrewarm
+    }).dispatch(
+      actorId,
+      parts,
+      returnResponse,
+      remoteBoundSessionTarget,
+      fallbackActorRef,
+      requestTerminal
+    );
   }
 
   private async commitNativeActorTransaction(
@@ -273,7 +303,10 @@ export class ZLinkSpotActorAdmissionCoordinator {
       try {
         if (snapshot !== undefined) await transfer?.rollbackNativeActorJoin(actor, snapshot);
       } catch (rollbackError) {
-        throw new AggregateError([error, rollbackError], 'Native actor admission and rollback both failed.');
+        throw new AggregateError(
+          [error, rollbackError],
+          'Native actor admission and rollback both failed.'
+        );
       }
       throw error;
     }
@@ -291,14 +324,9 @@ export class ZLinkSpotActorAdmissionCoordinator {
       activation.commitActorJoin(actor);
       activation.beginActorTransfer(actor.context.actorId);
       await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
-      const results = backlog.length === 0
-        ? []
-        : await this.replayActorBacklog(activation, actor, backlog);
-      await transfer?.claimRoutedActorLocation(
-        actor,
-        activation.spotId,
-        activation.meshName
-      );
+      const results =
+        backlog.length === 0 ? [] : await this.replayActorBacklog(activation, actor, backlog);
+      await transfer?.claimRoutedActorLocation(actor, activation.spotId, activation.meshName);
       routeSwitchStarted = true;
       await transfer?.publishRoutedActorOwnership(actor);
       await transfer?.openRoutedActorSession(actor);
@@ -311,7 +339,10 @@ export class ZLinkSpotActorAdmissionCoordinator {
       try {
         await transfer?.rollbackRoutedActor(actor);
       } catch (rollbackError) {
-        throw new AggregateError([error, rollbackError], 'Actor admission and rollback both failed.');
+        throw new AggregateError(
+          [error, rollbackError],
+          'Actor admission and rollback both failed.'
+        );
       }
       throw error;
     }
@@ -333,13 +364,14 @@ export class ZLinkSpotActorAdmissionCoordinator {
           remoteBoundSessionTarget,
           fallbackActorRef
         ),
-      (index) => this.options.runtimeEventPublisher?.publish({
-        sourceName: 'zlink.framework.actor-handoff',
-        timestamp: new Date(),
-        marker: 'backlog_enqueued',
-        actorId: actor.context.actorId,
-        index
-      })
+      (index) =>
+        this.options.runtimeEventPublisher?.publish({
+          sourceName: 'zlink.framework.actor-handoff',
+          timestamp: new Date(),
+          marker: 'backlog_enqueued',
+          actorId: actor.context.actorId,
+          index
+        })
     );
   }
 }

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

@@ -18,21 +18,14 @@ import type {
 import type { Message } from '../../contracts/Common/Message';
 import type { RequestResult } from '../backend/runtime-values';
 type RuntimeMessage = Message;
-import type {
-  ZLinkRemoteBoundSessionTarget
-} from '../actors';
+import type { ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkDispatchErrorReporter } from '../channels';
 import { ZLinkSpotActorLifecycleDrain } from './spot-actor-lifecycle-drain';
-import {
-  ZLinkSpotActorPacketDrain,
-  type ZLinkActorDispatchPart
-} from './spot-actor-packet-drain';
+import { ZLinkSpotActorPacketDrain, type ZLinkActorDispatchPart } from './spot-actor-packet-drain';
 import { ZLINK_RECV_DONT_WAIT } from './spot-native-flags';
 import { ZLinkSpotNativeActorJoinAdmission } from './spot-native-actor-join-admission';
 import { ZLinkSpotRoutedFrameDispatch } from './spot-routed-frame-dispatch';
-import {
-  ZLinkSpotSubscriptionDispatch
-} from './spot-subscription-dispatch';
+import { ZLinkSpotSubscriptionDispatch } from './spot-subscription-dispatch';
 import type { ZLinkSpotHandlerRegistration } from './spot-handler-registry';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import type { ZLinkApplicationWorkClaim } from '../admission';
@@ -62,12 +55,14 @@ interface ZLinkSpotActorAdmissionRuntime {
   readonly resolveActor: (actorId: string) => ZLinkActor | undefined;
   readonly getTarget: () => ZLinkActorJoinAdmissionTarget;
   readonly defaultAccept: boolean;
-  readonly transfer: {
-    readonly kind: 'disabled';
-  } | {
-    readonly kind: 'enabled';
-    readonly runtime: ZLinkSpotActorTransferRuntime;
-  };
+  readonly transfer:
+    | {
+        readonly kind: 'disabled';
+      }
+    | {
+        readonly kind: 'enabled';
+        readonly runtime: ZLinkSpotActorTransferRuntime;
+      };
   readonly commitNativeActor?: (actor: ZLinkActor) => Promise<void>;
   readonly commitActorDeparture?: (actorId: string) => void;
   readonly commitTransferredActor?: (
@@ -163,23 +158,34 @@ export class ZLinkSpotActorJoinDispatch {
       routedActorTransferProvider: transfer?.runtime.materializeRoutedActor.bind(transfer.runtime),
       commitTransferredActor: actors.commitTransferredActor,
       actorPacketHandler: options.packets?.handle,
-      bindRemoteSession: options.packets?.bindRemoteSession === undefined
-        ? undefined
-        : (actor, sourceNodeRid, sourceSessionRid, declaredTarget) =>
-            options.packets!.bindRemoteSession!(
-              {
-                actorId: actor.actorId,
-                generation: actor.objectGeneration,
-                nodeRid: actor.nodeRid
-              },
-              sourceNodeRid,
-              sourceSessionRid,
-              declaredTarget
-            ),
-      routedBoundSessionReceiver: options.boundSessionRuntime?.receiveRoutedBoundSession.bind(options.boundSessionRuntime),
-      routedBoundSessionResponseReceiver: options.boundSessionRuntime?.receiveRoutedBoundSessionResponse.bind(options.boundSessionRuntime),
-      routedBoundSessionErrorReceiver: options.boundSessionRuntime?.receiveRoutedBoundSessionError.bind(options.boundSessionRuntime),
-      actorPacketTargetProvider: options.boundSessionRuntime?.actorPacketTargetForState.bind(options.boundSessionRuntime),
+      bindRemoteSession:
+        options.packets?.bindRemoteSession === undefined
+          ? undefined
+          : (actor, sourceNodeRid, sourceSessionRid, declaredTarget) =>
+              options.packets!.bindRemoteSession!(
+                {
+                  actorId: actor.actorId,
+                  generation: actor.objectGeneration,
+                  nodeRid: actor.nodeRid
+                },
+                sourceNodeRid,
+                sourceSessionRid,
+                declaredTarget
+              ),
+      routedBoundSessionReceiver: options.boundSessionRuntime?.receiveRoutedBoundSession.bind(
+        options.boundSessionRuntime
+      ),
+      routedBoundSessionResponseReceiver:
+        options.boundSessionRuntime?.receiveRoutedBoundSessionResponse.bind(
+          options.boundSessionRuntime
+        ),
+      routedBoundSessionErrorReceiver:
+        options.boundSessionRuntime?.receiveRoutedBoundSessionError.bind(
+          options.boundSessionRuntime
+        ),
+      actorPacketTargetProvider: options.boundSessionRuntime?.actorPacketTargetForState.bind(
+        options.boundSessionRuntime
+      ),
       messageSerializers: options.messageSerializers,
       providerResolver: options.providerResolver,
       dispatchErrors: options.dispatchErrors,
@@ -229,27 +235,37 @@ export class ZLinkSpotActorJoinDispatch {
         return;
       }
       if (info.event === ZLinkBackendSpotDispatchEvent.ChannelReplyReadable) {
-        if (info.subjectKind === ZLINK_SPOT_DISPATCH_SUBJECT_CHANNEL_DEALER &&
-            info.subjectHandle !== undefined) {
+        if (
+          info.subjectKind === ZLINK_SPOT_DISPATCH_SUBJECT_CHANNEL_DEALER &&
+          info.subjectHandle !== undefined
+        ) {
           this.nativeSpot.drainChannelReply(info.subjectHandle);
           return;
         }
-        if (info.subjectKind === ZLINK_SPOT_DISPATCH_SUBJECT_SPOT ||
-            info.subjectKind === undefined) {
+        if (
+          info.subjectKind === ZLINK_SPOT_DISPATCH_SUBJECT_SPOT ||
+          info.subjectKind === undefined
+        ) {
           this.nativeSpot.drainReply();
         }
         return;
       }
       if (info.event === ZLinkBackendSpotDispatchEvent.RoutedReadable) {
         if (info.routed !== undefined && info.routed !== null) {
-          this.runDetached('spot routed frame dispatch', () => this.routedFrames.dispatchFromEvent(info.routed!));
+          this.runDetached('spot routed frame dispatch', () =>
+            this.routedFrames.dispatchFromEvent(info.routed!)
+          );
         }
         return;
       }
       if (info.event === ZLinkBackendSpotDispatchEvent.ActorReadable) {
-        this.runDetached('spot actor packet drain', () => this.actorPacketDrain.drain(info as unknown as {
-          recvActorPart(flags?: number): ZLinkActorDispatchPart | null;
-        }));
+        this.runDetached('spot actor packet drain', () =>
+          this.actorPacketDrain.drain(
+            info as unknown as {
+              recvActorPart(flags?: number): ZLinkActorDispatchPart | null;
+            }
+          )
+        );
         return;
       }
       if (info.event === ZLinkBackendSpotDispatchEvent.ActorLifecycleReadable) {

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

@@ -1,8 +1,5 @@
 import type { ZLinkActor } from '../../contracts';
-import type {
-  ZLinkBackendActorRef,
-  ZLinkBackendSpot
-} from '../backend/contracts';
+import type { ZLinkBackendActorRef, ZLinkBackendSpot } from '../backend/contracts';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import { ZLINK_RECV_DONT_WAIT } from './spot-native-flags';
 
@@ -47,9 +44,10 @@ export class ZLinkSpotActorLifecycleDrain {
         await this.options.waitIdle();
         return;
       }
-      const actorRef = event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_LEFT
-        ? event.info.previousActor
-        : event.info.currentActor;
+      const actorRef =
+        event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_LEFT
+          ? event.info.previousActor
+          : event.info.currentActor;
       const actorId = actorRef?.actorId;
       if (actorId === undefined || this.options.resolveActor(actorId) === undefined) {
         continue;

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

@@ -10,17 +10,10 @@ import { ZLinkEncodedPayload, ZLinkMessage } from '../../contracts';
 import { throwIfAborted } from '../abort';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import {
-  ZLinkConfigurationException
-} from '../configuration';
+import { ZLinkConfigurationException } from '../configuration';
 import { ZLinkDispatchErrorReporter } from '../channels';
-import {
-  ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME,
-  ZLinkSpotActorDispatcher
-} from '../actors';
-import {
-  encodeFrameworkPayloadMessage
-} from '../messaging/payload-codec';
+import { ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME, ZLinkSpotActorDispatcher } from '../actors';
+import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
 import { routingIdsEqual } from '../routing-id';
 import type { ZLinkSpotActivation } from './spot-activation-state';
 import type { ZLinkSpotActorTransferRuntime } from './spot-runtime-ports';
@@ -55,7 +48,9 @@ export class ZLinkSpotActorMembership {
     spotId: RoutingId,
     actor: ZLinkActor,
     request: Message,
-    commit: (spot: ZLinkSpot) => Promise<ZLinkActorJoinRollback | void> | ZLinkActorJoinRollback | void,
+    commit: (
+      spot: ZLinkSpot
+    ) => Promise<ZLinkActorJoinRollback | void> | ZLinkActorJoinRollback | void,
     signal?: AbortSignal,
     leaveSource?: () => Promise<void>,
     contentType = 'application/json'
@@ -93,9 +88,10 @@ export class ZLinkSpotActorMembership {
     }
     return {
       accepted: response.accepted,
-      reply: response.reply === undefined
-        ? undefined
-        : encodeFrameworkPayloadMessage(response.reply, this.options.messageSerializers)
+      reply:
+        response.reply === undefined
+          ? undefined
+          : encodeFrameworkPayloadMessage(response.reply, this.options.messageSerializers)
     };
   }
 
@@ -112,19 +108,23 @@ export class ZLinkSpotActorMembership {
       this.options.entryNodeRidProvider?.() ??
       this.options.entryNodeRid ??
       this.options.nodeRid;
-    const entrySpotId = meshName === undefined
-      ? undefined
-      : this.options.entrySpotIdProvider?.(meshName);
-    const resolvedEntry = entrySpotId === undefined
-      ? undefined
-      : await this.options.spotRouteResolver?.resolve(entrySpotId, signal);
-    const entryNodeRid = resolvedEntry?.targetNodeRid ??
+    const entrySpotId =
+      meshName === undefined ? undefined : this.options.entrySpotIdProvider?.(meshName);
+    const resolvedEntry =
+      entrySpotId === undefined
+        ? undefined
+        : await this.options.spotRouteResolver?.resolve(entrySpotId, signal);
+    const entryNodeRid =
+      resolvedEntry?.targetNodeRid ??
       this.options.actorTransferRuntime?.actorEntryNodeRid(actor) ??
       localEntryNodeRid;
     if (entryNodeRid === undefined) {
-      throw new ZLinkConfigurationException('Spot actor leave requires an Entry Spot node routing id.');
+      throw new ZLinkConfigurationException(
+        'Spot actor leave requires an Entry Spot node routing id.'
+      );
     }
-    const remoteEntry = localEntryNodeRid !== undefined && !routingIdsEqual(entryNodeRid, localEntryNodeRid);
+    const remoteEntry =
+      localEntryNodeRid !== undefined && !routingIdsEqual(entryNodeRid, localEntryNodeRid);
     if (!remoteEntry) {
       const leaveSource = async () => {
         activation.beginActorTransfer(actor.context.actorId);
@@ -149,7 +149,7 @@ export class ZLinkSpotActorMembership {
           request: unknown,
           signal?: AbortSignal
         ): Promise<boolean>;
-    };
+      };
       const joinEntry = context[ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME](
         entryNodeRid,
         ZLinkMessage.fromEncoded(ZLinkEncodedPayload.from(request.data())),
@@ -184,7 +184,6 @@ export class ZLinkSpotActorMembership {
     });
   }
 
-
   async prepareActorLeaveForTransfer(
     spotId: RoutingId,
     actor: ZLinkActor,
@@ -241,8 +240,7 @@ export class ZLinkSpotActorMembership {
     if (joinedActor === undefined) {
       return false;
     }
-    await activation.serial.execute(() =>
-      activation.spot.onDisconnectActor?.(joinedActor));
+    await activation.serial.execute(() => activation.spot.onDisconnectActor?.(joinedActor));
     return true;
   }