@zlink-systems/framework 0.26.0 → 0.28.0

package/src/runtime/handlers/handler-instance-scope.ts

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
 import type { Type, ZLinkMessageContext } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import { ZLinkStateLane } from '../execution/state-lane';
+import type { ZLinkDetachedTaskRunner } from '../spots/spot-actor-join-dispatch';
 
 export interface ZLinkHandlerInstanceScope {
   resolve<T>(type: Type<T>): Promise<T>;
@@ -22,16 +22,6 @@ interface Deferred<T> {
   readonly reject: (error: unknown) => void;
 }
 
-interface HandlerResolution<T> {
-  readonly promise: Promise<T>;
-  readonly activation?: Deferred<unknown>;
-}
-
-interface HandlerScopeDisposal {
-  readonly pending: readonly Promise<unknown>[];
-  readonly owned: readonly unknown[];
-}
-
 interface LifecycleScopeDisposal {
   readonly completion: Promise<void>;
   readonly deferred?: Deferred<void>;
@@ -41,9 +31,9 @@ interface LifecycleScopeDisposal {
 const HANDLER_SCOPE_FACTORY = Symbol.for('@zlink-systems/framework.handler-instance-scope-factory');
 const activeHandlerScope = new AsyncLocalStorage<ActiveHandlerScope>();
 const activeLifecycleScope = new AsyncLocalStorage<LifecycleHandlerInstanceScope>();
-const detachedStateLaneResource = new AsyncResource('zlink:handler-instance-scope');
+const detachedLifecycleResource = new AsyncResource('zlink:handler-instance-scope');
 const dispatchScopes = new WeakMap<object, ZLinkHandlerInstanceScope>();
-const lifecycleScopes = new WeakMap<object, Promise<LifecycleHandlerInstanceScope>>();
+const lifecycleScopes = new WeakMap<object, LifecycleHandlerInstanceScope>();
 
 export async function runInHandlerInstanceScope<T>(
   providerResolver: ZLinkProviderResolver | undefined,
@@ -80,14 +70,7 @@ export async function resolveLifecycleHandler<T>(
   type: Type<T>,
   providerResolver?: ZLinkProviderResolver
 ): Promise<T> {
-  let scope = lifecycleScopes.get(owner);
-  if (scope === undefined) {
-    scope = Promise.resolve(
-      new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver))
-    );
-    lifecycleScopes.set(owner, scope);
-  }
-  return (await scope).resolve(type);
+  return lifecycleHandlerScope(owner, providerResolver).resolve(type);
 }
 
 export async function runWithLifecycleHandler<THandler, TResult>(
@@ -96,25 +79,34 @@ export async function runWithLifecycleHandler<THandler, TResult>(
   providerResolver: ZLinkProviderResolver | undefined,
   callback: (handler: THandler) => Promise<TResult>
 ): Promise<TResult> {
+  return lifecycleHandlerScope(owner, providerResolver).run(type, callback);
+}
+
+function lifecycleHandlerScope(
+  owner: object,
+  providerResolver?: ZLinkProviderResolver
+): LifecycleHandlerInstanceScope {
   let scope = lifecycleScopes.get(owner);
   if (scope === undefined) {
-    scope = Promise.resolve(
-      new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver))
-    );
+    scope = new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver));
     lifecycleScopes.set(owner, scope);
   }
-  return (await scope).run(type, callback);
+  return scope;
 }
 
-export async function disposeLifecycleHandlers(owner: object): Promise<void> {
+export async function disposeLifecycleHandlers(
+  owner: object,
+  detachedTaskRunner: ZLinkDetachedTaskRunner
+): Promise<void> {
+  if ((detachedTaskRunner as unknown) === undefined) {
+    throw new Error('Lifecycle handler disposal requires a detached task runner.');
+  }
   const scope = lifecycleScopes.get(owner);
   if (scope === undefined) return;
-  const resolved = await scope;
-  await resolved.dispose();
+  await scope.dispose(detachedTaskRunner);
   // Keep the closed scope as a tombstone for the lifetime of the owner object.
   // A late dispatch must fail instead of creating a second activation.
 }
-
 function createHandlerInstanceScope(
   providerResolver?: ZLinkProviderResolver,
   context?: ZLinkMessageContext
@@ -138,72 +130,47 @@ function isHandlerInstanceScopeFactory(value: unknown): value is ZLinkHandlerIns
 }
 
 class DefaultHandlerInstanceScope implements ZLinkHandlerInstanceScope {
-  private readonly lane = new ZLinkStateLane();
   private readonly instances = new Map<Type, Promise<unknown>>();
   private readonly owned: unknown[] = [];
   private disposed = false;
 
   constructor(private readonly providerResolver?: ZLinkProviderResolver) {}
 
-  async resolve<T>(type: Type<T>): Promise<T> {
-    const resolution = await this.lane.run(() => this.resolveCore(type));
-    if (resolution.activation !== undefined) {
-      startOutsideStateLane(() => {
-        void this.activate(type, resolution.activation!);
-      });
-    }
-    return await resolution.promise;
-  }
-
-  async dispose(): Promise<void> {
-    const disposal = await this.lane.run(() => this.beginDisposeCore());
-    if (disposal === undefined) return;
-
-    await Promise.allSettled(disposal.pending);
-    for (const instance of disposal.owned) {
-      await disposeOwnedInstance(instance);
-    }
-    await this.lane.run(() => this.completeDisposeCore());
-  }
-
-  private resolveCore<T>(type: Type<T>): HandlerResolution<T> {
+  resolve<T>(type: Type<T>): Promise<T> {
     if (this.disposed) {
-      throw new Error('Handler instance scope is already disposed.');
+      return Promise.reject(new Error('Handler instance scope is already disposed.'));
     }
-    let instance = this.instances.get(type) as Promise<T> | undefined;
-    if (instance !== undefined) return { promise: instance };
-
+    const existing = this.instances.get(type) as Promise<T> | undefined;
+    if (existing !== undefined) return existing;
     const activation = createDeferred<unknown>();
-    instance = activation.promise as Promise<T>;
     this.instances.set(type, activation.promise);
-    return { promise: instance, activation };
+    void this.activate(type, activation);
+    return activation.promise as Promise<T>;
   }
 
-  private beginDisposeCore(): HandlerScopeDisposal | undefined {
-    if (this.disposed) return undefined;
+  async dispose(): Promise<void> {
+    if (this.disposed) return;
     this.disposed = true;
-    return {
-      pending: [...this.instances.values()],
-      owned: [...this.owned].reverse()
-    };
-  }
-
-  private completeDisposeCore(): void {
-    this.owned.length = 0;
-    this.instances.clear();
+    await Promise.allSettled(this.instances.values());
+    try {
+      await disposeOwnedInstances(this.owned);
+    } finally {
+      this.owned.length = 0;
+      this.instances.clear();
+    }
   }
-
   private async activate<T>(type: Type<T>, activation: Deferred<unknown>): Promise<void> {
     let instance: T;
     try {
-      instance = (await this.providerResolver?.create?.(type)) ?? new type();
+      const created = this.providerResolver?.create?.(type);
+      instance = created === undefined ? new type() : await created;
     } catch (error) {
       activation.reject(error);
       return;
     }
 
-    const accepted = await this.lane.run(() => this.acceptActivationCore(instance));
-    if (accepted) {
+    if (!this.disposed) {
+      this.owned.push(instance);
       activation.resolve(instance);
       return;
     }
@@ -214,16 +181,9 @@ class DefaultHandlerInstanceScope implements ZLinkHandlerInstanceScope {
       activation.reject(error);
     }
   }
-
-  private acceptActivationCore(instance: unknown): boolean {
-    if (this.disposed) return false;
-    this.owned.push(instance);
-    return true;
-  }
 }
 
 class LifecycleHandlerInstanceScope {
-  private readonly lane = new ZLinkStateLane();
   private activeInvocations = 0;
   private closing = false;
   private idle?: Promise<void>;
@@ -232,12 +192,7 @@ class LifecycleHandlerInstanceScope {
 
   constructor(private readonly instances: ZLinkHandlerInstanceScope) {}
 
-  async resolve<T>(type: Type<T>): Promise<T> {
-    const resolution = await this.lane.run(() => ({ promise: this.resolveCore(type) }));
-    return await resolution.promise;
-  }
-
-  private resolveCore<T>(type: Type<T>): Promise<T> {
+  resolve<T>(type: Type<T>): Promise<T> {
     this.throwIfClosingCore();
     return this.instances.resolve(type);
   }
@@ -246,29 +201,34 @@ class LifecycleHandlerInstanceScope {
     type: Type<THandler>,
     callback: (handler: THandler) => Promise<TResult>
   ): Promise<TResult> {
-    await this.lane.run(() => this.beginInvocationCore());
+    this.beginInvocationCore();
     try {
       return await activeLifecycleScope.run(this, async () =>
         callback(await this.instances.resolve(type))
       );
     } finally {
-      await this.lane.run(() => this.completeInvocationCore());
+      this.completeInvocationCore();
     }
   }
 
-  async dispose(): Promise<void> {
+  async dispose(detachedTaskRunner: ZLinkDetachedTaskRunner): Promise<void> {
     const disposeFromActiveInvocation = activeLifecycleScope.getStore() === this;
-    const disposal = await this.lane.run(() => this.beginDisposeCore());
+    const disposal = this.beginDisposeCore();
     if (disposal.deferred !== undefined) {
-      startOutsideStateLane(() => {
+      startOutsideLifecycleInvocation(() => {
         void this.disposeWhenIdle(disposal);
+        if (disposeFromActiveInvocation) {
+          detachedTaskRunner.runDetached(
+            LifecycleHandlerInstanceScope.name,
+            () => disposal.completion
+          );
+        }
       });
     }
     if (disposeFromActiveInvocation) {
       // Waiting here would make the current handler wait for its own terminal
       // completion. The same disposal promise continues after run() releases
       // the final active invocation.
-      void disposal.completion.catch(() => undefined);
       return;
     }
     await disposal.completion;
@@ -318,7 +278,7 @@ class LifecycleHandlerInstanceScope {
       await this.instances.dispose();
       deferred.resolve();
     } catch (error) {
-      await this.lane.run(() => this.failDisposalCore(deferred.promise));
+      this.failDisposalCore(deferred.promise);
       deferred.reject(error);
     }
   }
@@ -340,8 +300,8 @@ function createDeferred<T>(): Deferred<T> {
   return { promise, resolve, reject };
 }
 
-function startOutsideStateLane<T>(work: () => T): T {
-  return detachedStateLaneResource.runInAsyncScope(work);
+function startOutsideLifecycleInvocation<T>(work: () => T): T {
+  return detachedLifecycleResource.runInAsyncScope(work);
 }
 
 export async function disposeOwnedInstance(instance: unknown): Promise<void> {
@@ -359,3 +319,16 @@ export async function disposeOwnedInstance(instance: unknown): Promise<void> {
     await value.onModuleDestroy();
   }
 }
+
+export async function disposeOwnedInstances(instances: readonly unknown[]): Promise<void> {
+  const failures: unknown[] = [];
+  for (let index = instances.length - 1; index >= 0; index -= 1) {
+    try {
+      await disposeOwnedInstance(instances[index]);
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, 'Handler scope cleanup failed.');
+}

package/src/runtime/host/actor-packet-relay.ts

@@ -20,10 +20,6 @@ import {
   type ZLinkRemoteActorPacketTarget,
   type ZLinkRemoteBoundSessionTarget
 } from '../actors';
-import {
-  mergeRemoteBoundSessionTarget,
-  preferredRemoteBoundSessionTarget
-} from '../actors/actor-runtime-state';
 import type { DefaultZLinkActorManager } from '../actors';
 import {
   decodeRemoteActorSessionBinding,
@@ -44,13 +40,14 @@ import { streamMetadataMap } from '../actors/bound-session-wire';
 import { decodeRoutingId, normalizeRoutingId, routingIdsEqual } from '../routing-id';
 import { ZLinkSubmitStatus } from '../messaging/submission-result';
 import type { DefaultZLinkSpotManager, ZLinkSpotNodeRuntimeManager } from '../spots';
-import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkDetachedTaskRunner } from '../spots/spot-actor-join-dispatch';
 import type { ZLinkBoundSessionResponseTarget } from '../streams';
 import type {
   ZLinkBoundSessionResponsePort,
+  ZLinkSessionBindingConfirmationOptions,
   ZLinkStreamActorLookupPort
 } from '../streams/stream-binding-runtime-ports';
+import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
 import { actorSessionBindingRuntimeOwnerIfRegistered } from '../streams/actor-session-binding-runtime-owner';
 import {
   decodeStreamHeader,
@@ -65,10 +62,6 @@ import type { MeshRouterResolver } from './mesh-router-resolver';
 import { ZLinkRemoteActorPacketTargetStore } from './remote-actor-packet-target-store';
 import type { ZLinkStoreLocationResolvers } from '../locations';
 
-const REMOTE_SESSION_BIND_RETRY_DEADLINE_MS = 30_000;
-const REMOTE_SESSION_BIND_RETRY_INITIAL_DELAY_MS = 25;
-const REMOTE_SESSION_BIND_RETRY_MAX_DELAY_MS = 1_000;
-
 export interface ZLinkActorPacketRelayOptions {
   readonly requestTimeoutMs?: number;
   readonly routeTransport: ZLinkActorRoutedJoinTransport;
@@ -120,12 +113,7 @@ export class ZLinkActorPacketRelay {
   ): Promise<void> {
     const state = this.options.actorManager()?.getState(actor.actorId);
     const currentRemoteBoundSessionTarget =
-      state?.spotId === undefined
-        ? undefined
-        : preferredRemoteBoundSessionTarget(
-            state.remoteBoundSessionTarget,
-            state.boundSessionTransferTarget
-          );
+      state?.spotId === undefined ? undefined : state.remoteBoundSessionTarget;
     const currentRemoteActorPacketTarget =
       state?.spotId === undefined ? undefined : state.remoteActorPacketTarget;
     const remoteTarget =
@@ -162,11 +150,8 @@ export class ZLinkActorPacketRelay {
     await this.targets.updateFromWire(actorId, value);
   }
 
-  actorPacketTargetForState(
-    actorId: string,
-    routerChannelIdHint?: string
-  ): ZLinkRemoteActorPacketTarget | undefined {
-    return this.targets.targetForState(actorId, routerChannelIdHint);
+  actorPacketTargetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined {
+    return this.targets.targetForState(actorId);
   }
 
   async notifyActorDisconnectedById(actorId: string, signal?: AbortSignal): Promise<void> {
@@ -174,10 +159,7 @@ export class ZLinkActorPacketRelay {
     const remoteTarget =
       state === undefined
         ? undefined
-        : (preferredRemoteBoundSessionTarget(
-            state.remoteBoundSessionTarget,
-            state.boundSessionTransferTarget
-          ) ?? state.remoteActorPacketTarget);
+        : (state.remoteBoundSessionTarget ?? state.remoteActorPacketTarget);
     if (remoteTarget !== undefined) {
       await this.notifyRemoteActorDisconnected(actorId, remoteTarget, signal);
       return;
@@ -288,66 +270,28 @@ export class ZLinkActorPacketRelay {
         if (frameHeader.kind !== ZLinkStreamMessageKind.Send) {
           throw new Error('Remote actor session binding requires a send frame.');
         }
-        const { sessionNodeRid, sessionRid } = decodeRemoteActorSessionBinding(
-          messageToBytes(body)
-        );
+        const { sessionNodeRid } = decodeRemoteActorSessionBinding(messageToBytes(body));
         if (!routingIdsEqual(sessionNodeRid, _routeContext.sourceNodeRid)) {
           throw new Error(
             'Remote actor session binding source did not match the declared session node.'
           );
         }
+        // The Actor owner installs the binding from the Session owner's
+        // command 38 (Session–Actor binding §5); this relay confirmation only
+        // acknowledges that the Actor is still owned here.
         const state = this.options.actorManager()?.getState(relay.actorId);
-        const actorRef = state?.nativeActorRef;
-        if (state === undefined || actorRef === undefined) {
+        if (state?.nativeActorRef === undefined) {
           throw new Error(`Actor '${relay.actorId}' does not have a concrete actor ref.`);
         }
-        if (this.requireSpotNodeRuntime().primaryMeshNode === undefined) {
-          throw new Error('MeshNode actor runtime is not started.');
-        }
-        const target =
-          relay.routerChannelId === undefined
-            ? this.options.meshRouters.remoteBoundSessionTargetForSource(sessionNodeRid)
-            : {
-                routerChannelId: relay.routerChannelId,
-                targetNodeRid: sessionNodeRid,
-                spotId: sessionNodeRid
-              };
-        if (target === undefined) {
-          throw new Error('Remote actor session binding did not declare a return router.');
-        }
-        const bindingGeneration = (
-          fallbackActorRef as
-            | (ActorRef & {
-                readonly bindingGeneration?: bigint;
-              })
-            | undefined
-        )?.bindingGeneration;
-        const refreshedTarget = mergeRemoteBoundSessionTarget(
-          {
-            ...target,
-            sessionNodeRid,
-            sessionRid,
-            ...(bindingGeneration === undefined ? {} : { bindingGeneration })
-          },
-          preferredRemoteBoundSessionTarget(
-            state.remoteBoundSessionTarget,
-            state.boundSessionTransferTarget
-          )
-        );
-        state.setRemoteBoundSessionTarget(refreshedTarget);
         return { ok: true, response: { acknowledged: true } };
       }
       if (frameHeader.name === ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
         this.requireCurrentRemoteBinding(relay, _routeContext);
-        this.options
-          .actorManager()
-          ?.getState(relay.actorId)
-          ?.setRemoteBoundSessionTarget(undefined);
         await this.notifyLocalActorDisconnectedById(relay.actorId);
         return {
           ok: true,
           actorPacketTarget: encodeRemoteActorPacketTarget(
-            this.actorPacketTargetForState(relay.actorId, relay.routerChannelId)
+            this.actorPacketTargetForState(relay.actorId)
           )
         };
       }
@@ -400,7 +344,7 @@ export class ZLinkActorPacketRelay {
         return {
           ok: true,
           actorPacketTarget: encodeRemoteActorPacketTarget(
-            this.actorPacketTargetForState(relay.actorId, relay.routerChannelId)
+            this.actorPacketTargetForState(relay.actorId)
           )
         };
       }
@@ -472,7 +416,7 @@ export class ZLinkActorPacketRelay {
           ok: true,
           deferredResponse: true,
           actorPacketTarget: encodeRemoteActorPacketTarget(
-            this.actorPacketTargetForState(relay.actorId, relay.routerChannelId)
+            this.actorPacketTargetForState(relay.actorId)
           )
         };
       }
@@ -497,7 +441,7 @@ export class ZLinkActorPacketRelay {
         ok: true,
         response,
         actorPacketTarget: encodeRemoteActorPacketTarget(
-          this.actorPacketTargetForState(relay.actorId, relay.routerChannelId)
+          this.actorPacketTargetForState(relay.actorId)
         )
       };
     } catch (error) {
@@ -520,37 +464,12 @@ export class ZLinkActorPacketRelay {
   async relayActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
-    //  Spec 32:87 — a route/owner that is not currently usable is
-    //  Unavailable and retryable within the request deadline. Right after a
-    //  relocation the cached packet target can carry a transiently
-    //  incomplete Ready authority fence (route publication still
-    //  converging); failing the request on the fence check would surface a
-    //  NotFound for a Spot that exists and is Ready on its owner. Clear the
-    //  stale hint and re-resolve with a short bound instead.
-    const fenceRetryDeadlineMs = performance.now() + 1_000;
-    for (;;) {
-      try {
-        if (await this.relayRemoteActorPacket(actor, frameHeader, payload, signal)) {
-          return true;
-        }
-        return await this.relayLocalActorPacket(actor, frameHeader, payload, signal);
-      } catch (error) {
-        if (
-          !(
-            error instanceof Error && error.message.includes('no complete Ready authority fence')
-          ) ||
-          performance.now() >= fenceRetryDeadlineMs
-        ) {
-          throw error;
-        }
-        this.targets.clear(actor.actorId);
-        this.options.actorManager()?.getState(actor.actorId)?.setRemoteActorPacketTarget(undefined);
-        await new Promise<void>((resolve) => setTimeout(resolve, 25));
-      }
+    if (await this.relayRemoteActorPacket(actor, frameHeader, payload)) {
+      return true;
     }
+    return this.relayLocalActorPacket(actor, frameHeader, payload);
   }
 
   async confirmRemoteSessionBinding(
@@ -558,10 +477,13 @@ export class ZLinkActorPacketRelay {
     sessionNodeRid: RoutingId,
     sessionRid: RoutingId,
     signal?: AbortSignal,
-    options?: { readonly waitForAcknowledgement?: boolean }
+    options?: ZLinkSessionBindingConfirmationOptions
   ): Promise<void> {
     const target = this.targets.targetForActorRef(actor);
-    if (target === undefined) return;
+    if (target === undefined) {
+      this.installSameNodeSessionBinding(actor.actorId, options?.binding);
+      return;
+    }
     const header = encodeStreamHeader({
       kind: ZLinkStreamMessageKind.Send,
       codec: ZLinkStreamCodec.Json,
@@ -579,12 +501,9 @@ export class ZLinkActorPacketRelay {
       payload: encodeRemoteActorSessionBinding({ sessionNodeRid, sessionRid })
     });
     if (options?.waitForAcknowledgement === false) {
-      await this.retryRemoteSessionBindingSend(
-        withDefaultSpotKind(target),
-        request,
-        performance.now() + REMOTE_SESSION_BIND_RETRY_DEADLINE_MS,
-        REMOTE_SESSION_BIND_RETRY_INITIAL_DELAY_MS
-      );
+      await this.options.routeTransport.sendToSpot(withDefaultSpotKind(target), request, {
+        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
+      });
       return;
     }
     const reply = await this.requestRemoteTarget<{
@@ -624,49 +543,44 @@ export class ZLinkActorPacketRelay {
     }
   }
 
-  private async retryRemoteSessionBindingSend(
-    target: ZLinkSpotRouteTarget,
-    request: unknown,
-    deadline: number,
-    delayMs: number
-  ): Promise<void> {
-    try {
-      await this.options.routeTransport.sendToSpot(target, request, {
-        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
-      });
-    } catch (error) {
-      if (performance.now() >= deadline) {
-        //  Spec 32-framework-error-model: DeadlineExceeded(7). Retry
-        //  exhaustion on the one-way bind send remains diagnostics-only but
-        //  the caller waits for its bounded submission terminal so later
-        //  application relay cannot overtake it.
-        this.options
-          .errorSink()
-          .reportRuntimeTaskException(
-            'remote session binding send',
-            createInternalFrameworkException(
-              ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
-              'Remote actor session binding send retries exceeded their deadline.',
-              error
-            )
-          );
-        return;
-      }
-      await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
-      await this.retryRemoteSessionBindingSend(
-        target,
-        request,
-        deadline,
-        Math.min(delayMs * 2, REMOTE_SESSION_BIND_RETRY_MAX_DELAY_MS)
+  /**
+   * Session–Actor binding §5·§6 (.NET ZLinkSessionActorCoordinator rule): a
+   * same-node bind installs the Session owner's registry identity through the
+   * same install a remote command 38 uses, so relocation seals and carries it.
+   */
+  private installSameNodeSessionBinding(
+    actorId: string,
+    binding: ServiceStreamSessionBinding | undefined
+  ): void {
+    // The Actor is gone (destroyed or relocated away): nothing to record.
+    const state = this.options.actorManager()?.getState(actorId);
+    // No registry binding exists only for a native-fallback bind, which has no
+    // Session owner registry (managed-stream.ts `bindActor` fallback).
+    if (state === undefined || binding === undefined) return;
+    const route = this.options.meshRouters.remoteBoundSessionTargetForSource(
+      binding.sessionOwnerNodeRid
+    );
+    if (route === undefined) {
+      throw createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.ActorLocationStale,
+        `Actor '${actorId}' Session route is unavailable.`
       );
     }
+    state.installBoundSessionBinding({
+      ...route,
+      sessionNodeRid: binding.sessionOwnerNodeRid,
+      sessionRid: binding.sessionRid,
+      sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
+      sessionOwnerId: binding.sessionOwnerId,
+      sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
+      bindingGeneration: binding.bindingGeneration
+    });
   }
 
   async relayRemoteActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
     const streamRuntime = this.options.streamBindingRuntime();
     const responseTarget = await streamRuntime.captureBoundSessionResponseTarget(actor);
@@ -755,8 +669,7 @@ export class ZLinkActorPacketRelay {
         remoteAddress.routerChannelId,
         String(remoteAddress.targetNodeRid),
         ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        request,
-        signal
+        request
       );
       if (result.status !== ZLinkSubmitStatus.Submitted) {
         throw new Error(`Actor '${actor.actorId}' remote node relay was not admitted.`);
@@ -765,8 +678,7 @@ export class ZLinkActorPacketRelay {
     }
     if (frameHeader.kind === ZLinkStreamMessageKind.Send || frameHeader.requestSeq === undefined) {
       await this.options.routeTransport.sendToSpot(remoteAddress, request, {
-        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        signal
+        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
       });
       return true;
     }
@@ -786,8 +698,7 @@ export class ZLinkActorPacketRelay {
           throw new Error(`Remote actor packet relay reply was empty for '${actor.actorId}'.`);
         }
         return JSON.parse(parts[0].getString('utf8')) as typeof reply;
-      },
-      signal
+      }
     );
     const actorPacketTarget = this.targets.decodeFromWire(reply.actorPacketTarget);
     const currentStoredRoute = await streamRuntime.sessionRouteFence(actor.actorId);
@@ -894,13 +805,7 @@ export class ZLinkActorPacketRelay {
     routeContext: ZLinkRouteMessageContext
   ): void {
     const state = this.options.actorManager()?.getState(relay.actorId);
-    const current =
-      state === undefined
-        ? undefined
-        : preferredRemoteBoundSessionTarget(
-            state.remoteBoundSessionTarget,
-            state.boundSessionTransferTarget
-          );
+    const current = state?.boundSession;
     if (
       current === undefined ||
       current.sessionNodeRid === undefined ||
@@ -953,10 +858,8 @@ export class ZLinkActorPacketRelay {
   private async relayLocalActorPacket(
     actor: ZLinkSessionActor,
     frameHeader: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ): Promise<boolean> {
-    void signal;
     const state = this.options.actorManager()?.getState(actor.actorId);
     const spotId = state?.spotId as RoutingId | undefined;
     const hasActiveSpot =