@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/host/instance-activation-authority.ts

@@ -20,6 +20,7 @@ import { ZLinkFrameworkException } from '../../contracts';
 import {
   decodeServiceInstanceAuthorityPayload,
   decodeServiceReadySpotAuthority,
+  decodeServiceClosingSpotAuthority,
   encodeServiceInstanceAuthorityPayload
 } from '../foundation/service-authority-payload-codec';
 import type {
@@ -36,7 +37,6 @@ import type {
 } from '../foundation/service-stateful-wire-codec';
 import { routingIdsEqual } from '../routing-id';
 import { encodeAuthorityKey } from '../locations/authority-key-codec';
-import { crc32c } from '../foundation/service-relocation-runtime';
 import { putNewRelocationBlob, relocationBlobReference } from '../locations/relocation-blob';
 
 import {
@@ -80,7 +80,8 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
   }
 
   async reserve(
-    activation: Omit<ServiceInstanceActivationRecoveryEnvelope, 'targetMeshName'>
+    activation: Omit<ServiceInstanceActivationRecoveryEnvelope, 'targetMeshName'>,
+    signal?: AbortSignal
   ): Promise<ServiceInstanceAuthorityReserve> {
     const target = activation.target;
     const owner = this.requireOwner();
@@ -99,15 +100,15 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
     const stored = await putNewRelocationBlob(
       relocationStore,
       requestBytes,
-      CREATION_REQUEST_RETENTION_MS
+      CREATION_REQUEST_RETENTION_MS,
+      signal
     );
-    const storedRead = await relocationStore.read(stored.reference);
+    const storedRead = await relocationStore.read(stored.reference, signal);
     if (
       stored.reference.value.length === 0 ||
       stored.expiresAt.getTime() <= stored.storeNow.getTime() ||
       storedRead.kind !== 'found' ||
-      crc32c(storedRead.bytes) !== crc32c(requestBytes) ||
-      !Buffer.from(storedRead.bytes).equals(requestBytes)
+      Buffer.compare(storedRead.bytes, requestBytes) !== 0
     ) {
       await this.deleteOrphan(stored.reference);
       throw new Error('Relocation Store returned an invalid creation request receipt.');
@@ -115,50 +116,44 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
     let reserved: Awaited<ReturnType<ZLinkObjectCreationStore['reserve']>>;
     try {
       for (;;) {
-        reserved = await this.options.store.reserve({
-          key: { kind: 'instance_spot', globalId: target.targetSpotId },
-          intent: {
-            stableType: target.stableType,
-            requestContentReference: stored.reference.value,
-            requestSha256: requestHash,
-            requestEncodedSize: BigInt(requestBytes.byteLength)
-          },
-          target: {
-            meshName: this.options.meshName,
-            nodeRid: target.targetNodeRid,
-            nodeLifecycleGeneration: target.targetNodeGeneration,
-            owner
-          },
-          creatingPayload: encodeServiceInstanceAuthorityPayload({
-            state: 'coldActivating',
-            stableType: target.stableType,
-            spotId: target.targetSpotId,
-            ownerId: owner.ownerId,
-            ownerLeaseGeneration: owner.leaseGeneration,
-            ownerMeshName: this.options.meshName,
-            ownerNodeRid: target.targetNodeRid,
-            ownerNodeGeneration: target.targetNodeGeneration
-          }),
-          capacity: {
-            actors: 0,
-            spots: 1,
-            spotType: {
-              objectKind: 'instance_spot',
+        reserved = await this.options.store.reserve(
+          {
+            key: { kind: 'instance_spot', globalId: target.targetSpotId },
+            intent: {
               stableType: target.stableType,
-              count: 1
+              requestContentReference: stored.reference.value,
+              requestSha256: requestHash,
+              requestEncodedSize: BigInt(requestBytes.byteLength)
+            },
+            target: {
+              meshName: this.options.meshName,
+              nodeRid: target.targetNodeRid,
+              nodeLifecycleGeneration: target.targetNodeGeneration,
+              owner
+            },
+            creatingPayload: encodeServiceInstanceAuthorityPayload({
+              state: 'coldActivating',
+              stableType: target.stableType,
+              spotId: target.targetSpotId,
+              ownerId: owner.ownerId,
+              ownerLeaseGeneration: owner.leaseGeneration,
+              ownerMeshName: this.options.meshName,
+              ownerNodeRid: target.targetNodeRid,
+              ownerNodeGeneration: target.targetNodeGeneration
+            }),
+            capacity: {
+              actors: 0,
+              spots: 1,
+              spotType: {
+                objectKind: 'instance_spot',
+                stableType: target.stableType,
+                count: 1
+              }
             }
-          }
-        });
-        if (reserved.kind === 'conflict' || reserved.kind === 'alreadyExists') {
-          const existingState =
-            reserved.current.kind === 'snapshot'
-              ? decodeServiceInstanceAuthorityPayload(reserved.current.payload)?.state
-              : undefined;
-          if (existingState === 'closing') {
-            await this.awaitClosingRelease(target, activation.deadlineUnixMs);
-            continue;
-          }
-        }
+          },
+          undefined,
+          activation.deadlineUnixMs
+        );
         if (reserved.kind !== 'alreadyExists') break;
         this.options.metrics?.recordInstanceSpotClaimConflict(
           this.options.meshName,
@@ -266,40 +261,45 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
   async commit(
     target: ServiceInstanceActivationTarget,
     reservation: ServiceInstanceActivationReservation,
-    spot: ServiceSpotState
+    spot: ServiceSpotState,
+    deadlineUnixMs?: bigint
   ): Promise<{ readonly kind: 'committed' | 'lost'; readonly route: ServiceInstanceRouteFence }> {
     const pending = this.requirePending(reservation);
     requireCommitIdentity(target, reservation, pending.creating, spot, this.options.meshName);
     let result;
     try {
-      result = await this.options.store.commit({
-        key: { kind: 'instance_spot', globalId: target.targetSpotId },
-        reservationId: pending.reservationId,
-        expectedStoreVersion: pending.creating.storeVersion.value,
-        target: {
-          meshName: this.options.meshName,
-          nodeRid: target.targetNodeRid,
-          nodeLifecycleGeneration: target.targetNodeGeneration,
-          owner: pending.owner
+      result = await this.options.store.commit(
+        {
+          key: { kind: 'instance_spot', globalId: target.targetSpotId },
+          reservationId: pending.reservationId,
+          expectedStoreVersion: pending.creating.storeVersion.value,
+          target: {
+            meshName: this.options.meshName,
+            nodeRid: target.targetNodeRid,
+            nodeLifecycleGeneration: target.targetNodeGeneration,
+            owner: pending.owner
+          },
+          readyPayload: encodeServiceInstanceAuthorityPayload({
+            state: 'ready',
+            stableType: spot.stableType,
+            spotId: spot.ref.spotId,
+            ownerId: pending.owner.ownerId,
+            ownerLeaseGeneration: pending.owner.leaseGeneration,
+            ownerMeshName: this.options.meshName,
+            ownerNodeRid: target.targetNodeRid,
+            ownerNodeGeneration: target.targetNodeGeneration,
+            activationRecovery: {
+              reference: pending.requestReference.value,
+              sha256: pending.requestSha256,
+              encodedSize: pending.requestEncodedSize,
+              inboxSequence: 1n,
+              replayCursor: 0n
+            }
+          })
         },
-        readyPayload: encodeServiceInstanceAuthorityPayload({
-          state: 'ready',
-          stableType: spot.stableType,
-          spotId: spot.ref.spotId,
-          ownerId: pending.owner.ownerId,
-          ownerLeaseGeneration: pending.owner.leaseGeneration,
-          ownerMeshName: this.options.meshName,
-          ownerNodeRid: target.targetNodeRid,
-          ownerNodeGeneration: target.targetNodeGeneration,
-          activationRecovery: {
-            reference: pending.requestReference.value,
-            sha256: pending.requestSha256,
-            encodedSize: pending.requestEncodedSize,
-            inboxSequence: 1n,
-            replayCursor: 0n
-          }
-        })
-      });
+        undefined,
+        deadlineUnixMs
+      );
     } catch (error) {
       if (error instanceof ZLinkFrameworkException) throw error;
       throw createInternalFrameworkException(
@@ -483,32 +483,6 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
     );
   }
 
-  private async awaitClosingRelease(
-    target: ServiceInstanceActivationTarget,
-    deadlineUnixMs: bigint
-  ): Promise<void> {
-    const key = authorityKey(target.targetSpotId);
-    const deadlineMs = performance.now() + Number(deadlineUnixMs - BigInt(Date.now()));
-    while (performance.now() <= deadlineMs) {
-      const current = await this.options.store.readAuthority(key);
-      if (current.kind !== 'snapshot') return;
-      const decoded = decodeServiceInstanceAuthorityPayload(current.payload);
-      if (
-        current.allocation.objectKind !== 'instance_spot' ||
-        current.allocation.stableType !== target.stableType ||
-        decoded?.kind !== 'instance_spot' ||
-        decoded.spotId !== target.targetSpotId
-      ) {
-        throw new Error('Instance authority changed to a different Spot while closing.');
-      }
-      if (decoded.state !== 'closing') return;
-      await waitForActivationJoin(deadlineMs);
-    }
-    throw new Error(
-      `Instance Spot '${target.targetSpotId}' close did not release authority before deadline.`
-    );
-  }
-
   private requirePending(reservation: ServiceInstanceActivationReservation): PendingReservation {
     const pending = this.pending.get(reservation.token);
     if (pending === undefined || pending.creating.objectGeneration !== reservation.attempt) {
@@ -522,12 +496,13 @@ function readyRead(
   snapshot: ZLinkAuthoritySnapshot,
   target: ServiceInstanceActivationTarget
 ): ServiceInstanceAuthorityRead {
-  const decoded = decodeServiceReadySpotAuthority(snapshot.payload);
+  const decoded =
+    decodeServiceReadySpotAuthority(snapshot.payload) ??
+    decodeServiceClosingSpotAuthority(snapshot.payload);
   const creating = decodeServiceInstanceAuthorityPayload(snapshot.payload);
   if (
     creating?.state === 'coldActivating' &&
     snapshot.allocation.objectKind === 'instance_spot' &&
-    snapshot.allocation.state === 'reserved' &&
     creating.stableType === target.stableType &&
     creating.spotId === target.targetSpotId &&
     creating.ownerId === snapshot.ownerId &&
@@ -541,7 +516,8 @@ function readyRead(
     return {
       kind: 'creating',
       objectGeneration: snapshot.objectGeneration,
-      authorityOwnerGeneration: snapshot.authorityOwnerGeneration
+      authorityOwnerGeneration: snapshot.authorityOwnerGeneration,
+      authority: snapshot
     };
   }
   if (
@@ -560,14 +536,16 @@ function readyRead(
   ) {
     return { kind: 'missing' };
   }
-  return { kind: 'ready', route: routeFromSnapshot(snapshot) };
+  return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
 }
 
 function readyExisting(
   snapshot: ZLinkAuthoritySnapshot,
   target: ServiceInstanceActivationTarget
 ): Extract<ServiceInstanceAuthorityRead, { readonly kind: 'ready' }> {
-  const decoded = decodeServiceReadySpotAuthority(snapshot.payload);
+  const decoded =
+    decodeServiceReadySpotAuthority(snapshot.payload) ??
+    decodeServiceClosingSpotAuthority(snapshot.payload);
   if (
     decoded?.kind !== 'instance_spot' ||
     decoded.stableType !== target.stableType ||
@@ -582,7 +560,7 @@ function readyExisting(
   ) {
     throw new Error('Existing Instance authority is not a matching Ready allocation.');
   }
-  return { kind: 'ready', route: routeFromSnapshot(snapshot) };
+  return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
 }
 
 async function waitForActivationJoin(deadlineMs: number): Promise<void> {
@@ -619,7 +597,9 @@ function requireCommitIdentity(
 }
 
 function routeFromSnapshot(snapshot: ZLinkAuthoritySnapshot): ServiceInstanceRouteFence {
-  const decoded = decodeServiceReadySpotAuthority(snapshot.payload);
+  const decoded =
+    decodeServiceReadySpotAuthority(snapshot.payload) ??
+    decodeServiceClosingSpotAuthority(snapshot.payload);
   if (decoded?.kind !== 'instance_spot') {
     throw new Error('Instance authority is not Ready.');
   }

package/src/runtime/host/location-runtime-owner.ts

@@ -203,13 +203,15 @@ export class ZLinkLocationRuntimeOwner {
   async startForRuntime(
     primaryMeshName: string | undefined,
     spotNodeRuntime: ZLinkSpotNodeRuntimeManager,
-    channelRuntime: ZLinkChannelRuntimeManager
+    channelRuntime: ZLinkChannelRuntimeManager,
+    signal: AbortSignal,
+    shutdownSignal: () => AbortSignal
   ): Promise<ZLinkLocationRuntime | undefined> {
     const runtime = this.ensureRuntime(primaryMeshName);
     if (runtime === undefined) {
       return undefined;
     }
-    await runtime.start(this.ownerNodeRid(spotNodeRuntime));
+    await runtime.start(this.ownerNodeRid(spotNodeRuntime), signal, shutdownSignal);
     const stores = this.currentStores;
     if (stores === undefined) {
       return runtime;

package/src/runtime/host/remote-actor-join-receiver.ts

@@ -1,12 +1,8 @@
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import type { RoutingId, ZLinkRouteMessageContext } from '../../contracts';
+import type { RoutingId } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendActorRef } from '../backend';
 import type { DefaultZLinkActorManager } from '../actors';
-import {
-  mergeRemoteBoundSessionTarget,
-  preferredRemoteBoundSessionTarget
-} from '../actors/actor-runtime-state';
 import { decodeRemoteActorJoinPayload } from '../actors/actor-remote-wire';
 import type { DefaultZLinkSpotManager } from '../spots';
 import type { ZLinkAuthorityStore } from '../locations/internal-store-contracts';
@@ -15,7 +11,7 @@ import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
 } from '../framework-errors-internal';
-import { normalizeRoutingId, routingIdWireHex, routingIdsEqual } from '../routing-id';
+import { routingIdWireHex, routingIdsEqual } from '../routing-id';
 
 export interface ZLinkCanonicalActorJoinAuthorityFence {
   readonly actorId: string;
@@ -35,10 +31,7 @@ export interface ZLinkRemoteActorJoinReceiverOptions {
 export class ZLinkRemoteActorJoinReceiver {
   constructor(private readonly options: ZLinkRemoteActorJoinReceiverOptions) {}
 
-  async receive(
-    payload: unknown,
-    routeContext: ZLinkRouteMessageContext
-  ): Promise<{
+  async receive(payload: unknown): Promise<{
     readonly accepted: boolean;
     readonly actorNodeRid: string;
     readonly actorNodeRidHex?: string;
@@ -77,26 +70,6 @@ export class ZLinkRemoteActorJoinReceiver {
       generation: BigInt(join.actorGeneration)
     };
     state.setNativeActorRef(actorRef as unknown as ZLinkBackendActorRef);
-    const refreshedTarget = mergeRemoteBoundSessionTarget(
-      {
-        routerChannelId:
-          join.boundSessionRouterChannelId ??
-          join.routerChannelId ??
-          routeContext.channelName ??
-          '',
-        targetNodeRid:
-          join.boundSessionTargetNodeRid ?? normalizeRoutingId(routeContext.sourceNodeRid),
-        spotId:
-          join.boundSessionSpotId ??
-          join.sourceSpotId ??
-          normalizeRoutingId(routeContext.sourceNodeRid)
-      },
-      preferredRemoteBoundSessionTarget(
-        state.remoteBoundSessionTarget,
-        state.boundSessionTransferTarget
-      )
-    );
-    state.setRemoteBoundSessionTarget(refreshedTarget);
     const request = RuntimeMessage.from(Buffer.from(join.request, 'base64'));
     try {
       const response = await this.requireSpotManager().admitActorJoin(
@@ -105,7 +78,6 @@ export class ZLinkRemoteActorJoinReceiver {
         request,
         (spot) => {
           state.setJoinedSpot(join.spotId as RoutingId, spot);
-          return () => state.clearJoinedSpot();
         },
         undefined,
         undefined,

package/src/runtime/host/remote-actor-packet-target-store.ts

@@ -1,11 +1,15 @@
-import type { ActorRef, RoutingId, SpotId, ZLinkSessionActor } from '../../contracts';
-import { ZLinkSpotKind } from '../../contracts';
+import {
+  type ActorRef,
+  type RoutingId,
+  type ZLinkSessionActor,
+  ZLinkSpotKind
+} from '../../contracts';
+
 import type { DefaultZLinkActorManager, ZLinkRemoteActorPacketTarget } from '../actors';
-import type { ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
 import { decodeRemoteActorPacketTarget } from '../actors/actor-packet-relay-wire';
-import { normalizeRoutingId as normalizeRuntimeRoutingId } from '../routing-id';
-import type { MeshRouterResolver } from './mesh-router-resolver';
 import { routingIdsEqual } from '../routing-id';
+import type { ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
+import type { MeshRouterResolver } from './mesh-router-resolver';
 
 export interface ZLinkRemoteActorPacketTargetStoreOptions {
   readonly actorManager: () => DefaultZLinkActorManager | undefined;
@@ -100,10 +104,7 @@ export class ZLinkRemoteActorPacketTargetStore {
     );
   }
 
-  targetForState(
-    actorId: string,
-    routerChannelIdHint?: string
-  ): ZLinkRemoteActorPacketTarget | undefined {
+  targetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined {
     const state = this.options.actorManager()?.getState(actorId);
     if (
       state?.remoteActorPacketTarget !== undefined &&
@@ -112,51 +113,12 @@ export class ZLinkRemoteActorPacketTargetStore {
     ) {
       return state.remoteActorPacketTarget;
     }
-    const spotId = state?.spotId;
-    if (spotId !== undefined && state?.remoteActorPacketTarget !== undefined) {
-      //  The cached packet target refers to a different Spot than the
-      //  actor's current membership (the actor just moved Entry -> User).
-      //  Combining the stale target's node with the new Spot id fabricates
-      //  a route with no complete Ready authority fence, and the next
-      //  direct request then fails the fence check instead of resolving
-      //  the current owner route (spec 12 §direct payload uses the
-      //  Location Store's current owner route; spec 32:87 — an unavailable
-      //  route is Unavailable, not a fabricated hit). Publish no hint so
-      //  the source clears its cache and re-resolves completely.
-      return undefined;
-    }
-    const actorRef = state?.nativeActorRef as ActorRef | undefined;
-    const targetNodeRid =
-      (actorRef?.nodeRid as RoutingId | undefined) ?? this.options.primaryNodeRid();
-    const routerChannelId =
-      routerChannelIdHint ??
-      this.options.meshRouters.defaultSpotRouterChannelId() ??
-      this.options.meshRouters.defaultRouterChannelId();
-    const localNodeRid = this.options.primaryNodeRid();
-    if (
-      spotId === undefined &&
-      targetNodeRid !== undefined &&
-      localNodeRid !== undefined &&
-      routingIdsEqual(targetNodeRid, localNodeRid)
-    ) {
-      return undefined;
-    }
-    if (spotId === undefined || targetNodeRid === undefined || routerChannelId === undefined) {
-      return undefined;
-    }
-    return {
-      routerChannelId,
-      targetNodeRid: normalizeRuntimeRoutingId(targetNodeRid),
-      spotId: validateSpotId(spotId),
-      spotKind: ZLinkSpotKind.User,
-      ...(state?.spotGeneration === undefined ? {} : { targetSpotGeneration: state.spotGeneration })
-    };
+    return undefined;
   }
 
   targetForActorRef(actorRef: ActorRef): ZLinkRemoteActorPacketTarget | undefined {
     const targetNodeRid = actorRef.nodeRid as RoutingId;
-    const localNodeRid = this.options.primaryNodeRid();
-    if (localNodeRid !== undefined && routingIdsEqual(localNodeRid, targetNodeRid)) {
+    if (this.isLocalActorRef(actorRef)) {
       return undefined;
     }
     const meshName = actorRef.meshName;
@@ -176,6 +138,11 @@ export class ZLinkRemoteActorPacketTargetStore {
     };
   }
 
+  isLocalActorRef(actorRef: ActorRef): boolean {
+    const localNodeRid = this.options.primaryNodeRid();
+    return localNodeRid !== undefined && routingIdsEqual(localNodeRid, actorRef.nodeRid);
+  }
+
   tenureKeyForActor(actor: ZLinkSessionActor): string {
     return sessionActorPacketTargetTenureKey(actor);
   }
@@ -236,11 +203,3 @@ function sessionActorPacketTargetTenureKeyForRef(actorId: string, actorRef: Acto
     ref.ownerLeaseGeneration?.toString() ?? ''
   ].join(':');
 }
-
-function validateSpotId(value: string): SpotId {
-  const byteLength = Buffer.byteLength(value, 'utf8');
-  if (byteLength < 1 || byteLength > 255) {
-    throw new TypeError('SpotId must contain between 1 and 255 UTF-8 bytes.');
-  }
-  return value;
-}

package/src/runtime/host/remote-bound-session-relay.ts

@@ -54,10 +54,7 @@ export interface ZLinkRemoteBoundSessionRelayOptions {
   readonly destroyedActorRefs: ReadonlyMap<string, ActorRef>;
   readonly boundSessionFactory: (actorId: string) => DefaultZLinkBoundSession;
   readonly updateRemoteActorPacketTarget: (actorId: string, value: unknown) => Promise<void>;
-  readonly actorPacketTargetForState: (
-    actorId: string,
-    routerChannelIdHint?: string
-  ) => ZLinkRemoteActorPacketTarget | undefined;
+  readonly actorPacketTargetForState: (actorId: string) => ZLinkRemoteActorPacketTarget | undefined;
   readonly reportOwnershipRefreshError?: (actorId: string, error: unknown) => void;
 }
 
@@ -197,17 +194,6 @@ export class ZLinkRemoteBoundSessionRelay {
   async receiveRemoteBoundSessionSend(payload: unknown): Promise<{ readonly ok: boolean }> {
     const send = decodeRemoteBoundSessionSendPayload(payload);
     await this.options.updateRemoteActorPacketTarget(send.actorId, send.actorPacketTarget);
-    const owner = actorSessionBindingRuntimeOwnerIfRegistered(this.options.streamBindingRuntime());
-    const retained = await owner?.retainRelocationOutbound(
-      send.actorId,
-      {
-        deliver: () => this.deliverRemoteBoundSessionSend(send),
-        fail: (error) => this.options.reportOwnershipRefreshError?.(send.actorId, error)
-      },
-      send.relocationSealId
-    );
-    if (retained === 'retained') return { ok: true };
-    if (retained === 'rejected') return { ok: false };
     return { ok: await this.deliverRemoteBoundSessionSend(send) };
   }
 
@@ -349,7 +335,7 @@ export class ZLinkRemoteBoundSessionRelay {
       await owner.clearRelocation(actorId, error);
       void this.options
         .streamBindingRuntime()
-        .disconnectBoundSession(actorId)
+        .closeSessionBinding(actorId, value.session)
         .catch((disconnectError) =>
           this.options.reportOwnershipRefreshError?.(actorId, disconnectError)
         );
@@ -389,7 +375,7 @@ export class ZLinkRemoteBoundSessionRelay {
           await owner.clearRelocation(actorId, error);
           void this.options
             .streamBindingRuntime()
-            .disconnectBoundSession(actorId)
+            .closeSessionBinding(actorId, value.session)
             .catch((disconnectError) =>
               this.options.reportOwnershipRefreshError?.(actorId, disconnectError)
             );
@@ -425,15 +411,6 @@ export class ZLinkRemoteBoundSessionRelay {
     }
     const state = this.activeServiceWireRelocations.get(key);
     if (state === undefined) {
-      await actorSessionBindingRuntimeOwner(
-        this.options.streamBindingRuntime()
-      ).discardRelocationOutbound(
-        value.actor.actorId,
-        key,
-        new ZLinkRemoteBoundSessionFenceError(
-          `Actor '${value.actor.actorId}' command 44 did not match an active command 42.`
-        )
-      );
       this.warnLateSessionRouteUpdate(value);
       return;
     }
@@ -500,7 +477,7 @@ export class ZLinkRemoteBoundSessionRelay {
       );
       await this.options
         .streamBindingRuntime()
-        .disconnectBoundSession(state.actorId)
+        .closeSessionBinding(state.actorId, value.session)
         .catch((disconnectError) =>
           this.options.reportOwnershipRefreshError?.(state.actorId, disconnectError)
         );
@@ -528,7 +505,7 @@ export class ZLinkRemoteBoundSessionRelay {
     const owner = actorSessionBindingRuntimeOwner(runtime);
     const fingerprint = encodeSessionRelocationRoute(value).toString('base64');
     if (value.route.action === 'abort') {
-      await owner.applyRelocation(value.actor.actorId, key, fingerprint, 'abort', async () => {
+      await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
         if (!(await runtime.abortActorRouteSeal(value.actor.actorId, key))) {
           throw new ZLinkRemoteBoundSessionFenceError(
             `Actor '${value.actor.actorId}' command 44 abort lost its Session seal.`
@@ -550,9 +527,10 @@ export class ZLinkRemoteBoundSessionRelay {
         nodeRid: decodeWireRoutingId(committedRoute.targetNodeRid, undefined),
         bindingGeneration: value.session.bindingGeneration,
         ownershipGeneration: committedRoute.targetAuthorityOwnerGeneration,
-        ownerNodeGeneration: committedRoute.targetNodeGeneration
+        ownerNodeGeneration: committedRoute.targetNodeGeneration,
+        ownerLeaseGeneration: committedRoute.targetOwnerLeaseGeneration
       } as ActorRef;
-      await owner.applyRelocation(value.actor.actorId, key, fingerprint, 'commit', async () => {
+      await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
         await runtime.commitActorRoute(targetActorRef, undefined, {
           confirmRemoteSessionBinding: 'send',
           releaseSeal: { sealId: key }
@@ -591,13 +569,6 @@ export class ZLinkRemoteBoundSessionRelay {
     }
   }
 
-  rememberRemoteBoundSessionTarget(
-    actorId: string,
-    target: ZLinkRemoteBoundSessionTarget | undefined
-  ): void {
-    this.options.actorManager()?.getState(actorId)?.setRemoteBoundSessionTarget(target);
-  }
-
   resolveRemoteBoundSessionTarget(
     sourceNodeRid: RoutingId,
     sourceSessionRid: RoutingId
@@ -617,11 +588,8 @@ export class ZLinkRemoteBoundSessionRelay {
     };
   }
 
-  actorPacketTargetForState(
-    actorId: string,
-    routerChannelIdHint?: string
-  ): ZLinkRemoteActorPacketTarget | undefined {
-    return this.options.actorPacketTargetForState(actorId, routerChannelIdHint);
+  actorPacketTargetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined {
+    return this.options.actorPacketTargetForState(actorId);
   }
 
   clearOwnership(actorId: string): void {
@@ -767,7 +735,7 @@ export class ZLinkRemoteBoundSessionRelay {
     signal?: AbortSignal
   ): Promise<void> {
     const actorPacketTarget = encodeRemoteActorPacketTarget(
-      this.options.actorPacketTargetForState(actorId, target.routerChannelId)
+      this.options.actorPacketTargetForState(actorId)
     );
     await this.sendRemoteBoundSessionControl(
       target,
@@ -802,7 +770,7 @@ export class ZLinkRemoteBoundSessionRelay {
         error,
         metadata,
         actorPacketTarget: encodeRemoteActorPacketTarget(
-          this.options.actorPacketTargetForState(actorId, target.routerChannelId)
+          this.options.actorPacketTargetForState(actorId)
         )
       }),
       signal