@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/actors/actor-client.ts

@@ -1,8 +1,15 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
 import { isUtf8 } from 'node:buffer';
 import { channelErrorKindFromCode } from '../channels/channel-envelope';
 import { routingIdsEqual } from '../routing-id';
 import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
-import { createZLinkRequest } from '../messaging/request-result';
+import {
+  createZLinkRequest,
+  mapZLinkRequestReply,
+  type ZLinkRequestResult,
+  identityRequestReply
+} from '../messaging/request-result';
 import type { ZLinkRequest } from '../../contracts/Handlers/Attributes';
 import {
   type ActorRef,
@@ -45,7 +52,11 @@ import {
   internalFrameworkErrorKindFromWireFailureCode,
   ZLinkFrameworkInternalErrorKind
 } from '../framework-errors-internal';
-import type { ZLinkResolvedActorRoute, ZLinkStoreLocationResolvers } from '../locations';
+import type {
+  ZLinkActorRouteInvalidationFence,
+  ZLinkResolvedActorRoute,
+  ZLinkStoreLocationResolvers
+} from '../locations';
 import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import { decodeFrameworkPayloadMessage, encodeFrameworkPayload } from '../messaging/payload-codec';
 import {
@@ -77,9 +88,9 @@ import {
   ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
 } from './actor-packet-relay-wire';
 import type { ZLinkActorRoutedJoinTransport } from './actor-routed-join-transport';
-import { requestRoutedJsonReply } from './actor-routed-json-request';
 
 export interface ZLinkActorClientOptions {
+  readonly requests?: RequestRuntime;
   readonly nodeProvider: (meshName: string) => ZLinkBackendMeshNode | undefined;
   readonly completionTableProvider: (meshName: string) => ZLinkMeshCompletionTable | undefined;
   readonly locationResolver: () => ZLinkStoreLocationResolvers | undefined;
@@ -94,7 +105,8 @@ export interface ZLinkActorClientOptions {
     returnResponse: boolean,
     actor: ActorRef,
     deadlineUnixMs?: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ) => Promise<unknown> | undefined;
   readonly sendErrorReporter?: (error: unknown) => void;
   readonly routeTransport?: ZLinkActorRoutedJoinTransport;
@@ -110,7 +122,10 @@ export interface ZLinkActorClientOptions {
 }
 
 export class DefaultZLinkActorClient implements ZLinkActorClient {
-  constructor(private readonly options: ZLinkActorClientOptions) {}
+  private readonly requests: RequestRuntime;
+  constructor(private readonly options: ZLinkActorClientOptions) {
+    this.requests = options.requests ?? new RequestRuntime();
+  }
 
   sendToActor(actorId: string, message: unknown): ZLinkActorSendCall {
     requireActorId(actorId);
@@ -150,7 +165,7 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
   ): Promise<ZLinkSubmitResult> {
     const route = await this.resolveActorRoute(actorId);
     const { meshName, actorRef: actor } = route;
-    this.throwIfKnownStale(meshName, actor);
+    this.throwIfKnownStale(route);
     const parts = this.createPacketParts(
       ZLinkStreamMessageKind.Send,
       undefined,
@@ -158,9 +173,11 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
       message,
       metadata
     );
-    const messageFollow = createActorMessageFollowContext(route, parts, false);
-    const routedActor = attachActorMessageFollowContext(actor, messageFollow);
+    let routeFence: ZLinkActorRouteInvalidationFence | undefined;
     try {
+      const messageFollow = createActorMessageFollowContext(route, parts, false);
+      routeFence = actorRouteInvalidationFence(route);
+      const routedActor = attachActorMessageFollowContext(actor, messageFollow);
       const submissionCopies =
         (await this.options.transportDeliveryGate?.()?.waitBeforeSubmit(actorId, 'oneWay')) ?? 1;
       const handoff = this.options.handoffCapture?.(
@@ -207,18 +224,13 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
       }
       return await this.submitActorSend(meshName, toBackendActorRef(actor), parts, route);
     } catch (error) {
-      if (isStaleActorError(error)) {
-        this.invalidateActorRoute(actorId);
-        this.options.staleActorRefReporter?.(meshName, actor.actorId);
-        throw actorLocationStale(actor.actorId, error);
-      }
-      throw error;
+      throw this.mapActorFailure(actorId, error, routeFence, meshName);
     } finally {
       closeMessages(parts);
     }
   }
 
-  private async request<TReply>(
+  private request<TReply>(
     actorId: string,
     explicitPacketName: string | undefined,
     request: unknown,
@@ -227,112 +239,123 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
     signal?: AbortSignal,
     waitPolicy: 'async' | 'yield' = 'async',
     onAdmitted?: () => void
-  ): Promise<TReply> {
+  ): ZLinkRequestResult<TReply> {
     throwIfAborted(signal);
     const sourceSpotId = currentZLinkActorExecution()?.spotId ?? currentZLinkSpotSerialSourceId();
     const effectiveTimeoutMs = timeoutMs ?? this.options.defaultRequestTimeoutMs;
-    const deadlineMs =
-      effectiveTimeoutMs === undefined ? undefined : performance.now() + effectiveTimeoutMs;
-    const deadlineUnixMs =
-      effectiveTimeoutMs === undefined ? undefined : Date.now() + effectiveTimeoutMs;
-    const route = await this.resolveActorRoute(actorId, signal, deadlineMs);
-    if (
-      waitPolicy === 'async' &&
-      sourceSpotId !== undefined &&
-      sameSpotRoute(sourceSpotId, route)
-    ) {
-      throw createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.InvalidOperation,
-        `An Actor request cannot await Actor '${actorId}' on the current Spot while holding its execution claim.`
-      );
-    }
-    const { meshName, actorRef: actor } = route;
-    this.throwIfKnownStale(meshName, actor);
-    const operationId = createMessageFollowId();
-    const correlationId = createMessageFollowId();
-    const requestSequence = BigInt(`0x${operationId.slice(16)}`);
-    const parts = this.createPacketParts(
-      ZLinkStreamMessageKind.Request,
-      requestSequence === 0n ? 1n : requestSequence,
-      explicitPacketName,
-      request,
-      mergeActorRequestMetadata(metadata, deadlineUnixMs),
-      correlationId
-    );
-    const messageFollow = createActorMessageFollowContext(
-      route,
-      parts,
-      true,
-      deadlineUnixMs,
-      correlationId,
-      operationId
-    );
-    const routedActor = attachActorMessageFollowContext(actor, messageFollow);
-    try {
-      const delivery = this.options
-        .transportDeliveryGate?.()
-        ?.waitBeforeSubmit(actorId, 'request', signal);
-      const submissionCopies =
-        delivery === undefined
-          ? 1
-          : ((await waitActorReply(delivery, actorId, deadlineMs, signal)) ?? 1);
-      const handoff = this.options.handoffCapture?.(
-        meshName,
-        actor.actorId,
-        parts,
-        true,
-        routedActor,
-        deadlineUnixMs,
-        onAdmitted
-      );
-      if (handoff !== undefined) {
-        const submissions = [handoff];
-        for (let copy = 1; copy < submissionCopies; copy++) {
-          const duplicate = this.options.handoffCapture?.(
-            meshName,
-            actor.actorId,
-            parts,
-            true,
-            routedActor,
-            deadlineUnixMs,
-            onAdmitted
+    let meshName: string | undefined;
+    let routeFence: ZLinkActorRouteInvalidationFence | undefined;
+    return this.requests.prepare<TReply>(
+      effectiveTimeoutMs,
+      signal,
+      (requestOperation, receiver) => {
+        void (async () => {
+          const deadlineMs = requestOperation.deadlineMs;
+          const deadlineUnixMs =
+            effectiveTimeoutMs === undefined ? undefined : Date.now() + effectiveTimeoutMs;
+          const route = await this.resolveActorRoute(actorId, signal, deadlineMs, requestOperation);
+          if (!requestOperation.isPending()) return;
+          if (
+            waitPolicy === 'async' &&
+            sourceSpotId !== undefined &&
+            sameSpotRoute(sourceSpotId, route)
+          ) {
+            throw createInternalFrameworkException(
+              ZLinkFrameworkInternalErrorKind.InvalidOperation,
+              `An Actor request cannot await Actor '${actorId}' on the current Spot while holding its execution claim.`
+            );
+          }
+          const { actorRef: actor } = route;
+          meshName = route.meshName;
+          if (this.options.staleActorRefPredicate?.(meshName, actor) === true) {
+            routeFence = actorRouteInvalidationFence(route);
+            throw actorLocationStale(actor.actorId, undefined);
+          }
+          const operationId = createMessageFollowId();
+          const correlationId = createMessageFollowId();
+          const requestSequence = BigInt(`0x${operationId.slice(16)}`);
+          const parts = this.createPacketParts(
+            ZLinkStreamMessageKind.Request,
+            requestSequence === 0n ? 1n : requestSequence,
+            explicitPacketName,
+            request,
+            mergeActorRequestMetadata(metadata, deadlineUnixMs),
+            correlationId
           );
-          if (duplicate !== undefined) submissions.push(duplicate);
-        }
-        const replies = await waitActorReply<unknown[]>(
-          Promise.all(submissions),
-          actorId,
-          deadlineMs,
-          signal
-        );
-        return replies[0] as TReply;
-      }
-      return await this.submitActorRequest<TReply>(
-        meshName,
-        toBackendActorRef(actor),
-        parts,
-        remainingActorRequestTimeout(actorId, deadlineMs),
-        signal,
-        route,
-        messageFollow,
-        onAdmitted
-      );
-    } catch (error) {
-      if (isStaleActorError(error)) {
-        this.invalidateActorRoute(actorId);
-        this.options.staleActorRefReporter?.(meshName, actor.actorId);
-        throw actorLocationStale(actor.actorId, error);
-      }
-      throw error;
-    } finally {
-      closeMessages(parts);
-    }
+          try {
+            const messageFollow = createActorMessageFollowContext(
+              route,
+              parts,
+              true,
+              deadlineUnixMs,
+              correlationId,
+              operationId
+            );
+            routeFence = actorRouteInvalidationFence(route);
+            const routedActor = attachActorMessageFollowContext(actor, messageFollow);
+            const delivery = this.options
+              .transportDeliveryGate?.()
+              ?.waitBeforeSubmit(actorId, 'request', signal);
+            const submissionCopies =
+              delivery === undefined
+                ? 1
+                : ((await waitActorReply(delivery, actorId, requestOperation)) ?? 1);
+            const handoff = this.options.handoffCapture?.(
+              meshName,
+              actor.actorId,
+              parts,
+              true,
+              routedActor,
+              deadlineUnixMs,
+              onAdmitted,
+              requestOperation
+            );
+            if (handoff !== undefined) {
+              const submissions = [handoff];
+              for (let copy = 1; copy < submissionCopies; copy++) {
+                const duplicate = this.options.handoffCapture?.(
+                  meshName,
+                  actor.actorId,
+                  parts,
+                  true,
+                  routedActor,
+                  deadlineUnixMs,
+                  onAdmitted,
+                  requestOperation
+                );
+                if (duplicate !== undefined) submissions.push(duplicate);
+              }
+              const replies = await Promise.all(submissions);
+              receiver.operationCompleted(requestOperation.id, replies[0], undefined);
+              return;
+            }
+            this.submitActorRequest<TReply>(
+              meshName,
+              toBackendActorRef(actor),
+              parts,
+              remainingActorRequestTimeout(actorId, deadlineMs),
+              signal,
+              route,
+              messageFollow,
+              onAdmitted,
+              requestOperation,
+              receiver
+            );
+          } finally {
+            closeMessages(parts);
+          }
+        })().catch((error) => receiver.operationFailed(requestOperation.id, error, undefined));
+      },
+      (value) => value as TReply,
+      (error) => this.mapActorFailure(actorId, error, routeFence, meshName)
+    );
   }
 
   private async resolveActorRoute(
     actorId: string,
     signal?: AbortSignal,
-    deadlineMs?: number
+    deadlineMs?: number,
+    requestOperation?: PendingOperation<unknown>
   ): Promise<ZLinkResolvedActorRoute> {
     const resolver = this.options.locationResolver();
     if (resolver === undefined) {
@@ -341,7 +364,12 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
         'Actor direct messaging requires a Location Store.'
       );
     }
-    const resolution = await resolver.resolveDirectActorRoute(actorId, signal, deadlineMs);
+    const resolution = await resolver.resolveDirectActorRoute(
+      actorId,
+      signal,
+      deadlineMs,
+      requestOperation
+    );
     if (resolution.kind === 'missing') {
       throw createInternalFrameworkException(
         ZLinkFrameworkInternalErrorKind.ActorRouteNotFound,
@@ -357,15 +385,29 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
     return resolution.route;
   }
 
-  private invalidateActorRoute(actorId: string): void {
-    this.options.locationResolver()?.invalidateActorRoute(actorId);
+  private mapActorFailure(
+    actorId: string,
+    error: unknown,
+    routeFence: ZLinkActorRouteInvalidationFence | undefined,
+    meshName: string | undefined
+  ): unknown {
+    if (!isStaleActorError(error)) return error;
+    const resolver = this.options.locationResolver();
+    if (routeFence !== undefined && resolver !== undefined)
+      resolver.invalidateActorRouteIfMatches(routeFence);
+    if (meshName !== undefined) this.options.staleActorRefReporter?.(meshName, actorId);
+    return actorLocationStale(actorId, error);
   }
 
-  private throwIfKnownStale(meshName: string, actor: ActorRef): void {
+  private throwIfKnownStale(route: ZLinkResolvedActorRoute): void {
+    const { meshName, actorRef: actor } = route;
     if (this.options.staleActorRefPredicate?.(meshName, actor) !== true) return;
-    this.invalidateActorRoute(actor.actorId);
-    this.options.staleActorRefReporter?.(meshName, actor.actorId);
-    throw actorLocationStale(actor.actorId, undefined);
+    throw this.mapActorFailure(
+      actor.actorId,
+      actorLocationStale(actor.actorId, undefined),
+      actorRouteInvalidationFence(route),
+      meshName
+    );
   }
 
   private createPacketParts(
@@ -436,7 +478,7 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
     }
   }
 
-  private async submitActorRequest<TReply>(
+  private submitActorRequest<TReply>(
     meshName: string,
     actor: ZLinkBackendActorRef,
     parts: readonly Message[],
@@ -444,8 +486,10 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
     signal: AbortSignal | undefined,
     route: ZLinkResolvedActorRoute,
     messageFollowContext: ZLinkActorMessageFollowContext,
-    onAdmitted?: () => void
-  ): Promise<TReply> {
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    destination: OperationObserver<unknown, unknown>
+  ): void {
     const node = this.requireNode(meshName);
     if (
       this.options.routeTransport !== undefined &&
@@ -470,51 +514,88 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
         returnResponse: true,
         messageFollowContext
       });
-      const reply = await requestRoutedJsonReply<{
-        readonly ok?: boolean;
-        readonly error?: unknown;
-        readonly errorKind?: unknown;
-        readonly response?: TReply;
-      }>(
-        this.options.routeTransport,
+      this.options.routeTransport.requestToSpot(
         remoteActorRouteTarget(route),
         relay,
-        { timeoutMs, signal, onAdmitted },
-        `Remote Actor request is not available for '${actor.actorId}'.`,
-        (replyParts) => JSON.parse(replyParts[0]?.getString('utf8') ?? '{}')
+        {
+          packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
+          timeoutMs,
+          signal,
+          onAdmitted,
+          requestOperation
+        },
+        {
+          operationCompleted: (id, value) => {
+            const reply = value as {
+              ok?: boolean;
+              error?: unknown;
+              errorKind?: unknown;
+              response?: TReply;
+            };
+            if (reply.ok !== true) {
+              destination.operationFailed(
+                id,
+                createInternalFrameworkException(
+                  remoteRelayErrorKind(reply.errorKind),
+                  typeof reply.error === 'string'
+                    ? reply.error
+                    : `Remote Actor request failed for '${actor.actorId}'.`
+                ),
+                undefined
+              );
+              return;
+            }
+            destination.operationCompleted(id, reply.response, undefined);
+          },
+          operationFailed: (id, error) => destination.operationFailed(id, error, undefined)
+        }
       );
-      if (reply.ok !== true) {
-        throw createInternalFrameworkException(
-          remoteRelayErrorKind(reply.errorKind),
-          typeof reply.error === 'string'
-            ? reply.error
-            : `Remote Actor request failed for '${actor.actorId}'.`
-        );
-      }
-      return reply.response as TReply;
+      return;
     }
     const completions = this.options.completionTableProvider(meshName);
     if (completions === undefined) {
       throw routeNotConnected('Actor request requires a running MeshNode completion table.');
     }
-    const completion = await completions.submit(
-      () =>
-        node.requestToActor(actor, toMessageLikeParts(parts), {
-          flags: ZLINK_BACKEND_SEND_NONE,
-          routeFence: nativeActorRouteFence(route, actor),
-          timeoutMs,
-          onAdmitted
-        }),
-      signal
-    );
-    if (completion.terminalResult !== RequestResult.Ok) {
-      closeMeshCompletion(completion);
-      throw mapRequestResult(completion.terminalResult, completion.failureErrno, 'Actor request');
-    }
-    return decodeActorReply<TReply>(
-      completion.parts,
-      this.options.messageSerializers,
-      decodeStreamHeader(parts[0].data()).name
+    const packetName = decodeStreamHeader(parts[0].data()).name;
+    this.requests.run(
+      requestOperation,
+      (receiver) =>
+        completions.submit(
+          (completion) =>
+            node.requestToActor(
+              actor,
+              toMessageLikeParts(parts),
+              {
+                flags: ZLINK_BACKEND_SEND_NONE,
+                routeFence: nativeActorRouteFence(route, actor),
+                timeoutMs,
+                onAdmitted,
+                requestOperation
+              },
+              completion
+            ),
+          signal,
+          requestOperation,
+          receiver
+        ),
+      (raw) => {
+        const completion = raw as import('../backend').ZLinkMeshCompletion;
+        if (completion.terminalResult !== RequestResult.Ok) {
+          closeMeshCompletion(completion);
+          throw mapRequestResult(
+            completion.terminalResult,
+            completion.failureErrno,
+            'Actor request'
+          );
+        }
+        return decodeActorReply<TReply>(
+          completion.parts,
+          this.options.messageSerializers,
+          packetName
+        );
+      },
+      identityRequestReply,
+      destination
     );
   }
 
@@ -540,6 +621,19 @@ function nativeActorRouteFence(route: ZLinkResolvedActorRoute, actor: ZLinkBacke
   };
 }
 
+function actorRouteInvalidationFence(
+  route: ZLinkResolvedActorRoute
+): ZLinkActorRouteInvalidationFence {
+  return {
+    actorId: route.actorRef.actorId,
+    objectGeneration: route.actorRef.objectGeneration,
+    targetNodeRid: route.actorRef.nodeRid,
+    targetNodeGeneration: route.ownerNodeGeneration,
+    authorityOwnerGeneration: route.authorityOwnerGeneration,
+    ownerLeaseGeneration: route.ownerLeaseGeneration
+  };
+}
+
 function remoteActorRouteTarget(route: ZLinkResolvedActorRoute) {
   if (route.enclosingSpotRoute !== undefined) {
     return route.enclosingSpotRoute;
@@ -694,13 +788,13 @@ class DefaultZLinkActorRequestCall implements ZLinkActorRequestCall {
       metadata: ReadonlyMap<string, string>,
       signal?: AbortSignal,
       onAdmitted?: () => void
-    ) => Promise<TReply>,
+    ) => ZLinkRequestResult<TReply>,
     private readonly yieldSubmitter: <TReply>(
       packetName: string | undefined,
       timeoutMs: number | undefined,
       metadata: ReadonlyMap<string, string>,
       signal?: AbortSignal
-    ) => Promise<TReply>,
+    ) => ZLinkRequestResult<TReply>,
     private readonly targetActorId: string,
     private readonly request: unknown,
     private readonly defaultRequestTimeoutMs?: number
@@ -729,7 +823,7 @@ class DefaultZLinkActorRequestCall implements ZLinkActorRequestCall {
   yield<TReply>(signal?: AbortSignal): Promise<TReply> {
     this.rejectSelfActorRequest();
     const turn = requireZLinkYieldTurn(this.turn);
-    const pending = this.execute<TReply>('yield', signal);
+    const pending = mapZLinkRequestReply(this.execute<TReply>('yield', signal));
     return turn.yieldFrameworkPromise(pending);
   }
 
@@ -737,7 +831,7 @@ class DefaultZLinkActorRequestCall implements ZLinkActorRequestCall {
     waitPolicy: 'async' | 'yield',
     signal?: AbortSignal,
     onAdmitted?: () => void
-  ): Promise<TReply> {
+  ): ZLinkRequestResult<TReply> {
     ensureSingleSubmit(this.executed);
     this.executed = true;
     throwIfAborted(signal);

package/src/runtime/actors/actor-context.ts

@@ -147,16 +147,24 @@ export class DefaultZLinkActorContext implements ZLinkActorContext {
   ): Promise<boolean> {
     const requestMessage = encodeJoinRequest(request, this.messageSerializers);
     try {
-      return (
-        await this.requireJoinCoordinator().joinEntrySpot(
-          this.requireActor(),
-          this.state,
-          nodeRid,
-          requestMessage,
-          undefined,
-          signal
-        )
-      ).accepted;
+      const result = await this.requireJoinCoordinator().joinEntrySpot(
+        this.requireActor(),
+        this.state,
+        nodeRid,
+        requestMessage,
+        undefined,
+        signal
+      );
+      try {
+        if (result.sourceCleanup !== undefined) {
+          await result.sourceCleanup();
+          return result.accepted;
+        }
+      } finally {
+        result.reply?.close();
+      }
+      await result.finalizeDeferredJoin?.();
+      return result.accepted;
     } finally {
       requestMessage.close();
     }
@@ -248,7 +256,8 @@ class DefaultZLinkActorJoinSpotCall implements ZLinkActorJoinSpotCall {
               requestMessage,
               remainingJoinTimeout(deadline.atMs),
               deadline.signal,
-              operationId
+              operationId,
+              deadline.atMs
             );
             if (this.turn === undefined) {
               await pendingJoin.catch(() => undefined);
@@ -271,7 +280,8 @@ class DefaultZLinkActorJoinSpotCall implements ZLinkActorJoinSpotCall {
                 requestMessage,
                 remainingJoinTimeout(deadline.atMs),
                 deadline.signal,
-                operationId
+                operationId,
+                deadline.atMs
               );
             result =
               this.turn === undefined
@@ -396,7 +406,8 @@ class DefaultZLinkActorJoinEntrySpotCall implements ZLinkActorJoinEntrySpotCall
               requestMessage,
               remainingJoinTimeout(deadline.atMs),
               deadline.signal,
-              operationId
+              operationId,
+              deadline.atMs
             );
             if (this.turn === undefined) {
               await pendingJoin.catch(() => undefined);
@@ -419,7 +430,8 @@ class DefaultZLinkActorJoinEntrySpotCall implements ZLinkActorJoinEntrySpotCall
                 requestMessage,
                 remainingJoinTimeout(deadline.atMs),
                 deadline.signal,
-                operationId
+                operationId,
+                deadline.atMs
               );
             result =
               this.turn === undefined

package/src/runtime/actors/actor-execution-context.ts

@@ -9,13 +9,13 @@ interface ZLinkActorExecutionContext {
 const actorExecutionStorage = new AsyncLocalStorage<ZLinkActorExecutionContext>();
 
 /** Runs one Actor handler while retaining its Actor FIFO claim across Yield. */
-export async function runZLinkActorExecution<T>(
+export function runZLinkActorExecution<T>(
   actorId: string,
   spotId: unknown,
   operation: () => Promise<T> | T
 ): Promise<T> {
   const context: ZLinkActorExecutionContext = { actorId, spotId, active: true };
-  return await actorExecutionStorage.run(context, async () => {
+  return actorExecutionStorage.run(context, async () => {
     try {
       return await operation();
     } finally {