@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -31,8 +31,11 @@ import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import { throwIfAborted } from '../abort';
 import { ZLinkConfigurationException } from '../configuration';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import type {
-  ZLinkBackendReceived,
   ZLinkBackendSpot,
   ZLinkBackendSpotNode,
   ZLinkBackendTopicMessage
@@ -77,7 +80,7 @@ import type {
 } from './spot-actor-join-dispatch';
 import { ZLinkSpotActorAdmissionCoordinator } from './spot-actor-admission-coordinator';
 import type { ZLinkRouteToActorJoinPrewarm } from './spot-actor-packet-dispatch';
-import { ZLinkSpotActivation, ZLinkSpotCloseOccupiedError } from './spot-activation-state';
+import { ZLinkSpotActivation } from './spot-activation-state';
 import type { ZLinkSpotLocationClaim } from './spot-location-claim';
 import type {
   ZLinkSpotActorHandoffRuntime,
@@ -111,9 +114,9 @@ export interface ZLinkSpotActivationLifecycleOptions {
   readonly routedTransport?: ZLinkSpotRoutedTransport;
   readonly addressTransport?: ZLinkSpotAddressTransport;
   readonly spotRouterChannelIdForMesh?: (meshName: string) => string;
-  readonly channelMeshNameForChannel?: (channelName: string) => string | undefined;
   readonly providerResolver?: ZLinkProviderResolver;
   readonly dispatchErrors?: ZLinkDispatchErrorReporter;
+  readonly closeErrorSink?: import('../diagnostics/dispatch-error-port').ZLinkDispatchErrorSink;
   readonly runtimeEventPublisher?: ZLinkRuntimeEventPublisher;
   readonly workerRuntime: ZLinkWorkerRuntime;
   readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
@@ -123,14 +126,13 @@ export interface ZLinkSpotActivationLifecycleOptions {
     spotId: RoutingId,
     authority?: ZLinkNativeSpotAuthority
   ) => ZLinkBackendSpot | undefined;
-  readonly createReceived?: () => ZLinkBackendReceived;
   readonly createTopicMessage?: () => ZLinkBackendTopicMessage;
   readonly nativeSpotNodeProvider?: (meshName: string) => ZLinkBackendSpotNode | undefined;
   readonly actorResolver?: (actorId: string) => ZLinkActor | undefined;
   readonly actorTransferRuntime?: ZLinkSpotActorTransferRuntime;
   readonly boundSessionRuntime?: ZLinkSpotBoundSessionRuntime;
   readonly actorHandoffRuntime?: ZLinkSpotActorHandoffRuntime;
-  readonly detachedTaskRunner?: ZLinkDetachedTaskRunner;
+  readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
   readonly admission?: ZLinkRuntimeAdmissionGate;
   readonly statefulExecutionAllowed?: () => boolean;
   readonly leaveActor: (
@@ -139,11 +141,11 @@ export interface ZLinkSpotActivationLifecycleOptions {
     signal?: AbortSignal,
     meshName?: string
   ) => Promise<void>;
-  readonly closeSpot: (
-    meshName: string,
-    spotId: RoutingId,
-    signal?: AbortSignal,
-    reason?: ZLinkSpotCloseReason
+  /** Starts a context Close request after its calling turn has ended. */
+  readonly requestContextClose: (
+    activation: ZLinkSpotActivation,
+    objectGeneration: bigint,
+    signal?: AbortSignal
   ) => Promise<boolean>;
   readonly registerActivation: (activation: ZLinkSpotActivation) => void;
   readonly routeToActorJoinPrewarm?: ZLinkRouteToActorJoinPrewarm;
@@ -173,14 +175,19 @@ export class ZLinkSpotActivationLifecycle {
     {
       closingAttempted: boolean;
       timersDisposed: boolean;
+      serialDisposed: boolean;
       handlersDisposed: boolean;
+      actorDispatchDisposed: boolean;
       nativeDisposed: boolean;
       locationReleased: boolean;
-      inFlight?: Promise<void>;
+      inFlight?: Promise<unknown>;
     }
   >();
 
   constructor(private readonly options: ZLinkSpotActivationLifecycleOptions) {
+    if ((options.detachedTaskRunner as unknown) === undefined) {
+      throw new ZLinkConfigurationException('Spot activation requires a detached task runner.');
+    }
     this.actorAdmission = new ZLinkSpotActorAdmissionCoordinator(options);
   }
 
@@ -249,7 +256,7 @@ export class ZLinkSpotActivationLifecycle {
     const common = {
       meshName,
       spotId,
-      objectGeneration: toContextGeneration(objectGeneration),
+      objectGeneration: objectGeneration,
       outbound,
       timers,
       serial,
@@ -259,7 +266,7 @@ export class ZLinkSpotActivationLifecycle {
       providerResolver: this.options.providerResolver,
       runtimeEventPublisher: this.options.runtimeEventPublisher,
       workerRuntime: this.options.workerRuntime,
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(objectGeneration, () => activation)
     };
     const context =
       objectKind === 'user_spot'
@@ -314,6 +321,7 @@ export class ZLinkSpotActivationLifecycle {
           objectKind === 'user_spot'
             ? {
                 kind: 'user',
+                objectGeneration,
                 executionMode,
                 relocationCoordinationMode:
                   this.options.userSpotRelocationCoordinationMode?.(
@@ -336,11 +344,22 @@ export class ZLinkSpotActivationLifecycle {
       this.options.registerActivation(activation);
       return activation;
     } catch (error) {
-      await timers.dispose().catch(() => undefined);
-      if (instance !== undefined) {
-        await disposeLifecycleHandlers(instance).catch(() => undefined);
+      const cleanup = await Promise.allSettled([
+        timers.dispose(),
+        ...(instance === undefined
+          ? []
+          : [disposeLifecycleHandlers(instance, this.options.detachedTaskRunner)]),
+        ...(nativeSpot === undefined ? [] : [Promise.resolve().then(() => nativeSpot.dispose())])
+      ]);
+      const cleanupErrors = cleanup
+        .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+        .map((result) => result.reason);
+      if (cleanupErrors.length > 0) {
+        throw new AggregateError(
+          [error, ...cleanupErrors],
+          `Spot '${spotId}' relocation materialization cleanup failed.`
+        );
       }
-      await nativeSpot?.dispose().catch(() => undefined);
       throw error;
     }
   }
@@ -351,9 +370,10 @@ export class ZLinkSpotActivationLifecycle {
     implementation: Type<TSpot>,
     spotId: RoutingId,
     objectGeneration: bigint,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    serialOwner?: ZLinkSpotActivation
   ): Promise<ZLinkSpotActivation> {
-    const serial = new ZLinkSpotSerialTurnExecutor(true, spotId);
+    const serial = serialOwner?.serial ?? new ZLinkSpotSerialTurnExecutor(true, spotId);
     const serialExecutor = new ZLinkSpotSerialExecutor(
       serial,
       ZLinkUserSpotExecutionMode.SpotWide,
@@ -387,7 +407,7 @@ export class ZLinkSpotActivationLifecycle {
     const context = createInstanceSpotContext({
       meshName,
       spotId,
-      objectGeneration: toContextGeneration(objectGeneration),
+      objectGeneration: objectGeneration,
       handlers: instanceHandlers,
       outbound,
       timers,
@@ -398,7 +418,7 @@ export class ZLinkSpotActivationLifecycle {
       providerResolver: this.options.providerResolver,
       runtimeEventPublisher: this.options.runtimeEventPublisher,
       workerRuntime: this.options.workerRuntime,
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(objectGeneration, () => activation)
     });
     instance = await createFreshProviderInstance(
       implementation,
@@ -421,6 +441,7 @@ export class ZLinkSpotActivationLifecycle {
       timers,
       actorHandlers,
       handlers,
+      executionBarrier: serialOwner?.executionBarrier,
       externalActorCount: () => this.options.actorCountProvider?.(spotId) ?? 0
     });
     try {
@@ -438,14 +459,21 @@ export class ZLinkSpotActivationLifecycle {
           signal
         }
       );
-      await serial.execute(() => instance!.onInitialize?.());
+      await (serialOwner === undefined
+        ? serial.execute(() => instance!.onInitialize?.())
+        : serial.postBarrierTurn(() => instance!.onInitialize?.()));
       this.options.registerActivation(activation);
       return activation;
     } catch (error) {
-      await timers.dispose();
-      await disposeLifecycleHandlers(instance);
+      const cleanup = await Promise.allSettled([
+        timers.dispose(),
+        disposeLifecycleHandlers(instance, this.options.detachedTaskRunner)
+      ]);
+      const cleanupErrors = cleanup
+        .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+        .map((result) => result.reason);
       throw new AggregateError(
-        [error],
+        [error, ...cleanupErrors],
         `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`
       );
     }
@@ -474,7 +502,7 @@ export class ZLinkSpotActivationLifecycle {
       errors.push(error);
     }
     try {
-      await disposeLifecycleHandlers(activation.spot);
+      await disposeLifecycleHandlers(activation.spot, this.options.detachedTaskRunner);
     } catch (error) {
       errors.push(error);
     }
@@ -487,16 +515,6 @@ export class ZLinkSpotActivationLifecycle {
     }
   }
 
-  resourcesReleased(activation: ZLinkSpotActivation): boolean {
-    const state = this.cleanupStates.get(activation);
-    return (
-      state?.timersDisposed === true &&
-      state.handlersDisposed === true &&
-      state.nativeDisposed === true &&
-      state.locationReleased === true
-    );
-  }
-
   async create<TSpot extends ZLinkSpot>(
     meshName: string,
     spotType: Type<TSpot>,
@@ -585,7 +603,7 @@ export class ZLinkSpotActivationLifecycle {
     const context = createSpotContext({
       meshName,
       spotId,
-      objectGeneration: toContextGeneration(spotGeneration),
+      objectGeneration: spotGeneration,
       handlers,
       outbound,
       timers,
@@ -607,7 +625,7 @@ export class ZLinkSpotActivationLifecycle {
       ensureOperationAllowed: () => activation?.ensureContextOperationAllowed(),
       leaveActor: (actor, contextSignal) =>
         this.options.leaveActor(spotId, actor, contextSignal, meshName),
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(spotGeneration, () => activation)
     });
     try {
       spot = await createFreshProviderInstance(spotType, this.options.providerResolver, context);
@@ -624,6 +642,7 @@ export class ZLinkSpotActivationLifecycle {
         spotId,
         domain: {
           kind: 'user',
+          objectGeneration: spotGeneration,
           executionMode,
           relocationCoordinationMode:
             this.options.userSpotRelocationCoordinationMode?.(meshName, spotType) ??
@@ -667,9 +686,13 @@ export class ZLinkSpotActivationLifecycle {
         } else {
           const partialCleanup = await Promise.allSettled([
             timers.dispose(),
-            ...(spot === undefined ? [] : [disposeLifecycleHandlers(spot)]),
-            nativeSpot.dispose(),
-            this.options.locationClaim.release(locationClaim.meshName, spotId)
+            ...(spot === undefined
+              ? []
+              : [disposeLifecycleHandlers(spot, this.options.detachedTaskRunner)]),
+            Promise.resolve().then(() => nativeSpot.dispose()),
+            Promise.resolve().then(() =>
+              this.options.locationClaim.release(locationClaim.meshName, spotId)
+            )
           ]);
           const partialErrors = partialCleanup
             .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
@@ -716,7 +739,7 @@ export class ZLinkSpotActivationLifecycle {
     const context = createSpotContext({
       meshName,
       spotId,
-      objectGeneration: toContextGeneration(objectGeneration),
+      objectGeneration: objectGeneration,
       handlers,
       outbound,
       timers,
@@ -738,7 +761,7 @@ export class ZLinkSpotActivationLifecycle {
       ensureOperationAllowed: () => activation?.ensureContextOperationAllowed(),
       leaveActor: (actor, contextSignal) =>
         this.options.leaveActor(spotId, actor, contextSignal, meshName),
-      close: this.contextClose(meshName, spotId, () => activation)
+      close: this.contextClose(objectGeneration, () => activation)
     });
     spot = await createFreshProviderInstance(spotType, this.options.providerResolver, context);
     Object.defineProperty(spot, 'context', {
@@ -751,6 +774,7 @@ export class ZLinkSpotActivationLifecycle {
       spotId,
       domain: {
         kind: 'user',
+        objectGeneration,
         executionMode,
         relocationCoordinationMode:
           this.options.userSpotRelocationCoordinationMode?.(meshName, spotType) ??
@@ -777,67 +801,59 @@ export class ZLinkSpotActivationLifecycle {
   }
 
   private contextClose(
-    meshName: string,
-    spotId: RoutingId,
+    objectGeneration: bigint,
     activationProvider: () => ZLinkSpotActivation | undefined
   ): (signal?: AbortSignal) => Promise<boolean> {
-    return async (signal) => {
+    return (signal) => {
       const activation = activationProvider();
-      // Native callbacks can cross a promise boundary that does not retain
-      // the serial turn context. Queue the close before calling the manager
-      // so the callback never waits for work behind its own serial turn.
-      if (activation?.serial.isExecuting === true && !activation.serial.isCurrentTurn) {
-        activation.requestClose();
-        const retry = activation.serial.post(() =>
-          this.options.closeSpot(meshName, spotId, signal)
+      if (activation === undefined) {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.InvalidOperation,
+          'Spot context Close requires its active generation.'
         );
-        this.options.detachedTaskRunner?.runDetached(`spot close ${String(spotId)}`, async () => {
-          await retry;
-        });
-        if (this.options.detachedTaskRunner === undefined) {
-          void retry.catch(() => undefined);
-        }
-        return true;
       }
-      return await this.options.closeSpot(meshName, spotId, signal);
+      return this.options.requestContextClose(activation, objectGeneration, signal);
     };
   }
 
-  async close(
+  async sealForClose(
     activation: ZLinkSpotActivation,
-    signal?: AbortSignal,
-    reason = ZLinkSpotCloseReason.ExplicitClose
+    seal: import('../execution').ZLinkExecutionBarrierSeal,
+    signal?: AbortSignal
   ): Promise<void> {
-    const seal = activation.sealExecution();
-    await this.closeAfterSeal(activation, seal, signal, reason);
+    await activation.waitForExecutionQuiescence(seal, signal);
+    if (!activation.commitExecutionSeal(seal)) {
+      throw new Error(`Spot '${String(activation.spotId)}' close seal is stale.`);
+    }
   }
 
-  async closeAfterSeal(
+  /** Returns the OnClosing failure, which cleanup records and does not rethrow. */
+  async cleanupClosedActivation(
     activation: ZLinkSpotActivation,
-    seal: import('../execution').ZLinkExecutionBarrierSeal,
-    signal?: AbortSignal,
     reason = ZLinkSpotCloseReason.ExplicitClose,
     deadline?: Date
-  ): Promise<void> {
-    try {
-      await activation.waitForExecutionQuiescence(seal, signal);
-    } catch (error) {
-      activation.abortExecutionSeal(seal);
-      throw error;
-    }
-    // The eager occupancy check that authorized this seal (startClose ->
-    // canClose()) ran before quiescence, so it can miss an actor join that
-    // was already queued on the serial executor at that moment. Recheck now
-    // that every turn admitted before the seal has finished, and release the
-    // seal instead of closing an occupied Spot.
-    if (!activation.canClose(reason)) {
-      activation.abortExecutionSeal(seal);
-      throw new ZLinkSpotCloseOccupiedError(activation.spotId);
-    }
-    if (!activation.commitExecutionSeal(seal)) {
-      throw new Error(`Spot '${String(activation.spotId)}' close seal is stale.`);
-    }
-    await this.cleanupActivation(activation, activation.meshName, true, signal, reason, deadline);
+  ): Promise<unknown> {
+    return await this.cleanupActivation(
+      activation,
+      activation.meshName,
+      true,
+      undefined,
+      reason,
+      deadline,
+      true
+    );
+  }
+
+  async cleanupFailedIncarnation(activation: ZLinkSpotActivation): Promise<void> {
+    await this.cleanupActivation(
+      activation,
+      activation.meshName,
+      false,
+      undefined,
+      ZLinkSpotCloseReason.ExplicitClose,
+      undefined,
+      true
+    );
   }
 
   async dispatchActorPacket(
@@ -961,13 +977,16 @@ export class ZLinkSpotActivationLifecycle {
     notifyClosing: boolean,
     signal?: AbortSignal,
     reason = ZLinkSpotCloseReason.ExplicitClose,
-    deadline?: Date
-  ): Promise<void> {
+    deadline?: Date,
+    owningLifecycle = false
+  ): Promise<unknown> {
     throwIfAborted(signal);
     const state = this.cleanupStates.get(activation) ?? {
       closingAttempted: false,
       timersDisposed: false,
+      serialDisposed: false,
       handlersDisposed: false,
+      actorDispatchDisposed: false,
       nativeDisposed: false,
       locationReleased: false
     };
@@ -979,7 +998,8 @@ export class ZLinkSpotActivationLifecycle {
       notifyClosing,
       reason,
       state,
-      deadline
+      deadline,
+      owningLifecycle
     ).finally(() => {
       state.inFlight = undefined;
     });
@@ -994,13 +1014,17 @@ export class ZLinkSpotActivationLifecycle {
     state: {
       closingAttempted: boolean;
       timersDisposed: boolean;
+      serialDisposed: boolean;
       handlersDisposed: boolean;
+      actorDispatchDisposed: boolean;
       nativeDisposed: boolean;
       locationReleased: boolean;
     },
-    deadline?: Date
-  ): Promise<void> {
+    deadline?: Date,
+    owningLifecycle = false
+  ): Promise<unknown> {
     const errors: unknown[] = [];
+    let closingFailure: unknown;
     const cleanup = async (operation: () => Promise<void> | void, completed: () => void) => {
       try {
         await operation();
@@ -1011,10 +1035,21 @@ export class ZLinkSpotActivationLifecycle {
     };
     if (notifyClosing && !state.closingAttempted) {
       state.closingAttempted = true;
-      await cleanup(
-        () => invokeSpotClosing(activation.spot.onClosing?.bind(activation.spot), reason, deadline),
-        () => undefined
-      );
+      try {
+        // OnClosing is user code: it runs as a Framework turn through the
+        // execution gate while the Close lifecycle item keeps its FIFO slot.
+        await activation.serial.postBarrierTurn(() =>
+          invokeSpotClosing(activation.spot.onClosing?.bind(activation.spot), reason, deadline)
+        );
+      } catch (error) {
+        // An OnClosing failure is diagnostic and cleanup continues. It is
+        // returned so host shutdown can classify its teardown outcome.
+        this.options.closeErrorSink?.reportRuntimeTaskException(
+          `spot ${String(activation.spotId)} onClosing`,
+          error
+        );
+        closingFailure = error;
+      }
     }
     if (!state.timersDisposed) {
       await cleanup(
@@ -1024,23 +1059,34 @@ export class ZLinkSpotActivationLifecycle {
         }
       );
     }
-    await cleanup(
-      () => activation.serialExecutor.close(),
-      () => undefined
-    );
+    if (!state.serialDisposed && state.timersDisposed) {
+      await cleanup(
+        () =>
+          owningLifecycle
+            ? activation.serialExecutor.closeChildren()
+            : activation.serialExecutor.close(),
+        () => {
+          state.serialDisposed = true;
+        }
+      );
+    }
     if (!state.handlersDisposed) {
       await cleanup(
-        () => disposeLifecycleHandlers(activation.spot),
+        () => disposeLifecycleHandlers(activation.spot, this.options.detachedTaskRunner),
         () => {
           state.handlersDisposed = true;
         }
       );
     }
-    if (!state.nativeDisposed) {
+    if (!state.actorDispatchDisposed) {
       await cleanup(
         () => activation.actorDispatch?.dispose(),
-        () => undefined
+        () => {
+          state.actorDispatchDisposed = true;
+        }
       );
+    }
+    if (!state.nativeDisposed) {
       await cleanup(
         () => activation.nativeSpot?.dispose(),
         () => {
@@ -1048,7 +1094,21 @@ export class ZLinkSpotActivationLifecycle {
         }
       );
     }
-    if (!state.locationReleased) {
+    if (
+      !state.locationReleased &&
+      // Spot messaging §7 step 3: an Instance Spot's ExplicitClose releases its authority
+      // through the Close operation's Closing fence; a User Spot still releases its location.
+      !(
+        owningLifecycle &&
+        reason === ZLinkSpotCloseReason.ExplicitClose &&
+        activation.domain.kind === 'instance'
+      ) &&
+      state.timersDisposed &&
+      state.serialDisposed &&
+      state.handlersDisposed &&
+      state.actorDispatchDisposed &&
+      state.nativeDisposed
+    ) {
       await cleanup(
         () => this.options.releaseLocation(activation, locationMeshName, activation.spotId),
         () => {
@@ -1060,6 +1120,7 @@ export class ZLinkSpotActivationLifecycle {
     if (errors.length > 1) {
       throw new AggregateError(errors, `Spot '${activation.spotId}' cleanup failed.`);
     }
+    return closingFailure;
   }
 
   private decodeCreateReply(reply: unknown): unknown {
@@ -1079,12 +1140,3 @@ export class ZLinkSpotActivationLifecycle {
     }
   }
 }
-
-function toContextGeneration(generation: bigint): number {
-  if (generation < 0n || generation > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new ZLinkConfigurationException(
-      `Spot object generation '${generation}' cannot be represented by the Node.js public context.`
-    );
-  }
-  return Number(generation);
-}

package/src/runtime/spots/spot-actor-admission-coordinator.ts

@@ -16,7 +16,6 @@ import { ZLinkSpotActivation } from './spot-activation-state';
 import { ZLinkSpotActorJoinDispatch } from './spot-actor-join-dispatch';
 import { ZLinkSpotActorPacketDispatch } from './spot-actor-packet-dispatch';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import type { ZLinkNativeActorJoinSnapshot } from './spot-runtime-ports';
 
 type AdmissionOptions = Pick<
   ZLinkSpotActivationLifecycleOptions,
@@ -30,7 +29,6 @@ type AdmissionOptions = Pick<
   | 'locationClaim'
   | 'messageSerializers'
   | 'nativeSpotNodeProvider'
-  | 'createReceived'
   | 'createTopicMessage'
   | 'providerResolver'
   | 'runtimeEventPublisher'
@@ -92,7 +90,6 @@ export class ZLinkSpotActorAdmissionCoordinator {
     if (nativeSpot === undefined) return undefined;
     const nativeDispatch = new ZLinkSpotActorJoinDispatch({
       nativeSpot,
-      createReceived: requireBackendValueFactory(this.options.createReceived, 'Received'),
       createTopicMessage: requireBackendValueFactory(
         this.options.createTopicMessage,
         'TopicMessage'
@@ -112,10 +109,9 @@ export class ZLinkSpotActorAdmissionCoordinator {
                 kind: 'enabled',
                 runtime: this.options.actorTransferRuntime
               },
-        commitNativeActor: (actor) => this.commitNativeActorTransaction(activation, actor),
         commitActorDeparture: (actorId) => activation.commitActorDeparture(actorId),
-        commitTransferredActor: (actor, backlog) =>
-          this.commitTransferredActorTransaction(activation, actor, backlog)
+        commitTransferredActor: (actor, backlog, sealedSession) =>
+          this.commitTransferredActorTransaction(activation, actor, backlog, sealedSession)
       },
       packets: {
         handle: (delivery) =>
@@ -130,16 +126,6 @@ export class ZLinkSpotActorAdmissionCoordinator {
         bindRemoteSession: (actor, sourceNodeRid, sourceSessionRid) => {
           const node = this.options.nativeSpotNodeProvider?.(activation.meshName);
           if (node === undefined || routingIdsEqual(sourceNodeRid, node.routingId)) return;
-          const target = this.options.boundSessionRuntime?.resolveRemoteBoundSessionTarget(
-            sourceNodeRid,
-            sourceSessionRid
-          );
-          if (target !== undefined) {
-            this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(
-              actor.actorId,
-              target
-            );
-          }
           node.bindRemoteActorSession(actor, sourceNodeRid, sourceSessionRid);
         },
         replyNoBind: (info, parts, result) =>
@@ -251,8 +237,6 @@ export class ZLinkSpotActorAdmissionCoordinator {
           : (activation.resolveJoinedActor(targetActorId) ??
             this.options.actorResolver?.(targetActorId)),
       actorLeft: (targetActorId) => activation.hasDepartedActor(targetActorId),
-      onRemoteBoundSessionTarget: (targetActorId, target) =>
-        this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(targetActorId, target),
       onDisconnectActor: (actor) =>
         activation.serial.execute(() => activation.spot.onDisconnectActor?.(actor)),
       actorResponseSender: this.options.boundSessionRuntime?.sendActorResponse.bind(
@@ -275,47 +259,11 @@ export class ZLinkSpotActorAdmissionCoordinator {
     );
   }
 
-  private async commitNativeActorTransaction(
-    activation: ZLinkSpotActivation,
-    actor: ZLinkActor
-  ): Promise<void> {
-    const transfer = this.options.actorTransferRuntime;
-    let snapshot: ZLinkNativeActorJoinSnapshot | undefined;
-    let rollbackMembership: (() => void) | undefined;
-    let routeSwitchStarted = false;
-    try {
-      snapshot = await transfer?.claimNativeActorLocation(
-        actor,
-        activation.spotId,
-        activation.meshName
-      );
-      transfer?.commitRoutedActor(actor, activation.spotId, activation.spot);
-      rollbackMembership = activation.commitActorJoin(actor);
-      activation.beginActorTransfer(actor.context.actorId);
-      await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
-      routeSwitchStarted = true;
-      await transfer?.publishRoutedActorOwnership(actor);
-      await transfer?.openRoutedActorSession(actor);
-      activation.cancelActorTransfer(actor.context.actorId);
-    } catch (error) {
-      if (routeSwitchStarted) throw error;
-      rollbackMembership?.();
-      try {
-        if (snapshot !== undefined) await transfer?.rollbackNativeActorJoin(actor, snapshot);
-      } catch (rollbackError) {
-        throw new AggregateError(
-          [error, rollbackError],
-          'Native actor admission and rollback both failed.'
-        );
-      }
-      throw error;
-    }
-  }
-
   private async commitTransferredActorTransaction(
     activation: ZLinkSpotActivation,
     actor: ZLinkActor,
-    backlog: readonly ZLinkActorHandoffPacket[]
+    backlog: readonly ZLinkActorHandoffPacket[],
+    sealedSession: ZLinkRemoteBoundSessionTarget | undefined
   ): Promise<readonly ZLinkActorHandoffResult[]> {
     const transfer = this.options.actorTransferRuntime;
     let routeSwitchStarted = false;
@@ -328,7 +276,7 @@ export class ZLinkSpotActorAdmissionCoordinator {
         backlog.length === 0 ? [] : await this.replayActorBacklog(activation, actor, backlog);
       await transfer?.claimRoutedActorLocation(actor, activation.spotId, activation.meshName);
       routeSwitchStarted = true;
-      await transfer?.publishRoutedActorOwnership(actor);
+      await transfer?.publishRoutedActorOwnership(actor, sealedSession);
       await transfer?.openRoutedActorSession(actor);
       activation.cancelActorTransfer(actor.context.actorId);
       return results;