@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,3 +1,6 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation } from '../foundation/operation-registry';
+import { inspectRuntime } from '../internal-observation';
 import { type ActorRef, type RoutingId, ZLinkFrameworkException } from '../../contracts';
 
 import type { Message } from '../../contracts/Common/Message';
@@ -20,7 +23,6 @@ import {
   internalFrameworkErrorKind,
   ZLinkFrameworkInternalErrorKind
 } from '../framework-errors-internal';
-import { waitRequestReply } from '../messaging/request-deadline';
 import {
   decodeRoutingId,
   encodeRoutingIdStorageHex,
@@ -49,7 +51,6 @@ 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';
 import type { ZLinkRemoteBoundSessionTarget } from './actor-runtime-state';
 
 export const DEFAULT_MESSAGE_FOLLOW_DURATION_MS =
@@ -57,6 +58,7 @@ export const DEFAULT_MESSAGE_FOLLOW_DURATION_MS =
 export const RELOCATED_REQUEST_OWNED_BY_REQUESTER = Symbol('relocated request owned by requester');
 
 export interface ZLinkActorHandoffPacket {
+  requestOperation?: PendingOperation<unknown>;
   readonly index: number;
   readonly header: string;
   readonly payload: string;
@@ -247,6 +249,7 @@ interface MessageFollowRoute {
 }
 
 export interface ZLinkActorHandoffCoordinatorOptions {
+  readonly requests?: RequestRuntime;
   readonly routedTransport: ZLinkActorRoutedJoinTransport;
   readonly messageFollowDurationMs?: number;
   readonly requestTimeoutMs?: number;
@@ -303,6 +306,17 @@ function requireExactTargetOwnerFence(
 
 /** Owns packet ordering from relocation start through Message Follow removal. */
 export class ZLinkActorHandoffCoordinator {
+  private readonly requests: RequestRuntime;
+  [inspectRuntime]() {
+    return Object.freeze({
+      replyRouteCount: this.replyRoutes.size,
+      hasMessageFollowRoute: (actorId: string, actorRef: ActorRef) =>
+        this.hasMessageFollowRouteForStaleRef(actorId, actorRef),
+      tenureAuthorityOwnerGeneration: (actorId: string, actorRef: ActorRef) =>
+        this.tenureAuthorityOwnerGeneration(actorId, actorRef)
+    });
+  }
+
   private readonly active = new Map<string, ActiveHandoff>();
   // Each route is stored once: Actor -> native fence -> location owner id.
   // Native ingress has the complete fence except the location owner's text id.
@@ -324,6 +338,7 @@ export class ZLinkActorHandoffCoordinator {
   private readonly replyRoutes = new Map<string, ReplyRoute>();
 
   constructor(private readonly options: ZLinkActorHandoffCoordinatorOptions) {
+    this.requests = options.requests ?? new RequestRuntime();
     this.messageFollowDurationMs =
       options.messageFollowDurationMs ?? DEFAULT_MESSAGE_FOLLOW_DURATION_MS;
   }
@@ -855,7 +870,8 @@ export class ZLinkActorHandoffCoordinator {
     deadlineUnixMs?: number,
     messageFollowOrigin?: ZLinkMessageFollowOrigin,
     provisionalReplay?: ZLinkActorHandoffDispatch,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ): Promise<unknown> | undefined {
     let incomingContext = actorMessageFollowContext(fallbackActorRef);
     const originalDeadlineUnixMs =
@@ -930,7 +946,8 @@ export class ZLinkActorHandoffCoordinator {
         remoteBoundSessionTarget,
         fallbackActorRef,
         context,
-        messageFollowOrigin
+        messageFollowOrigin,
+        requestOperation
       );
       handoff.pendingBytes += packetBytes(packet);
       this.options.onMarker?.('handoff_backlog', actorId, packet.index);
@@ -1042,7 +1059,8 @@ export class ZLinkActorHandoffCoordinator {
               remoteBoundSessionTarget,
               fallbackActorRef,
               incomingContext,
-              messageFollowOrigin
+              messageFollowOrigin,
+              requestOperation
             );
             return this.enqueueMessageFollow(followRoute, actorId, packet, onAdmitted);
           }
@@ -1099,7 +1117,8 @@ export class ZLinkActorHandoffCoordinator {
       remoteBoundSessionTarget,
       fallbackActorRef,
       context,
-      messageFollowOrigin
+      messageFollowOrigin,
+      requestOperation
     );
     return this.enqueueMessageFollow(followRoute, actorId, packet, onAdmitted);
   }
@@ -1677,14 +1696,22 @@ export class ZLinkActorHandoffCoordinator {
       replyRouteId: context.replyRouteId,
       result
     });
+    packet.requestOperation?.setFailureDispatcher(reject);
     onAdmitted?.();
     entry.tail = entry.tail.then(async () => {
       try {
-        resolve(await this.relayMessageFollow(actorId, entry, packet));
+        if (packet.requestOperation !== undefined && !packet.requestOperation.isPending()) {
+          resolve(await packet.requestOperation.promise);
+        } else {
+          await this.relayMessageFollow(actorId, entry, packet, resolve, reject);
+        }
+        await result;
       } catch (error) {
         this.options.onMarker?.('message_follow_rejected', actorId);
         reject(error);
       } finally {
+        packet.requestOperation?.clearFailureDispatcher(reject);
+        delete packet.requestOperation;
         entry.queuedMessages--;
         entry.queuedBytes -= bytes;
       }
@@ -1695,8 +1722,10 @@ export class ZLinkActorHandoffCoordinator {
   private async relayMessageFollow(
     actorId: string,
     entry: MessageFollowRoute,
-    packet: ZLinkActorHandoffPacket
-  ): Promise<unknown> {
+    packet: ZLinkActorHandoffPacket,
+    resolve: (value: unknown) => void,
+    reject: (reason: unknown) => void
+  ): Promise<void> {
     const { target, targetActorRef } = entry;
     const context = packet.messageFollowContext;
     let advanced: ZLinkActorMessageFollowContext;
@@ -1723,53 +1752,52 @@ export class ZLinkActorHandoffCoordinator {
         packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
       });
       await this.messageFollowRelayed(actorId, entry, packet, advanced);
-      return undefined;
+      resolve(undefined);
+      return;
     }
     const timeoutMs = this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    const relayDeadlineMs = performance.now() + timeoutMs;
-    if (this.options.routedTransport.requestRawToSpot === undefined) {
-      const reply = await waitRequestReply(
-        this.options.routedTransport.requestToSpot<Record<string, unknown>>(target, payload, {
-          packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-          timeoutMs
-        }),
-        actorId,
-        relayDeadlineMs
-      );
-      if (reply.ok === false) {
-        throw actorRelayError(actorId, reply.errorKind, reply.error);
-      }
-      await this.messageFollowRelayed(actorId, entry, packet, advanced);
-      return reply.response;
+    const requestOperation = packet.requestOperation ?? this.requests.begin(timeoutMs);
+    if (packet.requestOperation === undefined) {
+      // The existing business result delivers failures from this entry alias.
+      void requestOperation.promise.catch(() => {});
+      requestOperation.setFailureDispatcher(reject);
+    }
+    if (!requestOperation.isPending()) {
+      resolve(await requestOperation.promise);
+      return;
     }
-    const response = await waitRequestReply(
-      requestRoutedJsonReply(
-        this.options.routedTransport,
+    try {
+      this.options.routedTransport.requestToSpot<Record<string, unknown>>(
         target,
         payload,
-        { timeoutMs },
-        `Actor Message Follow raw request is not available for '${actorId}'.`,
-        (parts) => {
-          if (parts.length === 0) {
-            throw new Error(`Actor Message Follow reply was empty for '${actorId}'.`);
-          }
-          const reply = JSON.parse(parts[0].getString('utf8')) as {
-            readonly ok?: boolean;
-            readonly response?: unknown;
-            readonly error?: unknown;
-            readonly errorKind?: unknown;
-          };
-          if (reply.ok === false) {
-            throw actorRelayError(actorId, reply.errorKind, reply.error);
+        { packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, timeoutMs, requestOperation },
+        {
+          operationCompleted: (_id, value) => {
+            requestOperation.clearFailureDispatcher(reject);
+            if (!requestOperation.isPending()) return;
+            void (async () => {
+              const reply = value as Record<string, unknown>;
+              if (reply.ok === false) throw actorRelayError(actorId, reply.errorKind, reply.error);
+              await this.messageFollowRelayed(actorId, entry, packet, advanced);
+              if (packet.requestOperation === undefined) requestOperation.complete(reply.response);
+              resolve(reply.response);
+            })().catch((error) => {
+              if (packet.requestOperation === undefined) requestOperation.fail(error);
+              reject(error);
+            });
+          },
+          operationFailed: (_id, error) => {
+            requestOperation.clearFailureDispatcher(reject);
+            if (packet.requestOperation === undefined) requestOperation.fail(error);
+            reject(error);
           }
-          return reply.response;
         }
-      ),
-      actorId,
-      relayDeadlineMs
-    );
-    await this.messageFollowRelayed(actorId, entry, packet, advanced);
-    return response;
+      );
+    } catch (error) {
+      requestOperation.clearFailureDispatcher(reject);
+      if (packet.requestOperation === undefined) requestOperation.fail(error);
+      throw error;
+    }
   }
 
   private async messageFollowRelayed(
@@ -1920,12 +1948,13 @@ function encodePacket(
   remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget,
   fallbackActorRef?: ActorRef,
   messageFollowContext?: ZLinkActorMessageFollowContext,
-  messageFollowOrigin?: ZLinkMessageFollowOrigin
+  messageFollowOrigin?: ZLinkMessageFollowOrigin,
+  requestOperation?: PendingOperation<unknown>
 ): ZLinkActorHandoffPacket {
   if (messageFollowContext === undefined) {
     throw new Error('Actor handoff packet requires a Message Follow context.');
   }
-  return {
+  const packet: ZLinkActorHandoffPacket = {
     index,
     header: Buffer.from(parts[0].data()).toString('base64'),
     payload: Buffer.from(parts[1].data()).toString('base64'),
@@ -1956,6 +1985,12 @@ function encodePacket(
             nodeRid: String(fallbackActorRef.nodeRid)
           }
   };
+  if (requestOperation !== undefined)
+    Object.defineProperty(packet, 'requestOperation', {
+      value: requestOperation,
+      configurable: true
+    });
+  return packet;
 }
 
 function optionalBigInt(value: string | undefined): bigint | undefined {

package/src/runtime/actors/actor-join-deferred-scope.ts

@@ -31,8 +31,8 @@ class ActorJoinRegistrationScope {
     this.open = false;
   }
 
-  async prepareSealedJoins(): Promise<void> {
-    await this.prepareSealedJoinsCore();
+  prepareSealedJoins(): Promise<void> {
+    return this.prepareSealedJoinsCore();
   }
 
   private async prepareSealedJoinsCore(): Promise<void> {
@@ -40,8 +40,8 @@ class ActorJoinRegistrationScope {
       return;
     }
     this.prepared = true;
-    for (const intent of this.intents) {
-      await intent.prepare?.();
+    for (let index = 0; index < this.intents.length; index++) {
+      await this.intents[index]!.prepare?.();
     }
   }
 
@@ -62,8 +62,8 @@ class ActorJoinRegistrationScope {
   }
 
   private async execute(): Promise<void> {
-    for (const intent of this.intents) {
-      await intent.execute();
+    for (let index = 0; index < this.intents.length; index++) {
+      await this.intents[index]!.execute();
     }
   }
 }

package/src/runtime/actors/actor-local-native-join.ts

@@ -27,6 +27,7 @@ import {
 } from '../framework-errors-internal';
 import type { ZLinkLocationLifecycle } from '../locations';
 import { frameworkPayloadContentType } from '../messaging/payload-codec';
+import { remainingActorRequestTimeout } from './actor-request-deadline';
 import { routingIdsEqual, toBackendRoutingId } from '../routing-id';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkActorJoinRelocation } from './actor-join-relocation';
@@ -81,7 +82,8 @@ export class ZLinkLocalNativeActorJoin {
     request: Message,
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
-    completionOperationId?: ZLinkActorJoinOperationId
+    completionOperationId?: ZLinkActorJoinOperationId,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>> {
     if (signal?.aborted === true) throw createAbortError();
     const target = requireUserSpotRoute(spotRouteTarget, spotId);
@@ -100,7 +102,8 @@ export class ZLinkLocalNativeActorJoin {
         timeoutMs,
         signal,
         completionOperationId,
-        false
+        false,
+        deadlineAtMs
       );
     }
     return await this.joinLocal(
@@ -125,7 +128,8 @@ export class ZLinkLocalNativeActorJoin {
     request: Message,
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
-    completionOperationId?: ZLinkActorJoinOperationId
+    completionOperationId?: ZLinkActorJoinOperationId,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>> {
     if (signal?.aborted === true) throw createAbortError();
     const targetNodeRid = spotRouteTarget?.targetNodeRid ?? nodeRid;
@@ -147,7 +151,8 @@ export class ZLinkLocalNativeActorJoin {
         timeoutMs,
         signal,
         completionOperationId,
-        true
+        true,
+        deadlineAtMs
       );
     }
     const target = {
@@ -210,7 +215,8 @@ export class ZLinkLocalNativeActorJoin {
         storeSpotId,
         spotGeneration,
         target.spotKind === ZLinkSpotKind.Entry ? ZLinkSpotKind.Entry : ZLinkSpotKind.User,
-        node.status().lifecycleGeneration
+        node.status().lifecycleGeneration,
+        signal
       );
       const committedActor = node.restoreActorAuthority!(
         actor.context.actorId,
@@ -268,12 +274,18 @@ export class ZLinkLocalNativeActorJoin {
     submit: () => { readonly high: bigint; readonly low: bigint },
     completions: ZLinkMeshCompletionTable,
     timeoutMs: number | undefined,
-    signal: AbortSignal | undefined
+    signal: AbortSignal | undefined,
+    deadlineAtMs?: number
   ): Promise<ZLinkMeshCompletion> {
     // The operation ID identifies one Core request. Once it is submitted, a
     // NotConnected completion is terminal for that request; resubmitting it
     // could execute the target lifecycle twice after a delayed reply.
-    return submitJoinWhenConnected(() => completions.submit(submit, signal), timeoutMs, signal);
+    return submitJoinWhenConnected(
+      () => completions.submit(submit, signal),
+      timeoutMs,
+      signal,
+      deadlineAtMs
+    );
   }
 
   private async relocateRemoteActorJoin(
@@ -286,9 +298,10 @@ export class ZLinkLocalNativeActorJoin {
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
     completionOperationId: ZLinkActorJoinOperationId | undefined,
-    entrySpot: boolean
+    entrySpot: boolean,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>> {
-    const deadlineAtMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
+    deadlineAtMs ??= timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     const actorType = state.actorType;
     if (actorType === undefined) {
       throw createInternalFrameworkException(
@@ -324,6 +337,10 @@ export class ZLinkLocalNativeActorJoin {
     let admissionOperationId: ZLinkActorJoinOperationId | undefined;
     const admission = await this.waitForJoinCompletion(
       () => {
+        const remainingTimeoutMs = remainingActorRequestTimeout(
+          actor.context.actorId,
+          deadlineAtMs
+        );
         const legacyAdmission =
           canonicalAdmission === undefined
             ? legacyRemoteActorJoinPayload(actor, state, actorRef, target, request, relocationId)
@@ -335,7 +352,7 @@ export class ZLinkLocalNativeActorJoin {
                   actorRef,
                   toBackendRoutingId(target.targetNodeRid),
                   legacyAdmission!,
-                  timeoutMs
+                  remainingTimeoutMs
                 )
               : node.joinActorSpot(
                   actorRef,
@@ -343,7 +360,7 @@ export class ZLinkLocalNativeActorJoin {
                   toBackendRoutingId(target.spotId),
                   target.targetSpotGeneration!,
                   legacyAdmission!,
-                  timeoutMs
+                  remainingTimeoutMs
                 )
             : entrySpot
               ? node.joinActorEntrySpotCanonical!(
@@ -352,7 +369,7 @@ export class ZLinkLocalNativeActorJoin {
                   canonicalAdmission.request,
                   canonicalAdmission.actorFence,
                   canonicalAdmission.local,
-                  timeoutMs
+                  remainingTimeoutMs
                 )
               : node.joinActorSpotCanonical!(
                   actorRef,
@@ -362,14 +379,15 @@ export class ZLinkLocalNativeActorJoin {
                   canonicalAdmission.request,
                   canonicalAdmission.actorFence,
                   canonicalAdmission.local,
-                  timeoutMs
+                  remainingTimeoutMs
                 );
         admissionOperationId = operationId;
         return operationId;
       },
       completions,
       timeoutMs,
-      signal
+      signal,
+      deadlineAtMs
     );
     const control = admission.kindData;
     if (control?.kind !== 'actorJoinCompletion' || control.actor === null) {
@@ -613,11 +631,14 @@ function runtimeActorMeshName(
 async function submitJoinWhenConnected<T>(
   submit: () => T,
   timeoutMs: number | undefined,
-  signal: AbortSignal | undefined
+  signal: AbortSignal | undefined,
+  deadlineAtMs?: number
 ): Promise<T> {
-  const deadline =
+  const deadline = Math.min(
+    deadlineAtMs ?? Infinity,
     performance.now() +
-    Math.min(timeoutMs ?? LOCAL_JOIN_RESOLUTION_TIMEOUT_MS, LOCAL_JOIN_RESOLUTION_TIMEOUT_MS);
+      Math.min(timeoutMs ?? LOCAL_JOIN_RESOLUTION_TIMEOUT_MS, LOCAL_JOIN_RESOLUTION_TIMEOUT_MS)
+  );
   for (;;) {
     throwIfAborted(signal);
     try {

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

@@ -14,7 +14,7 @@ import {
 import type { ApplicationJobPermitPort } from '../application-jobs/contracts';
 
 export class ZLinkActorSerialExecutor {
-  private readonly scheduler: ZLinkSerialExecutionQueue;
+  readonly scheduler: ZLinkSerialExecutionQueue;
 
   constructor(
     private readonly actorId: string,

package/src/runtime/actors/actor-remote-joiner.ts

@@ -83,7 +83,8 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
     request: Message,
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
-    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId
+    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>> {
     throwIfAborted(signal);
     const node = this.node();
@@ -105,7 +106,8 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
       request,
       timeoutMs ?? this.options.actorTransferTimeoutMs,
       signal,
-      completionOperationId
+      completionOperationId,
+      deadlineAtMs
     );
     return this.withDeferredJoinFinalizer(actor, state, target, result, completionOperationId);
   }
@@ -117,7 +119,8 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
     request: Message,
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
-    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId
+    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>> {
     throwIfAborted(signal);
     const node = this.node();
@@ -152,7 +155,8 @@ export class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCoordinato
       request,
       timeoutMs ?? this.options.actorTransferTimeoutMs,
       signal,
-      completionOperationId
+      completionOperationId,
+      deadlineAtMs
     );
     return this.withDeferredJoinFinalizer(actor, state, target, result, completionOperationId);
   }

package/src/runtime/actors/actor-routed-join-transport.ts

@@ -1,3 +1,5 @@
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
+import type { ZLinkRequestResult } from '../messaging/request-result';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendSpot } from '../backend/contracts';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
@@ -13,7 +15,7 @@ export interface ZLinkActorRoutedJoinTransport {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal
-  ): Promise<TReply>;
+  ): ZLinkRequestResult<TReply>;
   submit?(
     routerChannelId: string,
     targetNodeRid: string,
@@ -36,6 +38,7 @@ export interface ZLinkActorRoutedJoinTransport {
     request: Message,
     options: {
       readonly timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       readonly signal?: AbortSignal;
       readonly onAdmitted?: () => void;
     }
@@ -46,10 +49,12 @@ export interface ZLinkActorRoutedJoinTransport {
     options: {
       readonly packetName?: string;
       readonly timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       readonly signal?: AbortSignal;
       readonly onAdmitted?: () => void;
-    }
-  ): Promise<TReply>;
+    },
+    destination?: OperationObserver<unknown, unknown>
+  ): ZLinkRequestResult<TReply>;
   requestFromSpotToSpot?<TReply = unknown>(
     sourceSpot: ZLinkBackendSpot,
     spotRouteTarget: ZLinkSpotRouteTarget,
@@ -57,16 +62,19 @@ export interface ZLinkActorRoutedJoinTransport {
     options: {
       readonly packetName?: string;
       readonly timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       readonly signal?: AbortSignal;
       readonly onAdmitted?: () => void;
-    }
-  ): Promise<TReply>;
+    },
+    destination?: OperationObserver<unknown, unknown>
+  ): ZLinkRequestResult<TReply>;
   requestRawFromSpotToSpot?(
     sourceSpot: ZLinkBackendSpot,
     spotRouteTarget: ZLinkSpotRouteTarget,
     request: Message,
     options: {
       readonly timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       readonly signal?: AbortSignal;
       readonly onAdmitted?: () => void;
     }

package/src/runtime/actors/actor-routed-json-request.ts

@@ -1,3 +1,4 @@
+import type { PendingOperation } from '../foundation/operation-registry';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -9,6 +10,7 @@ export async function tryRequestRoutedJson(
   payload: unknown,
   options: {
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
     readonly onAdmitted?: () => void;
   }
@@ -30,6 +32,7 @@ export async function requestRoutedJsonReply<T>(
   payload: unknown,
   options: {
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
     readonly onAdmitted?: () => void;
   },

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

@@ -109,7 +109,8 @@ export interface ZLinkActorJoinCoordinator {
     request: Message,
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
-    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId
+    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>>;
   joinEntrySpot(
     actor: ZLinkActor,
@@ -118,6 +119,7 @@ export interface ZLinkActorJoinCoordinator {
     request: Message,
     timeoutMs: number | undefined,
     signal: AbortSignal | undefined,
-    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId
+    completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId,
+    deadlineAtMs?: number
   ): Promise<ZLinkActorJoinRuntimeResult<Message>>;
 }

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

@@ -174,7 +174,7 @@ export class ZLinkActorRuntimeState {
   private spotMembershipEpochValue = 0n;
   private nativeActorRefValue: ZLinkBackendActorRef | undefined;
   private entryNodeRidValue: RoutingId | undefined;
-  private boundSessionValue: ZLinkRemoteBoundSessionTarget | undefined;
+  boundSessionValue: ZLinkRemoteBoundSessionTarget | undefined;
   private remoteActorPacketTargetValue: ZLinkRemoteActorPacketTarget | undefined;
   private createRequestPayloadValue: Buffer | undefined;
   private ownsLocationValue = false;