@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -6,35 +6,35 @@ import type {
   ZLinkSpot,
   ZLinkSpotActorJoinResult
 } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import { ZLinkBackendSpotDispatchEvent } from '../backend/contracts';
-import type {
-  ZLinkBackendActorRef,
-  ZLinkBackendActorRecvInfo,
-  ZLinkBackendReceived,
-  ZLinkBackendSpot,
-  ZLinkBackendTopicMessage
+import type { ZLinkRemoteBoundSessionTarget } from '../actors';
+import type { ZLinkActorHandoffPacket, ZLinkActorHandoffResult } from '../actors/actor-handoff';
+import type { ZLinkApplicationWorkClaim } from '../admission';
+import {
+  type ZLinkBackendActorRecvInfo,
+  type ZLinkBackendActorRef,
+  type ZLinkBackendSpot,
+  type ZLinkBackendTopicMessage,
+  ZLinkBackendSpotDispatchEvent
 } from '../backend/contracts';
-import type { Message } from '../../contracts/Common/Message';
+
 import type { RequestResult } from '../backend/runtime-values';
-type RuntimeMessage = Message;
-import type { ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkDispatchErrorReporter } from '../channels';
 import { ZLinkSpotActorLifecycleDrain } from './spot-actor-lifecycle-drain';
+import type { ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
 import { ZLinkSpotActorPacketDrain, type ZLinkActorDispatchPart } from './spot-actor-packet-drain';
-import { ZLINK_RECV_DONT_WAIT } from './spot-native-flags';
-import { ZLinkSpotNativeActorJoinAdmission } from './spot-native-actor-join-admission';
-import { ZLinkSpotRoutedFrameDispatch } from './spot-routed-frame-dispatch';
-import { ZLinkSpotSubscriptionDispatch } from './spot-subscription-dispatch';
 import type { ZLinkSpotHandlerRegistration } from './spot-handler-registry';
-import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import type { ZLinkApplicationWorkClaim } from '../admission';
-import type { ZLinkActorHandoffPacket, ZLinkActorHandoffResult } from '../actors/actor-handoff';
-import type { ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
+import { ZLinkSpotRoutedFrameDispatch } from './spot-routed-frame-dispatch';
 import type {
   ZLinkSpotActorTransferRuntime,
   ZLinkSpotBoundSessionRuntime
 } from './spot-runtime-ports';
+import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
+import { ZLinkSpotSubscriptionDispatch } from './spot-subscription-dispatch';
+const ACTOR_JOIN_POLL_INTERVAL_MS = 5;
+
+type RuntimeMessage = Message;
 
 const ZLINK_SPOT_DISPATCH_SUBJECT_SPOT = 1;
 const ZLINK_SPOT_DISPATCH_SUBJECT_CHANNEL_DEALER = 3;
@@ -63,11 +63,11 @@ interface ZLinkSpotActorAdmissionRuntime {
         readonly kind: 'enabled';
         readonly runtime: ZLinkSpotActorTransferRuntime;
       };
-  readonly commitNativeActor?: (actor: ZLinkActor) => Promise<void>;
   readonly commitActorDeparture?: (actorId: string) => void;
   readonly commitTransferredActor?: (
     actor: ZLinkActor,
-    backlog: readonly ZLinkActorHandoffPacket[]
+    backlog: readonly ZLinkActorHandoffPacket[],
+    sealedSession: ZLinkRemoteBoundSessionTarget | undefined
   ) => Promise<readonly ZLinkActorHandoffResult[]>;
 }
 
@@ -76,8 +76,7 @@ interface ZLinkSpotActorPacketRuntime {
   readonly bindRemoteSession?: (
     actor: ZLinkBackendActorRef,
     sourceNodeRid: RoutingId,
-    sourceSessionRid: RoutingId,
-    declaredTarget?: ZLinkRemoteBoundSessionTarget
+    sourceSessionRid: RoutingId
   ) => void;
   readonly replyNoBind?: (
     info: ZLinkBackendActorRecvInfo,
@@ -92,7 +91,6 @@ export interface ZLinkDetachedTaskRunner {
 
 interface ZLinkSpotActorJoinDispatchOptions {
   readonly nativeSpot: ZLinkBackendSpot;
-  readonly createReceived: () => ZLinkBackendReceived;
   readonly createTopicMessage: () => ZLinkBackendTopicMessage;
   readonly serial: ZLinkSpotSerialTurnExecutor;
   readonly actors: ZLinkSpotActorAdmissionRuntime;
@@ -106,13 +104,10 @@ interface ZLinkSpotActorJoinDispatchOptions {
 }
 
 export class ZLinkSpotActorJoinDispatch {
-  private draining = false;
-  private redrainRequested = false;
   private readonly nativeSpotId: string;
   private readonly subscriptions: ZLinkSpotSubscriptionDispatch;
   private readonly actorLifecycleDrain: ZLinkSpotActorLifecycleDrain;
   private readonly actorPacketDrain: ZLinkSpotActorPacketDrain;
-  private readonly nativeActorJoinAdmission: ZLinkSpotNativeActorJoinAdmission;
   private readonly routedFrames: ZLinkSpotRoutedFrameDispatch;
   private readonly nativeSpot: ZLinkBackendSpot;
 
@@ -137,19 +132,7 @@ export class ZLinkSpotActorJoinDispatch {
       waitIdle: waitSpotDispatchIdle,
       flowEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
     });
-    this.nativeActorJoinAdmission = new ZLinkSpotNativeActorJoinAdmission({
-      nativeSpot: options.nativeSpot,
-      serial: options.serial,
-      resolveActor: actors.resolveActor,
-      getTarget: actors.getTarget,
-      defaultAccept: actors.defaultAccept,
-      commitAcceptedActor: actors.commitNativeActor,
-      messageSerializers: options.messageSerializers,
-      dispatchErrors: options.dispatchErrors
-    });
     this.routedFrames = new ZLinkSpotRoutedFrameDispatch({
-      nativeSpot: options.nativeSpot,
-      createReceived: options.createReceived,
       nativeSpotId: this.nativeSpotId,
       serial: options.serial,
       resolveActor: actors.resolveActor,
@@ -161,7 +144,7 @@ export class ZLinkSpotActorJoinDispatch {
       bindRemoteSession:
         options.packets?.bindRemoteSession === undefined
           ? undefined
-          : (actor, sourceNodeRid, sourceSessionRid, declaredTarget) =>
+          : (actor, sourceNodeRid, sourceSessionRid) =>
               options.packets!.bindRemoteSession!(
                 {
                   actorId: actor.actorId,
@@ -169,8 +152,7 @@ export class ZLinkSpotActorJoinDispatch {
                   nodeRid: actor.nodeRid
                 },
                 sourceNodeRid,
-                sourceSessionRid,
-                declaredTarget
+                sourceSessionRid
               ),
       routedBoundSessionReceiver: options.boundSessionRuntime?.receiveRoutedBoundSession.bind(
         options.boundSessionRuntime
@@ -189,8 +171,7 @@ export class ZLinkSpotActorJoinDispatch {
       messageSerializers: options.messageSerializers,
       providerResolver: options.providerResolver,
       dispatchErrors: options.dispatchErrors,
-      claimApplicationWork: options.claimApplicationWork,
-      waitIdle: waitSpotDispatchIdle
+      claimApplicationWork: options.claimApplicationWork
     });
     this.subscriptions = new ZLinkSpotSubscriptionDispatch({
       nativeSpot: options.nativeSpot,
@@ -226,10 +207,6 @@ export class ZLinkSpotActorJoinDispatch {
       return;
     }
     this.nativeSpot.setDispatchHandler((info) => {
-      if (info.event === ZLinkBackendSpotDispatchEvent.ActorJoinReadable) {
-        this.runDetached('spot actor join drain', () => this.drain());
-        return;
-      }
       if (info.event === ZLinkBackendSpotDispatchEvent.SubscribeReadable) {
         this.runDetached('spot subscription drain', () => this.subscriptions.drain());
         return;
@@ -281,39 +258,8 @@ export class ZLinkSpotActorJoinDispatch {
     }
     void callback().catch(() => undefined);
   }
-
-  private async drain(): Promise<void> {
-    if (this.draining) {
-      this.redrainRequested = true;
-      return;
-    }
-    this.draining = true;
-    try {
-      do {
-        this.redrainRequested = false;
-        await this.drainAvailableActorJoins();
-      } while (this.redrainWasRequested());
-    } finally {
-      this.draining = false;
-    }
-  }
-
-  private redrainWasRequested(): boolean {
-    return this.redrainRequested;
-  }
-
-  private async drainAvailableActorJoins(): Promise<void> {
-    for (;;) {
-      const request = this.nativeSpot.recvActorJoin(ZLINK_RECV_DONT_WAIT);
-      if (request === null) {
-        await waitSpotDispatchIdle();
-        return;
-      }
-      await this.nativeActorJoinAdmission.admit(request);
-    }
-  }
 }
 
 function waitSpotDispatchIdle(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 5));
+  return new Promise((resolve) => setTimeout(resolve, ACTOR_JOIN_POLL_INTERVAL_MS));
 }

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

@@ -53,25 +53,27 @@ export class ZLinkSpotActorLifecycleDrain {
         continue;
       }
       if (actorRef === null || actorRef === undefined) continue;
-      await this.options.serial.execute(() => {
-        const actor = this.options.resolveActor(actorId);
-        if (actor === undefined) {
+      await this.options.serial.executeLifecycleOperation(() =>
+        this.options.serial.execute(() => {
+          const actor = this.options.resolveActor(actorId);
+          if (actor === undefined) {
+            return undefined;
+          }
+          const target = this.options.getTarget();
+          if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_JOINED) {
+            return target.onJoinedActor?.(actor);
+          }
+          if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_LEFT) {
+            return Promise.resolve(target.onLeaveActor?.(actor)).then(() => {
+              this.options.commitActorDeparture?.(actorId);
+            });
+          }
+          if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_DISCONNECTED) {
+            return target.onDisconnectActor?.(actor);
+          }
           return undefined;
-        }
-        const target = this.options.getTarget();
-        if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_JOINED) {
-          return target.onJoinedActor?.(actor);
-        }
-        if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_LEFT) {
-          return Promise.resolve(target.onLeaveActor?.(actor)).then(() => {
-            this.options.commitActorDeparture?.(actorId);
-          });
-        }
-        if (event.kind === ZLINK_SPOT_ACTOR_LIFECYCLE_DISCONNECTED) {
-          return target.onDisconnectActor?.(actor);
-        }
-        return undefined;
-      });
+        })
+      );
     }
   }
 }

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

@@ -1,23 +1,31 @@
-import type {
-  RoutingId,
-  ZLinkActor,
-  ZLinkMessageSerializer,
-  ZLinkSpot,
-  ZLinkSpotActorJoinResult
+import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
+import {
+  type RoutingId,
+  type ZLinkActor,
+  type ZLinkMessageSerializer,
+  type ZLinkSpot,
+  type ZLinkSpotActorJoinResult,
+  ZLinkEncodedPayload,
+  ZLinkMessage
 } from '../../contracts';
+
+import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import { ZLinkEncodedPayload, ZLinkMessage } from '../../contracts';
+import {
+  ZLinkDispatchErrorSurface,
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeDispatchErrorAction,
+  ZLinkRuntimeDispatchErrorReason
+} from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { throwIfAborted } from '../abort';
-import type { Message } from '../../contracts/Common/Message';
+import { ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME, ZLinkSpotActorDispatcher } from '../actors';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import { ZLinkConfigurationException } from '../configuration';
 import { ZLinkDispatchErrorReporter } from '../channels';
-import { ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME, ZLinkSpotActorDispatcher } from '../actors';
+import { ZLinkConfigurationException } from '../configuration';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
-import { routingIdsEqual } from '../routing-id';
 import type { ZLinkSpotActivation } from './spot-activation-state';
-import type { ZLinkSpotActorTransferRuntime } from './spot-runtime-ports';
 import type { ZLinkSpotRouteResolver } from './spot-routing-internal';
+import type { ZLinkSpotActorTransferRuntime } from './spot-runtime-ports';
 
 export interface ZLinkSpotActorMembershipOptions {
   readonly resolveActivation: (
@@ -39,8 +47,6 @@ export interface ZLinkSpotActorMembershipOptions {
   readonly actorTransferRuntime?: ZLinkSpotActorTransferRuntime;
 }
 
-export type ZLinkActorJoinRollback = () => Promise<void> | void;
-
 export class ZLinkSpotActorMembership {
   constructor(private readonly options: ZLinkSpotActorMembershipOptions) {}
 
@@ -48,43 +54,58 @@ export class ZLinkSpotActorMembership {
     spotId: RoutingId,
     actor: ZLinkActor,
     request: Message,
-    commit: (
-      spot: ZLinkSpot
-    ) => Promise<ZLinkActorJoinRollback | void> | ZLinkActorJoinRollback | void,
+    commit: (spot: ZLinkSpot) => Promise<void> | void,
     signal?: AbortSignal,
     leaveSource?: () => Promise<void>,
-    contentType = 'application/json'
+    contentType: string = ZlinkStreamContentType.Json
   ): Promise<ZLinkSpotActorJoinResult> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
+    return await this.runLifecycleOperation(activation, async () => {
+      return await this.admitActorJoinCore(
+        activation,
+        actor,
+        request,
+        commit,
+        signal,
+        leaveSource,
+        contentType
+      );
+    });
+  }
+
+  private async admitActorJoinCore(
+    activation: ZLinkSpotActivation,
+    actor: ZLinkActor,
+    request: Message,
+    commit: (spot: ZLinkSpot) => Promise<void> | void,
+    signal: AbortSignal | undefined,
+    leaveSource: (() => Promise<void>) | undefined,
+    contentType: string
+  ): Promise<ZLinkSpotActorJoinResult> {
     const dispatcher = this.createActorDispatcher(activation);
-    const transaction: {
-      rollbackExternal?: ZLinkActorJoinRollback;
-      rollbackMembership?: () => void;
-      committed: boolean;
-    } = { committed: false };
-    let response: ZLinkSpotActorJoinResult;
-    try {
-      response = await dispatcher.evaluateActorJoin(actor, request, contentType);
-      if (response.accepted) {
+    const response = await dispatcher.evaluateActorJoin(actor, request, contentType);
+    if (response.accepted) {
+      await commit(activation.spot);
+      activation.commitActorJoin(actor);
+      try {
+        await dispatcher.notifyJoinActor(actor);
+      } finally {
         if (leaveSource === undefined) {
-          await this.options.entrySpotCallbacks?.onLeaveActor(actor, signal);
+          void this.options.entrySpotCallbacks?.onLeaveActor(actor, signal).catch((error) => {
+            this.options.dispatchErrors?.report({
+              surface: ZLinkDispatchErrorSurface.SpotActor,
+              messageKind: ZLinkDispatchMessageKind.ActorSend,
+              reason: ZLinkRuntimeDispatchErrorReason.HandlerException,
+              action: ZLinkRuntimeDispatchErrorAction.Drop,
+              actorId: actor.context.actorId,
+              error
+            });
+          });
         } else {
           await leaveSource();
         }
-        await dispatcher.commitActorJoin(actor, async () => {
-          const rollback = await commit(activation.spot);
-          if (rollback !== undefined) transaction.rollbackExternal = rollback;
-          transaction.rollbackMembership = activation.commitActorJoin(actor);
-          transaction.committed = true;
-        });
-      }
-    } catch (error) {
-      if (transaction.committed) {
-        transaction.rollbackMembership?.();
-        await transaction.rollbackExternal?.();
       }
-      throw error;
     }
     return {
       accepted: response.accepted,
@@ -103,6 +124,17 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId, meshName);
+    await this.runLifecycleOperation(activation, () =>
+      this.leaveActorCore(activation, actor, signal, meshName)
+    );
+  }
+
+  private async leaveActorCore(
+    activation: ZLinkSpotActivation,
+    actor: ZLinkActor,
+    signal?: AbortSignal,
+    meshName?: string
+  ): Promise<void> {
     const localEntryNodeRid =
       (meshName === undefined ? undefined : this.options.nodeRidProvider?.(meshName)) ??
       this.options.entryNodeRidProvider?.() ??
@@ -123,24 +155,6 @@ export class ZLinkSpotActorMembership {
         'Spot actor leave requires an Entry Spot node routing id.'
       );
     }
-    const remoteEntry =
-      localEntryNodeRid !== undefined && !routingIdsEqual(entryNodeRid, localEntryNodeRid);
-    if (!remoteEntry) {
-      const leaveSource = async () => {
-        activation.beginActorTransfer(actor.context.actorId);
-        await activation.spot.onLeaveActor(actor);
-        activation.commitActorDeparture(actor.context.actorId);
-        this.options.actorTransferRuntime?.clearRoutedActor(actor);
-      };
-      // A Spot actor handler already owns this activation's serial turn.
-      // Complete its lifecycle transition inside that turn instead of trying
-      // to acquire a second turn for the same owner.
-      if (activation.serial.isCurrentTurn) {
-        await leaveSource();
-      } else {
-        await activation.serial.execute(leaveSource);
-      }
-    }
     const request = RuntimeMessage.from(Buffer.alloc(0));
     try {
       const context = actor.context as typeof actor.context & {
@@ -177,11 +191,13 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(async () => {
-      activation.beginActorTransfer(actor.context.actorId);
-      await activation.spot.onLeaveActor(actor);
-      activation.commitActorDeparture(actor.context.actorId);
-    });
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(async () => {
+        activation.beginActorTransfer(actor.context.actorId);
+        await activation.spot.onLeaveActor(actor);
+        activation.commitActorDeparture(actor.context.actorId);
+      })
+    );
   }
 
   async prepareActorLeaveForTransfer(
@@ -191,12 +207,16 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(() => activation.spot.onLeaveActor(actor));
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(() => activation.spot.onLeaveActor(actor))
+    );
   }
 
   async commitActorLeaveAfterTransfer(spotId: RoutingId, actorId: string): Promise<void> {
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(() => activation.commitActorDeparture(actorId));
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(() => activation.commitActorDeparture(actorId))
+    );
   }
 
   async restoreActorAfterFailedTransfer(
@@ -206,24 +226,26 @@ export class ZLinkSpotActorMembership {
   ): Promise<void> {
     throwIfAborted(signal);
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(async () => {
-      activation.cancelActorTransfer(actor.context.actorId);
-      await activation.spot.onJoinedActor(actor);
-    });
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(async () => {
+        activation.cancelActorTransfer(actor.context.actorId);
+        await activation.spot.onJoinedActor(actor);
+      })
+    );
   }
 
   async beginActorTransfer(spotId: RoutingId, actorId: string): Promise<void> {
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(() => {
-      activation.beginActorTransfer(actorId);
-    });
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(() => activation.beginActorTransfer(actorId))
+    );
   }
 
   async cancelActorTransfer(spotId: RoutingId, actorId: string): Promise<void> {
     const activation = this.requireActivation(spotId);
-    await activation.serial.execute(() => {
-      activation.cancelActorTransfer(actorId);
-    });
+    await this.runLifecycleOperation(activation, () =>
+      activation.serial.execute(() => activation.cancelActorTransfer(actorId))
+    );
   }
 
   async notifyJoinedActorDisconnected(
@@ -252,6 +274,16 @@ export class ZLinkSpotActorMembership {
     return activation;
   }
 
+  private async runLifecycleOperation<T>(
+    activation: ZLinkSpotActivation,
+    operation: () => Promise<T> | T
+  ): Promise<T> {
+    const pending = activation.serial.executeLifecycleOperation(operation);
+    return activation.serial.isCurrentTurn
+      ? await activation.serial.currentTurn!.yieldFrameworkPromise(pending)
+      : await pending;
+  }
+
   private createActorDispatcher(activation: ZLinkSpotActivation): ZLinkSpotActorDispatcher {
     return new ZLinkSpotActorDispatcher({
       registry: activation.actorHandlers,

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

@@ -24,7 +24,6 @@ import { createInboundFlow, currentFlowContext, runWithFlow } from '../diagnosti
 import { streamSessionIdFromRoutingId } from '../streams/managed-stream';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors';
 import {
-  actorMessageFollowContext,
   ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET,
   ZLinkSpotActorDispatcher,
   ZLinkSpotActorHandlerRegistryRuntime
@@ -104,10 +103,6 @@ interface ZLinkSpotActorPacketDispatchOptions {
     | Promise<{ readonly handled: boolean; readonly response?: unknown } | undefined>
     | { readonly handled: boolean; readonly response?: unknown }
     | undefined;
-  readonly onRemoteBoundSessionTarget?: (
-    actorId: string,
-    target: ZLinkRemoteBoundSessionTarget | undefined
-  ) => void;
   readonly onDisconnectActor: (actor: ZLinkActor) => Promise<void>;
   readonly actorResponseSender?: (
     actor: ZLinkActor,
@@ -210,16 +205,6 @@ export class ZLinkSpotActorPacketDispatch {
         ) {
           return undefined;
         }
-        if (
-          remoteBoundSessionTarget !== undefined &&
-          actorMessageFollowContext(fallbackActorRef) === undefined
-        ) {
-          // A replayed handoff/Message Follow packet keeps its captured Session
-          // route solely for that packet's response. It cannot republish the
-          // predecessor route over a binding already confirmed by a later Actor
-          // owner turn.
-          this.options.onRemoteBoundSessionTarget?.(actorId, remoteBoundSessionTarget);
-        }
         const routed = await this.options.routeBeforeLocal?.(delivery);
         if (routed?.handled === true) {
           return routed.response;
@@ -239,7 +224,6 @@ export class ZLinkSpotActorPacketDispatch {
           );
         }
         if (header.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
-          this.options.onRemoteBoundSessionTarget?.(actorId, undefined);
           await this.options.onDisconnectActor(actor);
           return undefined;
         }

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

@@ -5,7 +5,7 @@ import {
 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 type { ZLinkRemoteActorPacketTarget } from '../actors';
 import { decodeStreamHeader, messageToBytes, ZLinkStreamMessageKind } from '../streams/protocol';
 import {
   decodeRemoteActorSessionBinding,
@@ -25,8 +25,7 @@ interface ZLinkSpotActorPacketRelayDispatchOptions {
   readonly bindRemoteSession?: (
     actor: ActorRef,
     sourceNodeRid: RoutingId,
-    sourceSessionRid: RoutingId,
-    declaredTarget?: ZLinkRemoteBoundSessionTarget
+    sourceSessionRid: RoutingId
   ) => void;
   readonly flowEnabled?: () => boolean;
 }
@@ -81,18 +80,7 @@ export class ZLinkSpotActorPacketRelayDispatch {
             'Remote actor session binding source did not match the declared session node.'
           );
         }
-        this.options.bindRemoteSession(
-          actorRef,
-          declaredSourceNodeRid,
-          binding.sessionRid,
-          remoteBoundSessionTarget === undefined
-            ? undefined
-            : {
-                ...remoteBoundSessionTarget,
-                sessionNodeRid: declaredSourceNodeRid,
-                sessionRid: binding.sessionRid
-              }
-        );
+        this.options.bindRemoteSession(actorRef, declaredSourceNodeRid, binding.sessionRid);
         if (hasReplyToken(received.replyToken)) {
           submitSpotRouteBridgeReply(received, actorPacketRelay.envelope, {
             ok: true,

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

@@ -26,7 +26,7 @@ import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 
 interface ZLinkEntrySpotContextOptions {
   readonly spotId: SpotId;
-  readonly objectGeneration: number;
+  readonly objectGeneration: bigint;
   readonly nodeRid: RoutingId;
   readonly handlers: ZLinkSpotHandlerRegistry;
   readonly outbound: ZLinkSpotOutbound;
@@ -47,7 +47,7 @@ interface ZLinkEntrySpotContextOptions {
 interface ZLinkSpotContextOptions {
   readonly meshName: string;
   readonly spotId: SpotId;
-  readonly objectGeneration: number;
+  readonly objectGeneration: bigint;
   readonly handlers: ZLinkSpotHandlerRegistry;
   readonly outbound: ZLinkSpotOutbound;
   readonly timers: ZLinkSpotTimerRegistry;
@@ -263,7 +263,7 @@ function withImmutableSpotIdentity<
   T extends {
     readonly meshName: string;
     readonly spotId: SpotId;
-    readonly objectGeneration: number;
+    readonly objectGeneration: bigint;
     readonly nodeRid: RoutingId;
   }
 >(context: T): T {