@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -17,7 +17,7 @@ import {
   ZLinkRuntimeDispatchErrorAction,
   ZLinkRuntimeDispatchErrorReason
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import { throwIfAborted } from '../abort';
+import { awaitWithAbort, throwIfAborted } from '../abort';
 import { ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME, ZLinkSpotActorDispatcher } from '../actors';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import { ZLinkDispatchErrorReporter } from '../channels';
@@ -124,8 +124,10 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId, meshName);
-    await this.runLifecycleOperation(activation, () =>
-      this.leaveActorCore(activation, actor, signal, meshName)
+    await this.runLifecycleOperation(
+      activation,
+      () => this.leaveActorCore(activation, actor, undefined, meshName),
+      signal
     );
   }
 
@@ -261,9 +263,10 @@ export class ZLinkSpotActorMembership {
 
   private async runLifecycleOperation<T>(
     activation: ZLinkSpotActivation,
-    operation: () => Promise<T> | T
+    operation: () => Promise<T> | T,
+    signal?: AbortSignal
   ): Promise<T> {
-    const pending = activation.serial.executeLifecycleOperation(operation);
+    const pending = awaitWithAbort(activation.serial.executeLifecycleOperation(operation), signal);
     return activation.serial.isCurrentTurn
       ? await activation.serial.currentTurn!.yieldFrameworkPromise(pending)
       : await pending;

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

@@ -1,16 +1,21 @@
-import { actorMessageFollowContext } from '../actors/actor-message-follow-context';
+import {
+  resolveActorIngress,
+  type ZLinkRouteToActorJoinPrewarm,
+  type ZLinkActorIngressRoute
+} from './spot-actor-ingress-admission';
+import type { ZLinkSpotActorHandoffRuntime } from './spot-runtime-ports';
 import { DefaultZLinkActorContext } from '../actors/actor-context';
 import { decodeSessionDisconnected } from '../actors/session-disconnected-wire';
 import { routingIdsEqual } from '../routing-id';
 import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import {
   ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException,
-  internalFrameworkErrorKind
+  createInternalFrameworkException
 } from '../framework-errors-internal';
 import type {
   ActorRef,
   RoutingId,
+  Type,
   ZLinkActor,
   ZLinkMessageSerializer,
   ZLinkSpot
@@ -31,6 +36,7 @@ import {
   ZLinkDispatchMessageKind
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { flowIfEnabled } from '../diagnostics';
+import { dispatchReasonFromError } from '../diagnostics/dispatch-error-details';
 import { createInboundFlow, currentFlowContext, runWithFlow } from '../diagnostics/flow-context';
 import { streamSessionIdFromRoutingId } from '../streams/managed-stream';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors';
@@ -73,6 +79,7 @@ export interface ZLinkActorRequestTerminal {
 /** One admitted Actor packet and the routing context that must move with it. */
 export interface ZLinkActorPacketDelivery {
   readonly origin: ApplicationJobOrigin;
+  readonly receivedAt?: Date;
   readonly actorId: string;
   readonly parts: readonly Message[];
   readonly returnResponse: boolean;
@@ -83,43 +90,15 @@ export interface ZLinkActorPacketDelivery {
   readonly sourceSessionRid?: RoutingId;
 }
 
-/**
- * Spec 15 §4.2 relocation temporary queue: consulted when {@code
- * resolveActor} finds nothing for an arrival that carries an exact object
- * identity. Parks the arrival if an Actor Join admission attempt is in
- * flight for {@code (actorId, objectGeneration)}, or reports not-found so
- * the caller falls through to its existing missing-actor handling
- * unchanged.
- */
-export type ZLinkRouteToActorJoinPrewarm = (
-  actorId: string,
-  objectGeneration: bigint,
-  arrival: {
-    readonly origin: ApplicationJobOrigin;
-    readonly header: Buffer;
-    readonly payload: Buffer;
-    readonly returnResponse: boolean;
-    readonly remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget;
-    readonly fallbackActorRef?: ActorRef;
-    readonly requestTerminal?: ZLinkActorRequestTerminal;
-    readonly resolve: (value: unknown) => void;
-    readonly reject: (reason: unknown) => void;
-  }
-) => 'parked' | 'not-found';
-
+export type { ZLinkRouteToActorJoinPrewarm } from './spot-actor-ingress-admission';
 interface ZLinkSpotActorPacketDispatchOptions {
+  readonly admission?: import('../admission').ZLinkRuntimeAdmissionGate;
   readonly spot: ZLinkSpot | (() => ZLinkSpot);
   readonly spotId: () => string;
   readonly registry: ZLinkSpotActorHandlerRegistryRuntime;
-  readonly serial?: ZLinkSpotSerialTurnExecutor;
   readonly resolveActor: (actorId: string) => ZLinkActor | undefined;
-  readonly actorLeft?: (actorId: string) => boolean;
-  readonly routeBeforeLocal?: (
-    delivery: ZLinkActorPacketDelivery
-  ) =>
-    | Promise<{ readonly handled: boolean; readonly response?: unknown } | undefined>
-    | { readonly handled: boolean; readonly response?: unknown }
-    | undefined;
+  readonly hasDepartedActor?: (actorId: string) => boolean;
+  readonly routeBeforeLocal?: ZLinkActorIngressRoute;
   readonly onDisconnectActor: (actor: ZLinkActor) => Promise<void>;
   readonly actorResponseSender?: (
     actor: ZLinkActor,
@@ -146,10 +125,14 @@ interface ZLinkSpotActorPacketDispatchOptions {
   readonly routeToActorJoinPrewarm?: ZLinkRouteToActorJoinPrewarm;
 }
 
+export type ZLinkActorPacketExecution =
+  { readonly terminal: Promise<unknown> } | { readonly response: unknown };
+
 export class ZLinkSpotActorPacketDispatch {
   constructor(private readonly options: ZLinkSpotActorPacketDispatchOptions) {}
 
   dispatch(
+    serial: ZLinkSpotSerialTurnExecutor | undefined,
     origin: ApplicationJobOrigin,
     actorId: string,
     parts: readonly Message[],
@@ -158,8 +141,9 @@ export class ZLinkSpotActorPacketDispatch {
     fallbackActorRef?: ActorRef,
     requestTerminal?: ZLinkActorRequestTerminal
   ): Promise<unknown> {
-    return this.dispatchDelivery({
+    return this.dispatchDelivery(serial, {
       origin,
+      receivedAt: new Date(),
       actorId,
       parts,
       returnResponse,
@@ -169,18 +153,32 @@ export class ZLinkSpotActorPacketDispatch {
     });
   }
 
-  async dispatchDelivery(delivery: ZLinkActorPacketDelivery): Promise<unknown> {
+  async dispatchDelivery(
+    serial: ZLinkSpotSerialTurnExecutor | undefined,
+    delivery: ZLinkActorPacketDelivery
+  ): Promise<unknown> {
+    const result = await this.admitDelivery(serial, delivery);
+    return 'terminal' in result ? await result.terminal : result.response;
+  }
+
+  async admitDelivery(
+    serial: ZLinkSpotSerialTurnExecutor | undefined,
+    delivery: ZLinkActorPacketDelivery,
+    handoffRuntime?: ZLinkSpotActorHandoffRuntime
+  ): Promise<ZLinkActorPacketExecution> {
     const {
       actorId,
       parts,
       returnResponse,
+      receivedAt: deliveryReceivedAt,
       remoteBoundSessionTarget,
       fallbackActorRef,
       requestTerminal
     } = delivery;
+    const receivedAt = deliveryReceivedAt ?? new Date();
     if (parts.length < 2) {
       this.reportInvalidFrame(actorId, ZLinkDispatchMessageKind.ActorSend);
-      return undefined;
+      return { response: undefined };
     }
     //  Spec 26 §4.1: one level read per processing point — the same gate value
     //  drives both the decode and the flow-context install.
@@ -223,28 +221,32 @@ export class ZLinkSpotActorPacketDispatch {
           disconnected && header.kind === ZLinkStreamMessageKind.Request
             ? emptyDisconnectedReply
             : undefined;
-        if (this.options.actorLeft?.(actorId) === true && disconnected) {
-          return disconnectedReply;
-        }
-        const routed = await this.options.routeBeforeLocal?.(delivery);
-        if (routed?.handled === true) {
-          return routed.response;
-        }
-        const actor = this.options.resolveActor(actorId);
-        if (actor === undefined) {
-          return this.handleMissingActor(
-            delivery.origin,
-            actorId,
-            parts,
-            header,
-            messageKind,
-            action,
-            returnResponse,
-            remoteBoundSessionTarget,
-            fallbackActorRef,
-            requestTerminal
-          );
-        }
+        const admitted = resolveActorIngress(
+          delivery,
+          messageKind === ZLinkDispatchMessageKind.ActorRequest,
+          {
+            handoffRuntime,
+            routeBeforeLocal: this.options.routeBeforeLocal,
+            resolveActor: this.options.resolveActor,
+            hasDepartedActor: this.options.hasDepartedActor,
+            routeToActorJoinPrewarm: this.options.routeToActorJoinPrewarm
+          }
+        );
+        if ('terminal' in admitted) return { terminal: admitted.terminal };
+        if (admitted.kind === 'stale')
+          return {
+            response: await this.dispatchUnavailableActor(
+              admitted.error,
+              actorId,
+              header,
+              messageKind,
+              action,
+              returnResponse,
+              remoteBoundSessionTarget,
+              fallbackActorRef
+            )
+          };
+        const actor = admitted.actor;
         if (disconnected) {
           const identity = decodeSessionDisconnected(messageToBytes(parts[1]));
           if (identity === undefined) {
@@ -258,7 +260,7 @@ export class ZLinkSpotActorPacketDispatch {
                 ),
                 'warning'
               );
-            return disconnectedReply;
+            return { response: disconnectedReply };
           }
           const current =
             actor.context instanceof DefaultZLinkActorContext
@@ -270,85 +272,68 @@ export class ZLinkSpotActorPacketDispatch {
               current.sessionOwnerNodeGeneration !== identity.sessionOwnerNodeGeneration ||
               current.bindingGeneration !== identity.bindingGeneration)
           )
-            return disconnectedReply;
+            return { response: disconnectedReply };
           await this.options.onDisconnectActor(actor);
-          return disconnectedReply;
+          this.trace(
+            messageKind === ZLinkDispatchMessageKind.ActorRequest
+              ? ZLinkMessageFlowOutcome.Replied
+              : ZLinkMessageFlowOutcome.Completed,
+            actorId,
+            header,
+            messageKind
+          );
+          return { response: disconnectedReply };
         }
         const decodePayload = this.createPayloadDecoder(parts[1], header);
-        return this.dispatchActorPacket(
-          actor,
-          actorId,
-          decodePayload,
-          header,
-          messageKind,
-          action,
-          returnResponse,
-          remoteBoundSessionTarget,
-          fallbackActorRef,
-          requestTerminal,
-          requestDeadlineUnixMs,
-          zlinkSerialWorkOptions(
-            parts[1].data().byteLength,
-            zlinkMetadataByteLength(header.metadata)
+        return {
+          response: await this.dispatchActorPacket(
+            actor,
+            actorId,
+            decodePayload,
+            header,
+            messageKind,
+            action,
+            returnResponse,
+            remoteBoundSessionTarget,
+            fallbackActorRef,
+            requestTerminal,
+            requestDeadlineUnixMs,
+            serial,
+            zlinkSerialWorkOptions(
+              parts[1].data().byteLength,
+              zlinkMetadataByteLength(header.metadata)
+            ),
+            receivedAt
           )
-        );
+        };
       }
     );
   }
 
-  private async handleMissingActor(
-    origin: ApplicationJobOrigin,
+  private async dispatchUnavailableActor(
+    missingActorError: unknown,
     actorId: string,
-    parts: readonly Message[],
     header: ReturnType<typeof decodeStreamHeader>,
     messageKind: ZLinkDispatchMessageKind,
     action: ZLinkDispatchErrorAction,
     returnResponse: boolean,
     fallbackBoundSessionTarget: ZLinkRemoteBoundSessionTarget | undefined,
-    fallbackActorRef: ActorRef | undefined,
-    requestTerminal: ZLinkActorRequestTerminal | undefined
+    fallbackActorRef: ActorRef | undefined
   ): Promise<unknown> {
-    if (
-      this.options.routeToActorJoinPrewarm !== undefined &&
-      fallbackActorRef !== undefined &&
-      parts.length >= 2 &&
-      //  A Request without a terminal has no way to complete once
-      //  migrated later — parking it would leave the caller hanging
-      //  forever with no reply route. Fall through to the existing
-      //  missing-actor handling for that shape instead.
-      (messageKind !== ZLinkDispatchMessageKind.ActorRequest || requestTerminal !== undefined)
-    ) {
-      const parked = this.parkForActorJoinPrewarm(
-        origin,
-        actorId,
-        parts,
-        messageKind,
-        returnResponse,
-        fallbackBoundSessionTarget,
-        fallbackActorRef,
-        requestTerminal
-      );
-      if (parked !== undefined) return parked;
-    }
     this.options.dispatchErrors?.report({
       surface: ZLinkDispatchErrorSurface.SpotActor,
       messageKind,
-      reason: ZLinkDispatchErrorReason.HandlerMissing,
+      reason: dispatchReasonFromError(missingActorError),
       action,
       packetName: header.name,
       spotId: this.options.spotId(),
       actorId,
-      correlationId: header.correlationId ?? header.requestSeq?.toString()
+      correlationId: header.correlationId ?? header.requestSeq?.toString(),
+      error: missingActorError
     });
     if (messageKind !== ZLinkDispatchMessageKind.ActorRequest) {
       return undefined;
     }
-    const missingActorError = createInternalFrameworkException(
-      actorMessageFollowContext(fallbackActorRef) === undefined
-        ? ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound
-        : ZLinkFrameworkInternalErrorKind.ActorLocationStale,
-      `SPOT actor is not registered locally: ${actorId}`
-    );
     if (
       header.requestSeq !== undefined &&
       !returnResponse &&
@@ -368,87 +353,15 @@ export class ZLinkSpotActorPacketDispatch {
     throw missingActorError;
   }
 
-  /**
-   * Spec 15 §4.2 relocation temporary queue: parks one arrival for a
-   * missing Actor that carries an exact object identity, instead of
-   * dropping it (Send) or replying HandlerNotFound (Request). Returns
-   * {@code undefined} when no admission attempt owns this object — the
-   * caller falls through to its existing missing-actor handling unchanged.
-   * Header/payload are copied to owned buffers before parking so the
-   * arrival survives independently of the original {@link Message}
-   * lifetime.
-   */
-  private parkForActorJoinPrewarm(
-    origin: ApplicationJobOrigin,
-    actorId: string,
-    parts: readonly Message[],
-    messageKind: ZLinkDispatchMessageKind,
-    returnResponse: boolean,
-    remoteBoundSessionTarget: ZLinkRemoteBoundSessionTarget | undefined,
-    fallbackActorRef: ActorRef,
-    requestTerminal: ZLinkActorRequestTerminal | undefined
-  ): Promise<unknown> | undefined {
-    const isRequest = messageKind === ZLinkDispatchMessageKind.ActorRequest;
-    let resolve: (value: unknown) => void = () => undefined;
-    let reject: (reason: unknown) => void = () => undefined;
-    const result = new Promise<unknown>((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    //  A Request's real reply must still travel through the exact mailbox
-    //  correlation the original caller captured in `requestTerminal` — not
-    //  through this method's own return value, which the caller only uses
-    //  to decide whether it still owes a reply itself. Wrapping keeps that
-    //  reply route intact across the (possibly much later) redelivery at
-    //  migration time while also releasing the original caller once the
-    //  real reply has gone out, so it never sends a premature empty one.
-    const wrappedRequestTerminal: ZLinkActorRequestTerminal | undefined =
-      requestTerminal === undefined
-        ? undefined
-        : Object.assign(
-            async (response: unknown, preparedReply?: unknown) => {
-              try {
-                await requestTerminal(response, preparedReply);
-                resolve(undefined);
-              } catch (error) {
-                reject(error);
-                throw error;
-              }
-            },
-            { prepare: requestTerminal.prepare }
-          );
-    const route = this.options.routeToActorJoinPrewarm!(
-      actorId,
-      fallbackActorRef.objectGeneration,
-      {
-        origin,
-        header: Buffer.from(parts[0].data()),
-        payload: Buffer.from(parts[1].data()),
-        returnResponse,
-        remoteBoundSessionTarget,
-        fallbackActorRef,
-        requestTerminal: wrappedRequestTerminal,
-        resolve,
-        reject
-      }
-    );
-    if (route !== 'parked') return undefined;
-    //  A Send has no reply to wait for: the migrated redelivery still runs
-    //  in order later, but this caller's own await is done once parking is
-    //  confirmed.
-    if (!isRequest) resolve(undefined);
-    return result;
-  }
-
   private createPayloadDecoder(
     message: Message,
     header: ReturnType<typeof decodeStreamHeader>
-  ): () => unknown {
-    return () =>
+  ): (messageType?: Type) => unknown {
+    return (messageType) =>
       decodeFrameworkTypedPayloadMessage(
         message,
         this.options.messageSerializers,
-        undefined,
+        messageType,
         streamCodecContentType(header.codec),
         header.name
       );
@@ -466,18 +379,26 @@ export class ZLinkSpotActorPacketDispatch {
     fallbackActorRef: ActorRef | undefined,
     requestTerminal: ZLinkActorRequestTerminal | undefined,
     requestDeadlineUnixMs: number | undefined,
-    workOptions: ZLinkSerialWorkOptions
+    serial: ZLinkSpotSerialTurnExecutor | undefined,
+    workOptions: ZLinkSerialWorkOptions,
+    receivedAt: Date
   ): Promise<unknown> {
     const spot = typeof this.options.spot === 'function' ? this.options.spot() : this.options.spot;
     const dispatcher = new ZLinkSpotActorDispatcher({
       registry: this.options.registry,
       spot,
       providerResolver: this.options.providerResolver,
-      serial: this.options.serial,
+      serial,
       serialWorkOptions: workOptions,
       messageSerializers: this.options.messageSerializers,
       onAdmitted: () => this.trace(ZLinkMessageFlowOutcome.Admitted, actorId, header, messageKind),
       onHandlerStart: () => {
+        if (this.options.admission?.ownerAdmissionOpen() === false) {
+          throw createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.RequestRejected,
+            'Actor handler was rejected because Location owner admission is closed.'
+          );
+        }
         // A transferred backlog is returned to the Actor queue as one FIFO
         // prefix. Check the request deadline when its owner turn actually
         // starts, not when that prefix is admitted.
@@ -491,8 +412,8 @@ export class ZLinkSpotActorPacketDispatch {
             `Actor request '${actorId}' expired before handler admission.`
           );
         }
-        releaseApplicationJobPermitBeforeHandler();
         this.trace(ZLinkMessageFlowOutcome.Dispatched, actorId, header, messageKind);
+        releaseApplicationJobPermitBeforeHandler();
       }
     });
     try {
@@ -500,7 +421,8 @@ export class ZLinkSpotActorPacketDispatch {
         await dispatcher.dispatchSendDecoded(actor, header.name, decodePayload, {
           meshName: spot.context.meshName,
           metadata: zlinkMessageMetadata(header.metadata),
-          correlationId: header.correlationId ?? undefined
+          correlationId: header.correlationId ?? undefined,
+          receivedAt
         });
         this.trace(
           ZLinkMessageFlowOutcome.Completed,
@@ -533,7 +455,8 @@ export class ZLinkSpotActorPacketDispatch {
           {
             meshName: spot.context.meshName,
             metadata: zlinkMessageMetadata(header.metadata),
-            correlationId: header.correlationId ?? header.requestSeq.toString()
+            correlationId: header.correlationId ?? header.requestSeq.toString(),
+            receivedAt
           },
           async (response) => {
             this.trace(
@@ -561,7 +484,8 @@ export class ZLinkSpotActorPacketDispatch {
           {
             meshName: spot.context.meshName,
             metadata: zlinkMessageMetadata(header.metadata),
-            correlationId: header.correlationId ?? header.requestSeq.toString()
+            correlationId: header.correlationId ?? header.requestSeq.toString(),
+            receivedAt
           }
         );
         this.trace(
@@ -579,7 +503,8 @@ export class ZLinkSpotActorPacketDispatch {
         {
           meshName: spot.context.meshName,
           metadata: zlinkMessageMetadata(header.metadata),
-          correlationId: header.correlationId ?? header.requestSeq.toString()
+          correlationId: header.correlationId ?? header.requestSeq.toString(),
+          receivedAt
         },
         async (response, replyOptions) => {
           this.trace(
@@ -605,16 +530,7 @@ export class ZLinkSpotActorPacketDispatch {
       this.options.dispatchErrors?.report({
         surface: ZLinkDispatchErrorSurface.SpotActor,
         messageKind,
-        reason:
-          error instanceof ZLinkFrameworkException &&
-          internalFrameworkErrorKind(error) ===
-            ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound
-            ? ZLinkDispatchErrorReason.HandlerMissing
-            : error instanceof ZLinkFrameworkException &&
-                internalFrameworkErrorKind(error) ===
-                  ZLinkFrameworkInternalErrorKind.PayloadDecodeFailed
-              ? ZLinkDispatchErrorReason.PayloadDecodeFailed
-              : ZLinkDispatchErrorReason.HandlerException,
+        reason: dispatchReasonFromError(error),
         action,
         packetName: header.name,
         spotId: this.options.spotId(),

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

@@ -37,14 +37,16 @@ interface ZLinkSpotActorPacketDrainOptions {
   ) => void;
   readonly waitIdle: () => Promise<void>;
   readonly flowEnabled?: () => boolean;
+  readonly receivedAtClock?: () => Date;
 }
 
 const ZLINK_SPOT_ACTOR_RECV_INFO_NO_BIND = 1;
+const systemReceivedAtClock = (): Date => new Date();
 
 export class ZLinkSpotActorPacketDrain {
   private readonly continuations = new Map<
     string,
-    { readonly owner: string; readonly parts: Message[] }
+    { readonly owner: string; readonly parts: Message[]; readonly receivedAt: Date }
   >();
 
   constructor(private readonly options: ZLinkSpotActorPacketDrainOptions) {}
@@ -60,6 +62,7 @@ export class ZLinkSpotActorPacketDrain {
     let requestId: bigint | undefined;
     let flags: number | undefined;
     let packetKey: string | undefined;
+    let receivedAt: Date | undefined;
     try {
       for (;;) {
         const part = info.recvActorPart(ZLINK_RECV_DONT_WAIT);
@@ -67,7 +70,8 @@ export class ZLinkSpotActorPacketDrain {
           if (parts.length > 0 && packetKey !== undefined) {
             this.continuations.set(packetKey, {
               owner: continuationOwner(parts[0], this.flowEnabled()),
-              parts: parts.splice(0)
+              parts: parts.splice(0),
+              receivedAt: receivedAt ?? (this.options.receivedAtClock ?? systemReceivedAtClock)()
             });
             return;
           }
@@ -78,6 +82,8 @@ export class ZLinkSpotActorPacketDrain {
         if (packetKey === undefined) {
           packetKey = currentPacketKey;
           const pending = this.continuations.get(currentPacketKey);
+          receivedAt =
+            pending?.receivedAt ?? (this.options.receivedAtClock ?? systemReceivedAtClock)();
           if (pending !== undefined) {
             if (isStreamHeaderMessage(part.message, this.flowEnabled())) {
               closeMessages(pending.parts);
@@ -125,7 +131,13 @@ export class ZLinkSpotActorPacketDrain {
         return;
       }
       if (noBindInfo !== undefined) {
-        await this.dispatchNoBindActorRequest(noBindInfo, actorId, parts, actorRef);
+        await this.dispatchNoBindActorRequest(
+          noBindInfo,
+          actorId,
+          parts,
+          actorRef,
+          receivedAt ?? (this.options.receivedAtClock ?? systemReceivedAtClock)()
+        );
       } else {
         await this.options.actorPacketHandler({
           origin: 'remote',
@@ -133,7 +145,8 @@ export class ZLinkSpotActorPacketDrain {
           parts,
           returnResponse: false,
           sourceSessionRid,
-          fallbackActorRef: actorRef as unknown as ActorRef | undefined
+          fallbackActorRef: actorRef as unknown as ActorRef | undefined,
+          receivedAt
         });
       }
     } finally {
@@ -188,7 +201,8 @@ export class ZLinkSpotActorPacketDrain {
     info: ZLinkBackendActorRecvInfo,
     actorId: string,
     parts: readonly Message[],
-    actorRef: ZLinkBackendActorRef | undefined
+    actorRef: ZLinkBackendActorRef | undefined,
+    receivedAt: Date
   ): Promise<void> {
     try {
       const response = await this.options.actorPacketHandler?.({
@@ -197,7 +211,8 @@ export class ZLinkSpotActorPacketDrain {
         parts,
         returnResponse: true,
         sourceSessionRid: info.sourceSessionRid,
-        fallbackActorRef: actorRef as unknown as ActorRef | undefined
+        fallbackActorRef: actorRef as unknown as ActorRef | undefined,
+        receivedAt
       });
       this.options.replyActorNoBind?.(
         info,