@zlink-systems/framework 0.21.0 → 0.23.0

package/src/runtime/spots/spot-actor-packet-relay-dispatch.ts

@@ -1,20 +1,12 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } from '../framework-errors-internal';
 import {
-  ZLinkFrameworkException,
-  type ActorRef,
-  type RoutingId
-} from '../../contracts';
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
+import { ZLinkFrameworkException, type ActorRef, type RoutingId } from '../../contracts';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import type { ZLinkBackendReceived as BackendReceived } from '../backend/runtime-values';
-import type {
-  ZLinkRemoteActorPacketTarget,
-  ZLinkRemoteBoundSessionTarget
-} from '../actors';
-import {
-  decodeStreamHeader,
-  messageToBytes,
-  ZLinkStreamMessageKind
-} from '../streams/protocol';
+import type { ZLinkRemoteActorPacketTarget, ZLinkRemoteBoundSessionTarget } from '../actors';
+import { decodeStreamHeader, messageToBytes, ZLinkStreamMessageKind } from '../streams/protocol';
 import {
   decodeRemoteActorSessionBinding,
   encodeRemoteActorPacketTarget,
@@ -22,15 +14,14 @@ import {
 } from '../actors/actor-packet-relay-wire';
 import { decodeRoutingId as decodeWireRoutingId, routingIdsEqual } from '../routing-id';
 import type { ZLinkRemoteActorPacketRelay } from './spot-remote-route-codec';
-import {
-  hasReplyToken,
-  submitSpotRouteBridgeReply
-} from './spot-route-replies';
+import { hasReplyToken, submitSpotRouteBridgeReply } from './spot-route-replies';
 import type { ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
 
 interface ZLinkSpotActorPacketRelayDispatchOptions {
   readonly actorPacketHandler?: (delivery: ZLinkActorPacketDelivery) => Promise<unknown>;
-  readonly actorPacketTargetProvider?: (actorId: string) => ZLinkRemoteActorPacketTarget | undefined;
+  readonly actorPacketTargetProvider?: (
+    actorId: string
+  ) => ZLinkRemoteActorPacketTarget | undefined;
   readonly bindRemoteSession?: (
     actor: ActorRef,
     sourceNodeRid: RoutingId,
@@ -54,18 +45,15 @@ export class ZLinkSpotActorPacketRelayDispatch {
       actorPacketRelay.routerChannelId === undefined ||
       actorPacketRelay.boundSessionTargetNodeRid === undefined ||
       actorPacketRelay.boundSessionSpotId === undefined
-      ? undefined
-      : {
-          routerChannelId: actorPacketRelay.routerChannelId,
-          targetNodeRid: decodeWireRoutingId(
-            actorPacketRelay.boundSessionTargetNodeRid,
-            undefined
-          ),
-          spotId: decodeWireRoutingId(
-            actorPacketRelay.boundSessionSpotId,
-            undefined
-          )
-        };
+        ? undefined
+        : {
+            routerChannelId: actorPacketRelay.routerChannelId,
+            targetNodeRid: decodeWireRoutingId(
+              actorPacketRelay.boundSessionTargetNodeRid,
+              undefined
+            ),
+            spotId: decodeWireRoutingId(actorPacketRelay.boundSessionSpotId, undefined)
+          };
     const header = RuntimeMessage.from(Buffer.from(actorPacketRelay.header, 'base64'));
     const payload = RuntimeMessage.from(Buffer.from(actorPacketRelay.payload, 'base64'));
     try {
@@ -82,12 +70,16 @@ export class ZLinkSpotActorPacketRelayDispatch {
           sourceNodeRid === null ||
           this.options.bindRemoteSession === undefined
         ) {
-          throw new Error('Remote actor session binding requires a send, source route, and concrete actor ref.');
+          throw new Error(
+            'Remote actor session binding requires a send, source route, and concrete actor ref.'
+          );
         }
         const binding = decodeRemoteActorSessionBinding(messageToBytes(payload));
         const declaredSourceNodeRid = binding.sessionNodeRid;
         if (!routingIdsEqual(sourceNodeRid, declaredSourceNodeRid)) {
-          throw new Error('Remote actor session binding source did not match the declared session node.');
+          throw new Error(
+            'Remote actor session binding source did not match the declared session node.'
+          );
         }
         this.options.bindRemoteSession(
           actorRef,
@@ -109,8 +101,10 @@ export class ZLinkSpotActorPacketRelayDispatch {
         }
         return true;
       }
-      if (actorPacketRelay.messageFollowContext?.deadlineUnixMs !== undefined
-        && Date.now() >= actorPacketRelay.messageFollowContext.deadlineUnixMs) {
+      if (
+        actorPacketRelay.messageFollowContext?.deadlineUnixMs !== undefined &&
+        Date.now() >= actorPacketRelay.messageFollowContext.deadlineUnixMs
+      ) {
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
           `Actor request '${actorPacketRelay.actorId}' expired before target handler admission.`
@@ -125,9 +119,9 @@ export class ZLinkSpotActorPacketRelayDispatch {
       //  be discarded. Non-follow relays keep the synchronous-return path.
       const outerReplyable = hasReplyToken(received.replyToken);
       const followedBoundSessionReply =
-        !outerReplyable
-        && actorPacketRelay.messageFollowContext !== undefined
-        && remoteBoundSessionTarget !== undefined;
+        !outerReplyable &&
+        actorPacketRelay.messageFollowContext !== undefined &&
+        remoteBoundSessionTarget !== undefined;
       const response = await this.options.actorPacketHandler({
         actorId: actorPacketRelay.actorId,
         parts: [header, payload],
@@ -137,7 +131,11 @@ export class ZLinkSpotActorPacketRelayDispatch {
       });
       const actorPacketTarget = this.actorPacketTarget(actorPacketRelay.actorId);
       if (hasReplyToken(received.replyToken)) {
-        submitSpotRouteBridgeReply(received, actorPacketRelay.envelope, { ok: true, response, actorPacketTarget });
+        submitSpotRouteBridgeReply(received, actorPacketRelay.envelope, {
+          ok: true,
+          response,
+          actorPacketTarget
+        });
       }
       return true;
     } catch (error) {

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

@@ -1,25 +1,24 @@
-import {
-  ZLinkSpotCloseReason,
-  type ZLinkSpotClosingContext
-} from '../../contracts';
+import { ZLinkSpotCloseReason, type ZLinkSpotClosingContext } from '../../contracts';
 
 const DEFAULT_CLEANUP_TIMEOUT_MS = 30_000;
 
 export async function invokeSpotClosing(
-  callback: ((context: ZLinkSpotClosingContext, cleanupSignal: AbortSignal) => Promise<void>) | undefined,
+  callback:
+    ((context: ZLinkSpotClosingContext, cleanupSignal: AbortSignal) => Promise<void>) | undefined,
   reason: ZLinkSpotCloseReason,
   cleanupDeadline: Date | number = DEFAULT_CLEANUP_TIMEOUT_MS
 ): Promise<void> {
   if (callback === undefined) return;
-  const deadline = new Date(cleanupDeadline instanceof Date
-    ? cleanupDeadline.getTime()
-    : Date.now() + cleanupDeadline);
-  const timeoutMs = Math.max(0, cleanupDeadline instanceof Date
-    ? cleanupDeadline.getTime() - Date.now()
-    : cleanupDeadline);
+  const deadline = new Date(
+    cleanupDeadline instanceof Date ? cleanupDeadline.getTime() : Date.now() + cleanupDeadline
+  );
+  const timeoutMs = Math.max(
+    0,
+    cleanupDeadline instanceof Date ? cleanupDeadline.getTime() - Date.now() : cleanupDeadline
+  );
   const controller = new AbortController();
   let timer: ReturnType<typeof setTimeout> | undefined;
-  const expired = new Promise<void>(resolve => {
+  const expired = new Promise<void>((resolve) => {
     timer = setTimeout(() => {
       controller.abort();
       resolve();

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

@@ -21,10 +21,7 @@ import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
 import type { ZLinkWorkerCall } from '../../contracts';
 import { ZLinkConfigurationException } from '../configuration';
 import { DefaultZLinkWorkerCall, ZLinkWorkerRuntime } from '../workers';
-import {
-  createTimerDiagnostics,
-  type ZLinkSpotTimerRegistry
-} from './spot-timer';
+import { createTimerDiagnostics, type ZLinkSpotTimerRegistry } from './spot-timer';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 
 interface ZLinkEntrySpotContextOptions {
@@ -67,7 +64,9 @@ interface ZLinkSpotContextOptions {
   readonly ensureOperationAllowed?: () => void;
 }
 
-export function createEntrySpotContext(options: ZLinkEntrySpotContextOptions): ZLinkEntrySpotContext {
+export function createEntrySpotContext(
+  options: ZLinkEntrySpotContextOptions
+): ZLinkEntrySpotContext {
   return withImmutableSpotIdentity({
     meshName: options.spotNodeName,
     spotId: options.spotId,
@@ -109,11 +108,13 @@ export function createEntrySpotContext(options: ZLinkEntrySpotContextOptions): Z
     },
     runCpuWorker<T>(work: (signal: AbortSignal) => T): ZLinkWorkerCall<T> {
       return new DefaultZLinkWorkerCall(options.serial, (timeoutMs, signal) =>
-        options.workerRuntime.scheduleCpu(work, timeoutMs, signal));
+        options.workerRuntime.scheduleCpu(work, timeoutMs, signal)
+      );
     },
     runIoWorker<T>(work: (signal: AbortSignal) => Promise<T>): ZLinkWorkerCall<T> {
       return new DefaultZLinkWorkerCall(options.serial, (timeoutMs, signal) =>
-        options.workerRuntime.scheduleIo(work, timeoutMs, signal));
+        options.workerRuntime.scheduleIo(work, timeoutMs, signal)
+      );
     }
   });
 }
@@ -131,13 +132,15 @@ export function createSpotContext(options: ZLinkSpotContextOptions): ZLinkSpotCo
     },
     relocationReady: () => {
       options.ensureOperationAllowed?.();
-      return options.relocationReady?.() ?? {
-        defer() {
-          throw new ZLinkConfigurationException(
-            'Spot relocation readiness is not configured for application signaling.'
-          );
+      return (
+        options.relocationReady?.() ?? {
+          defer() {
+            throw new ZLinkConfigurationException(
+              'Spot relocation readiness is not configured for application signaling.'
+            );
+          }
         }
-      };
+      );
     },
     leaveActor: (actor: ZLinkActor, signal?: AbortSignal) => {
       options.ensureOperationAllowed?.();
@@ -157,7 +160,9 @@ export function createSpotContext(options: ZLinkSpotContextOptions): ZLinkSpotCo
       options.ensureOperationAllowed?.();
       const spot = options.getSpot();
       if (spot === undefined) {
-        throw new ZLinkConfigurationException('Spot timer cannot be registered before spot activation.');
+        throw new ZLinkConfigurationException(
+          'Spot timer cannot be registered before spot activation.'
+        );
       }
       return options.timers.add(
         name,
@@ -168,18 +173,27 @@ export function createSpotContext(options: ZLinkSpotContextOptions): ZLinkSpotCo
         spot,
         options.providerResolver,
         signal,
-        createTimerDiagnostics(String(options.spotId), options.spotId, false, name, handlerType, options.runtimeEventPublisher)
+        createTimerDiagnostics(
+          String(options.spotId),
+          options.spotId,
+          false,
+          name,
+          handlerType,
+          options.runtimeEventPublisher
+        )
       );
     },
     runCpuWorker: <T>(work: (signal: AbortSignal) => T): ZLinkWorkerCall<T> => {
       options.ensureOperationAllowed?.();
       return new DefaultZLinkWorkerCall(options.serial, (timeoutMs, signal) =>
-        options.workerRuntime.scheduleCpu(work, timeoutMs, signal));
+        options.workerRuntime.scheduleCpu(work, timeoutMs, signal)
+      );
     },
     runIoWorker: <T>(work: (signal: AbortSignal) => Promise<T>): ZLinkWorkerCall<T> => {
       options.ensureOperationAllowed?.();
       return new DefaultZLinkWorkerCall(options.serial, (timeoutMs, signal) =>
-        options.workerRuntime.scheduleIo(work, timeoutMs, signal));
+        options.workerRuntime.scheduleIo(work, timeoutMs, signal)
+      );
     }
   });
 }
@@ -206,7 +220,9 @@ export function createInstanceSpotContext(
     ) => {
       const spot = options.getSpot();
       if (spot === undefined) {
-        throw new ZLinkConfigurationException('Instance Spot timer cannot be registered before activation.');
+        throw new ZLinkConfigurationException(
+          'Instance Spot timer cannot be registered before activation.'
+        );
       }
       return options.timers.add(
         name,
@@ -229,10 +245,12 @@ export function createInstanceSpotContext(
     },
     runCpuWorker: <T>(work: (signal: AbortSignal) => T): ZLinkWorkerCall<T> =>
       new DefaultZLinkWorkerCall(options.serial, (timeoutMs, signal) =>
-        options.workerRuntime.scheduleCpu(work, timeoutMs, signal)),
+        options.workerRuntime.scheduleCpu(work, timeoutMs, signal)
+      ),
     runIoWorker: <T>(work: (signal: AbortSignal) => Promise<T>): ZLinkWorkerCall<T> =>
       new DefaultZLinkWorkerCall(options.serial, (timeoutMs, signal) =>
-        options.workerRuntime.scheduleIo(work, timeoutMs, signal))
+        options.workerRuntime.scheduleIo(work, timeoutMs, signal)
+      )
   };
   return withImmutableSpotIdentity(common);
 }
@@ -241,12 +259,14 @@ function contextNodeRid(nodeRid: RoutingId | undefined): RoutingId {
   return nodeRid ?? ('' as RoutingId);
 }
 
-function withImmutableSpotIdentity<T extends {
-  readonly meshName: string;
-  readonly spotId: SpotId;
-  readonly objectGeneration: number;
-  readonly nodeRid: RoutingId;
-}>(context: T): T {
+function withImmutableSpotIdentity<
+  T extends {
+    readonly meshName: string;
+    readonly spotId: SpotId;
+    readonly objectGeneration: number;
+    readonly nodeRid: RoutingId;
+  }
+>(context: T): T {
   for (const key of ['meshName', 'spotId', 'objectGeneration', 'nodeRid'] as const) {
     Object.defineProperty(context, key, {
       configurable: false,

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

@@ -26,9 +26,7 @@ import type {
 import type { Message } from '../../contracts/Common/Message';
 import { throwIfAborted } from '../abort';
 import { routingIdsEqual } from '../routing-id';
-import {
-  ZLinkSpotActorHandlerRegistryRuntime
-} from '../actors';
+import { ZLinkSpotActorHandlerRegistryRuntime } from '../actors';
 import type {
   ZLinkBackendActorRecvInfo,
   ZLinkBackendReceived,
@@ -52,18 +50,12 @@ import {
   applyEntrySpotHandlerRegistrations,
   DefaultZLinkSpotHandlerRegistry
 } from './spot-handler-registry';
-import {
-  DefaultZLinkSpotOutbound,
-  type ZLinkSpotRoutedTransport
-} from './spot-outbound';
+import { DefaultZLinkSpotOutbound, type ZLinkSpotRoutedTransport } from './spot-outbound';
 import { createProviderInstance } from './spot-provider';
 import { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import { ZLinkSpotSerialExecutor } from './spot-serial-executor';
 import { invokeSpotClosing } from './spot-closing';
-import {
-  addEntrySpotTimerRegistrations,
-  ZLinkSpotTimerRegistry
-} from './spot-timer';
+import { addEntrySpotTimerRegistrations, ZLinkSpotTimerRegistry } from './spot-timer';
 import { createEntrySpotContext } from './spot-context';
 import { ZLinkRoutedSpotPacketDispatch } from './spot-routed-spot-packet-dispatch';
 import type { RequestResult } from '../backend/runtime-values';
@@ -166,14 +158,11 @@ export class ZLinkEntrySpotActivation {
       providerResolver: options.providerResolver,
       runtimeEventPublisher: options.runtimeEventPublisher,
       workerRuntime: this.workerRuntime,
-      destroyActor: options.entryActorRuntime === undefined
-        ? undefined
-        : (nodeRid, actor, signal) => options.entryActorRuntime!.destroyActor(
-          options.nativeNode,
-          nodeRid,
-          actor,
-          signal
-        )
+      destroyActor:
+        options.entryActorRuntime === undefined
+          ? undefined
+          : (nodeRid, actor, signal) =>
+              options.entryActorRuntime!.destroyActor(options.nativeNode, nodeRid, actor, signal)
     });
     this.entrySpot = undefined as unknown as ZLinkEntrySpot;
     applyEntrySpotHandlerRegistrations(this.handlers, options.entrySpotType, {
@@ -183,14 +172,15 @@ export class ZLinkEntrySpotActivation {
       subscriptionHandlers: options.subscriptionHandlers
     });
     this.packetDispatch = new ZLinkRoutedSpotPacketDispatch({
-      resolveActivation: (spotId) => spotId === this.spotId
-        ? {
-            spotId: this.spotId,
-            spot: this.entrySpot as unknown as ZLinkSpot,
-            serial: this.serial,
-            handlers: this.handlers
-          }
-        : undefined,
+      resolveActivation: (spotId) =>
+        spotId === this.spotId
+          ? {
+              spotId: this.spotId,
+              spot: this.entrySpot as unknown as ZLinkSpot,
+              serial: this.serial,
+              handlers: this.handlers
+            }
+          : undefined,
       providerResolver: options.providerResolver,
       dispatchErrors: options.dispatchErrors
     });
@@ -210,8 +200,12 @@ export class ZLinkEntrySpotActivation {
       onRemoteBoundSessionTarget: (targetActorId, target) =>
         this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(targetActorId, target),
       onDisconnectActor: (actor) => this.notifyDisconnectActor(actor),
-      actorResponseSender: this.options.boundSessionRuntime?.sendActorResponse.bind(this.options.boundSessionRuntime),
-      actorErrorSender: this.options.boundSessionRuntime?.sendActorError.bind(this.options.boundSessionRuntime),
+      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
@@ -271,7 +265,11 @@ export class ZLinkEntrySpotActivation {
   }
 
   async create(): Promise<void> {
-    const entrySpot = await createProviderInstance(this.options.entrySpotType, this.options.providerResolver, this.context);
+    const entrySpot = await createProviderInstance(
+      this.options.entrySpotType,
+      this.options.providerResolver,
+      this.context
+    );
     this.entrySpot = entrySpot;
     Object.defineProperty(this.entrySpot, 'context', {
       configurable: true,
@@ -285,9 +283,9 @@ export class ZLinkEntrySpotActivation {
       this.serial,
       { timerHandlers: this.options.timerHandlers },
       {
-          providerResolver: this.options.providerResolver,
-          spotNodeName: this.options.spotNodeName,
-          spotId: this.context.spotId,
+        providerResolver: this.options.providerResolver,
+        spotNodeName: this.options.spotNodeName,
+        spotId: this.context.spotId,
         runtimeEventPublisher: this.options.runtimeEventPublisher
       }
     );
@@ -316,11 +314,15 @@ export class ZLinkEntrySpotActivation {
       }
     };
     if (this.initialized) {
-      await cleanup(() => this.serial.execute(() => invokeSpotClosing(
-        this.entrySpot.onClosing?.bind(this.entrySpot),
-        ZLinkSpotCloseReason.HostShutdown,
-        deadline
-      )));
+      await cleanup(() =>
+        this.serial.execute(() =>
+          invokeSpotClosing(
+            this.entrySpot.onClosing?.bind(this.entrySpot),
+            ZLinkSpotCloseReason.HostShutdown,
+            deadline
+          )
+        )
+      );
     }
     await cleanup(() => this.actorDispatch?.dispose());
     await cleanup(() => this.timers.dispose());
@@ -340,9 +342,9 @@ export class ZLinkEntrySpotActivation {
     signal?: AbortSignal
   ): Promise<ZLinkActorCreateResponse> {
     throwIfAborted(signal);
-    return this.serial.execute(async () =>
-      await this.entrySpot.onCreateActor?.(actor, createRequest)
-        ?? { accepted: true });
+    return this.serial.execute(
+      async () => (await this.entrySpot.onCreateActor?.(actor, createRequest)) ?? { accepted: true }
+    );
   }
 
   notifyJoinActor(actor: ZLinkActor, signal?: AbortSignal): Promise<void> {
@@ -387,10 +389,13 @@ export class ZLinkEntrySpotActivation {
         resolveActor: (actorId) => this.options.entryActorRuntime?.resolveActor(actorId),
         getTarget: () => this.entrySpot,
         defaultAccept: true,
-        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.commitEntryActorTransaction(actor),
         commitTransferredActor: async (actor, backlog) => {
           await this.commitEntryActorTransaction(actor);
@@ -403,8 +408,12 @@ export class ZLinkEntrySpotActivation {
           if (routingIdsEqual(sourceNodeRid, this.options.nativeNode.routingId)) {
             return;
           }
-          const target = declaredTarget
-            ?? this.options.boundSessionRuntime?.resolveRemoteBoundSessionTarget(sourceNodeRid, sourceSessionRid);
+          const target =
+            declaredTarget ??
+            this.options.boundSessionRuntime?.resolveRemoteBoundSessionTarget(
+              sourceNodeRid,
+              sourceSessionRid
+            );
           if (target !== undefined) {
             this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(actor.actorId, {
               ...target,
@@ -428,8 +437,8 @@ export class ZLinkEntrySpotActivation {
   }
 
   private async commitEntryActorTransaction(actor: ZLinkActor): Promise<void> {
-    const notifyJoined = () => this.serial.execute(() =>
-      notifyEntryActorJoined(this.entrySpot, actor));
+    const notifyJoined = () =>
+      this.serial.execute(() => notifyEntryActorJoined(this.entrySpot, actor));
     const runtime = this.options.entryActorRuntime;
     if (runtime === undefined) {
       await notifyJoined();
@@ -445,8 +454,7 @@ export class ZLinkEntrySpotActivation {
     _membershipEpoch?: bigint
   ): Promise<void> {
     throwIfAborted(signal);
-    return this.serial.execute(() =>
-      this.entrySpot.onLeaveActor(actor));
+    return this.serial.execute(() => this.entrySpot.onLeaveActor(actor));
   }
 
   notifyDisconnectActor(actor: ZLinkActor, signal?: AbortSignal): Promise<void> {
@@ -471,7 +479,12 @@ export class ZLinkEntrySpotActivation {
       fallbackActorRef,
       undefined,
       messageFollowOrigin,
-      (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) =>
+      (
+        replayedParts,
+        replayReturnResponse,
+        replayRemoteBoundSessionTarget,
+        replayFallbackActorRef
+      ) =>
         this.spotSerialExecutor.executeActor(actorId, () =>
           this.dispatchActorPacketInsideMailbox({
             actorId,
@@ -479,11 +492,13 @@ export class ZLinkEntrySpotActivation {
             returnResponse: replayReturnResponse,
             remoteBoundSessionTarget: replayRemoteBoundSessionTarget,
             fallbackActorRef: replayFallbackActorRef
-          }))
+          })
+        )
     );
     if (handoff !== undefined) return await handoff;
     return this.spotSerialExecutor.executeActor(actorId, () =>
-      this.dispatchActorPacketInsideMailbox(delivery));
+      this.dispatchActorPacketInsideMailbox(delivery)
+    );
   }
 
   private async replayActorBacklog(
@@ -500,8 +515,10 @@ export class ZLinkEntrySpotActivation {
             returnResponse,
             remoteBoundSessionTarget,
             fallbackActorRef
-          })),
-      (index) => this.options.runtimeEventPublisher?.publish({
+          })
+        ),
+      (index) =>
+        this.options.runtimeEventPublisher?.publish({
           sourceName: 'zlink.framework.actor-handoff',
           timestamp: new Date(),
           marker: 'backlog_enqueued',
@@ -527,12 +544,12 @@ export class ZLinkEntrySpotActivation {
 }
 
 function notifyEntryActorJoined(entrySpot: ZLinkEntrySpot, actor: ZLinkActor): Promise<void> {
-  const callback = (entrySpot as unknown as {
-    readonly onJoinedActor?: (joinedActor: ZLinkActor) => Promise<void>;
-  }).onJoinedActor;
-  return callback === undefined
-    ? Promise.resolve()
-    : callback.call(entrySpot, actor);
+  const callback = (
+    entrySpot as unknown as {
+      readonly onJoinedActor?: (joinedActor: ZLinkActor) => Promise<void>;
+    }
+  ).onJoinedActor;
+  return callback === undefined ? Promise.resolve() : callback.call(entrySpot, actor);
 }
 
 function toContextGeneration(generation: bigint): number {
@@ -545,7 +562,9 @@ function toContextGeneration(generation: bigint): number {
 }
 
 function entrySpotGeneration(spot: ZLinkBackendSpot): bigint {
-  return spot.lifecycleGeneration
-    ?? (spot as Partial<ZLinkBackendSpot>).status?.().lifecycleGeneration
-    ?? 0n;
+  return (
+    spot.lifecycleGeneration ??
+    (spot as Partial<ZLinkBackendSpot>).status?.().lifecycleGeneration ??
+    0n
+  );
 }

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

@@ -1,8 +1,4 @@
-import type {
-  RoutingId,
-  ZLinkFrameworkRuntimeState,
-  ZLinkSpotKind
-} from '../../contracts';
+import type { RoutingId, ZLinkFrameworkRuntimeState, ZLinkSpotKind } from '../../contracts';
 
 declare const spotHandleBrand: unique symbol;
 
@@ -64,9 +60,12 @@ export function createSpotHandle(
     meshName: initial?.meshName ?? '',
     spotId
   }) as SpotHandle;
-  handleStates.set(handle, typeof initialOrRefresh === 'function'
-    ? { current: undefined, refresh: initialOrRefresh }
-    : { current: initialOrRefresh, refresh: refresh! });
+  handleStates.set(
+    handle,
+    typeof initialOrRefresh === 'function'
+      ? { current: undefined, refresh: initialOrRefresh }
+      : { current: initialOrRefresh, refresh: refresh! }
+  );
   return handle;
 }
 
@@ -75,7 +74,7 @@ export async function resolveSpotHandle(
   signal?: AbortSignal
 ): Promise<ResolvedSpotHandle | undefined> {
   const state = requireHandleState(handle);
-  return state.current ?? await refreshSpotHandle(handle, signal);
+  return state.current ?? (await refreshSpotHandle(handle, signal));
 }
 
 export async function refreshSpotHandle(
@@ -83,12 +82,15 @@ export async function refreshSpotHandle(
   signal?: AbortSignal
 ): Promise<ResolvedSpotHandle | undefined> {
   const state = requireHandleState(handle);
-  state.refreshing ??= state.refresh(signal).then((resolved) => {
-    state.current = resolved;
-    return resolved;
-  }).finally(() => {
-    state.refreshing = undefined;
-  });
+  state.refreshing ??= state
+    .refresh(signal)
+    .then((resolved) => {
+      state.current = resolved;
+      return resolved;
+    })
+    .finally(() => {
+      state.refreshing = undefined;
+    });
   return await state.refreshing;
 }