@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/streams/actor-session-binding-registry.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkActorSessionBindingRegistry = exports.ZLinkActorSessionBindingTermination = exports.DEFAULT_TERMINAL_RELOCATION_CAPACITY = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
 const ZLinkFrameworkException_1 = require("../../contracts/Errors/ZLinkFrameworkException");
 const Options_1 = require("../../contracts/Locations/Options");
 const abort_1 = require("../abort");
 const state_lane_1 = require("../execution/state-lane");
+const routing_id_1 = require("../routing-id");
 const framework_errors_internal_1 = require("../framework-errors-internal");
+const service_stateful_wire_codec_1 = require("../foundation/service-stateful-wire-codec");
+const service_wire_m6a_codec_1 = require("../foundation/service-wire-m6a-codec");
+const bound_session_wire_1 = require("../actors/bound-session-wire");
 exports.DEFAULT_TERMINAL_RELOCATION_CAPACITY = 4096;
-const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:actor-session-binding-registry');
 var ZLinkActorSessionBindingTermination;
 (function (ZLinkActorSessionBindingTermination) {
     ZLinkActorSessionBindingTermination[ZLinkActorSessionBindingTermination["BindingEnd"] = 0] = "BindingEnd";
@@ -24,6 +26,7 @@ class ZLinkActorSessionBindingRegistry {
     sealWaiters = new Map();
     activeFrameWaiters = new Map();
     relocations = new Map();
+    absentSessionRelocationResults = new Map();
     terminalRelocations = new Map();
     constructor(terminalRelocationCapacity = exports.DEFAULT_TERMINAL_RELOCATION_CAPACITY, 
     //  Spec 06 — SessionRelocationSealTimeout bounds how long a session
@@ -51,26 +54,20 @@ class ZLinkActorSessionBindingRegistry {
         if (current !== previous) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `Actor '${actor.actorId}' session binding changed before route commit.`, true);
         }
+        const currentSessionIdentity = sessionIdentity ?? sessionIdentityFromContext(context);
         const sameBinding = previous !== undefined &&
-            previous.context === context &&
-            previous.bindingToken === bindingToken;
+            previous.bindingToken === bindingToken &&
+            (previous.context === context ||
+                (previous.sessionIdentity !== undefined &&
+                    currentSessionIdentity !== undefined &&
+                    (0, routing_id_1.routingIdsEqual)(previous.sessionIdentity, currentSessionIdentity)));
         const actorSlot = sameBinding ? previous.actorSlot : this.issueActorSlot(context);
         commitActor?.();
         context.bindLocal(actor, bindingToken, actorSlot);
         try {
             if (previous !== undefined && !sameBinding) {
-                this.routes.delete(actor.actorId);
-                previous.context.unbindLocal(actor.actorId, previous.bindingToken);
-                if (previous.actorSlot !== undefined) {
-                    let unbound;
-                    try {
-                        unbound = previous.context.actorSlotControls?.enqueueUnbound(previous.actorSlot);
-                    }
-                    catch (error) {
-                        unbound = Promise.reject(error);
-                    }
-                    void unbound?.catch((error) => this.errorSink?.()?.reportRuntimeTaskException('retired session actor unbound', error));
-                }
+                const unbound = this.unbindCore(actor.actorId, previous.context, previous.bindingToken, ZLinkActorSessionBindingTermination.BindingEnd);
+                void unbound?.catch((error) => this.errorSink?.()?.reportRuntimeTaskException('retired session actor unbound', error));
             }
             if (!sameBinding && actorSlot !== undefined) {
                 // Session–Actor binding §5-2: `$zlink.actor.bound` enters the ordered
@@ -90,15 +87,19 @@ class ZLinkActorSessionBindingRegistry {
             context.unbindLocal(actor.actorId, bindingToken);
             throw error;
         }
+        const bindingState = sameBinding ? previous : undefined;
         this.routes.set(actor.actorId, {
             context,
             actor,
             bindingToken,
             actorSlot,
-            sessionIdentity: sessionIdentity ?? sessionIdentityFromContext(context),
+            sessionIdentity: currentSessionIdentity,
+            // Accepted frames retain their completion fence across route replacement;
+            // the successor's seal must still drain them (Session binding §8.1).
             activeFrames: previous?.activeFrames ?? { count: 0, requests: new Set() },
-            sealId: previous?.sealId,
-            authorityFence: authorityFence ?? previous?.authorityFence
+            sealId: bindingState?.sealId,
+            sessionRelocationResult: bindingState?.sessionRelocationResult,
+            authorityFence: authorityFence ?? bindingState?.authorityFence
         });
     }
     issueActorSlot(context) {
@@ -143,7 +144,7 @@ class ZLinkActorSessionBindingRegistry {
         return await this.lane.run(() => {
             const route = this.routeCore(actorId);
             const generation = route?.actor.ref.bindingGeneration;
-            return route?.sessionIdentity === sessionRid &&
+            return (0, routing_id_1.routingIdsEqual)(route?.sessionIdentity, sessionRid) &&
                 (bindingGeneration === undefined || generation === bindingGeneration)
                 ? route
                 : undefined;
@@ -181,7 +182,12 @@ class ZLinkActorSessionBindingRegistry {
         this.clearRouteRelocation(actorId, route);
         if (termination === ZLinkActorSessionBindingTermination.BindingEnd &&
             route.actorSlot !== undefined) {
-            return context.actorSlotControls?.enqueueUnbound(route.actorSlot);
+            try {
+                return context.actorSlotControls?.enqueueUnbound(route.actorSlot);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
         }
         return undefined;
     }
@@ -409,6 +415,120 @@ class ZLinkActorSessionBindingRegistry {
         await this.lane.run(() => this.sealCore(actorId, sealId, expected));
         await this.waitForActiveFrames(actorId, signal);
     }
+    async prepareSessionRelocationSeal(value, signal) {
+        for (;;) {
+            const step = await this.lane.run(() => this.prepareSessionRelocationSealCore(value, signal));
+            if (step === undefined || !('predecessor' in step))
+                return step;
+            await waitForSessionRelocation(step.predecessor, signal);
+        }
+    }
+    prepareSessionRelocationSealCore(value, signal) {
+        const actorId = value.actor.actor.actorId;
+        const key = (0, service_stateful_wire_codec_1.serviceSessionRelocationIdentityKey)(value);
+        const fingerprint = (0, service_stateful_wire_codec_1.encodeSessionRelocationSeal)(value).toString('base64');
+        const route = this.routes.get(actorId);
+        const bindingResult = route?.sessionRelocationResult;
+        const recorded = this.absentSessionRelocationResults.get(key)?.result ??
+            (bindingResult?.key === key ? bindingResult : undefined);
+        if (recorded !== undefined) {
+            if (recorded.fingerprint !== fingerprint) {
+                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 42 with different bytes.`);
+            }
+            if (recorded.seal?.phase === 'terminal') {
+                console.warn(`late_session_relocation_seal session=${value.session.sessionRid}`);
+                return undefined;
+            }
+            return recorded;
+        }
+        (0, abort_1.throwIfAborted)(signal);
+        const response = {
+            relocation: value.relocation,
+            coordinator: value.coordinator,
+            actor: value.actor,
+            session: value.session,
+            sealResult: route === undefined ? 'bindingAbsent' : 'sealed'
+        };
+        if (route === undefined) {
+            const result = {
+                key,
+                fingerprint,
+                response,
+                ready: Promise.resolve()
+            };
+            const expiry = (0, state_lane_1.startOutsideStateLane)(() => setTimeout(() => {
+                void (async () => {
+                    await this.lane.run(() => this.absentSessionRelocationResults.delete(key));
+                })().catch((error) => this.errorSink?.()?.reportRuntimeTaskException('session relocation result expiry', error));
+            }, this.sealWaitTimeoutMs));
+            expiry.unref();
+            this.absentSessionRelocationResults.set(key, { result, expiry });
+            return result;
+        }
+        const expected = {
+            objectGeneration: value.actor.actor.generation,
+            bindingGeneration: value.session.bindingGeneration
+        };
+        if (!(0, routing_id_1.routingIdsEqual)(route.sessionIdentity, value.session.sessionRid) ||
+            !routeMatchesFence(route, expected) ||
+            (route.authorityFence !== undefined &&
+                value.actor.ownerLeaseGeneration < route.authorityFence.ownerLeaseGeneration) ||
+            (route.sealId !== undefined && route.sealId !== key)) {
+            throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${actorId}' command 42 was fenced by its exact Session route.`);
+        }
+        const step = this.prepareRelocationSeal({
+            actorId,
+            actorGeneration: value.actor.actor.generation,
+            bindingGeneration: value.session.bindingGeneration,
+            sessionIdentity: value.session.sessionRid,
+            actorNodeRid: value.actor.actor.nodeRid,
+            actorNodeGeneration: value.actor.targetNodeGeneration,
+            sealId: key
+        }, expected, signal);
+        if (step.kind === 'predecessor')
+            return { predecessor: step.wait };
+        const result = {
+            key,
+            fingerprint,
+            response,
+            ready: step.wait,
+            seal: this.relocations.get(actorId).seals.get(key)
+        };
+        route.sessionRelocationResult = result;
+        return result;
+    }
+    async acceptSessionRelocationRoute(value, apply) {
+        const key = (0, service_stateful_wire_codec_1.serviceSessionRelocationIdentityKey)(value);
+        const fingerprint = (0, service_stateful_wire_codec_1.encodeSessionRelocationRoute)(value).toString('base64');
+        const prepared = await this.lane.run(() => {
+            if (this.absentSessionRelocationResults.has(key))
+                return undefined;
+            const result = this.routes.get(value.actor.actorId)?.sessionRelocationResult;
+            if (result?.key !== key || result.seal === undefined)
+                return undefined;
+            const seal = result.seal;
+            if (seal.applyFingerprint !== undefined && seal.applyFingerprint !== fingerprint) {
+                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 44 with different bytes.`);
+            }
+            if (seal.phase === 'terminal')
+                return undefined;
+            return this.prepareRelocationApply(value.actor.actorId, key, fingerprint);
+        });
+        if (prepared === undefined)
+            return false;
+        await this.runRelocationApply(prepared, apply);
+        await this.observeRelocationTerminal(value.actor.actorId, key, fingerprint);
+        return true;
+    }
+    async clearSessionRelocationResults() {
+        await this.lane.run(() => {
+            for (const { expiry } of this.absentSessionRelocationResults.values())
+                clearTimeout(expiry);
+            this.absentSessionRelocationResults.clear();
+            for (const route of this.routes.values())
+                route.sessionRelocationResult = undefined;
+        });
+    }
     async sealRelocation(claim, expected, signal) {
         for (;;) {
             (0, abort_1.throwIfAborted)(signal);
@@ -467,11 +587,14 @@ class ZLinkActorSessionBindingRegistry {
     }
     async applyRelocation(actorId, sealId, applyFingerprint, commitOwnerTransition) {
         const prepared = await this.lane.run(() => this.prepareRelocationApply(actorId, sealId, applyFingerprint));
+        await this.runRelocationApply(prepared, commitOwnerTransition);
+    }
+    async runRelocationApply(prepared, commitOwnerTransition) {
         if (prepared.applyPromise !== undefined) {
             await prepared.applyPromise;
             return;
         }
-        startOutsideStateLane(() => {
+        (0, state_lane_1.startOutsideStateLane)(() => {
             void (async () => {
                 try {
                     await commitOwnerTransition();
@@ -552,10 +675,13 @@ class ZLinkActorSessionBindingRegistry {
      * single physical route's disconnect, which must not disturb a relocation
      * seal it does not own (see `clearRouteRelocation`).
      */
-    async clearRelocation(actorId, error) {
-        await this.lane.run(() => this.clearRelocationCore(actorId, error));
+    async clearRelocation(actorId, error, sealId) {
+        await this.lane.run(() => this.clearRelocationCore(actorId, error, sealId));
     }
-    clearRelocationCore(actorId, error) {
+    clearRelocationCore(actorId, error, sealId) {
+        const result = this.routes.get(actorId)?.sessionRelocationResult;
+        if (sealId !== undefined && (result?.key !== sealId || result.seal?.phase === 'terminal'))
+            return;
         const queue = this.relocations.get(actorId);
         if (queue === undefined)
             return;
@@ -569,8 +695,8 @@ class ZLinkActorSessionBindingRegistry {
         this.relocations.delete(actorId);
         for (const state of queue.seals.values()) {
             this.terminalRelocations.delete(state);
-            if (state.phase !== 'terminal')
-                state.resolveTerminal();
+            state.phase = 'terminal';
+            state.resolveTerminal();
         }
     }
     /**
@@ -592,7 +718,7 @@ class ZLinkActorSessionBindingRegistry {
         const activeState = activeSealId === undefined ? undefined : queue.seals.get(activeSealId);
         const ownsActiveSeal = activeState !== undefined &&
             activeState.phase !== 'terminal' &&
-            activeState.sessionIdentity === route.sessionIdentity;
+            (0, routing_id_1.routingIdsEqual)(activeState.sessionIdentity, route.sessionIdentity);
         if (!ownsActiveSeal) {
             // Nothing this exact route still holds open — leave terminal
             // retention and any other Session's active seal untouched.
@@ -602,6 +728,7 @@ class ZLinkActorSessionBindingRegistry {
         queue.activeSealId = undefined;
         queue.seals.delete(activeSealId);
         this.terminalRelocations.delete(activeState);
+        activeState.phase = 'terminal';
         activeState.resolveTerminal();
         this.deleteEmptyRelocationQueue(queue);
     }
@@ -616,13 +743,6 @@ class ZLinkActorSessionBindingRegistry {
         this.resolveSealWaiters(actorId, sealId);
         return true;
     }
-    async updateAuthorityFence(actorId, authorityFence) {
-        await this.lane.run(() => this.updateAuthorityFenceCore(actorId, authorityFence));
-    }
-    updateAuthorityFenceCore(actorId, authorityFence) {
-        const route = this.requireRouteCore(actorId);
-        route.authorityFence = authorityFence;
-    }
     async validateSeal(actorId, sealId) {
         return await this.lane.run(() => this.validateSealCore(actorId, sealId));
     }
@@ -679,7 +799,7 @@ class ZLinkActorSessionBindingRegistry {
                 if (waiters.size === 0)
                     this.sealWaiters.delete(actorId);
             };
-            timer = startOutsideStateLane(() => setTimeout(() => {
+            timer = (0, state_lane_1.startOutsideStateLane)(() => setTimeout(() => {
                 this.lane.tryPost(() => {
                     removeWaiter();
                     rejectWaiter((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Actor '${actorId}' session seal was not released within the relocation seal timeout.`, true));
@@ -698,7 +818,7 @@ class ZLinkActorSessionBindingRegistry {
                 onAbort();
                 return;
             }
-            startOutsideStateLane(() => signal.addEventListener('abort', onAbort, { once: true }));
+            (0, state_lane_1.startOutsideStateLane)(() => signal.addEventListener('abort', onAbort, { once: true }));
         });
     }
     async waitForActiveFrames(actorId, signal) {
@@ -749,7 +869,7 @@ class ZLinkActorSessionBindingRegistry {
             //  Spec 48:205 — transport/deadline limits keep applying during
             //  relocation: the sealing side must not wait forever for active
             //  frames that themselves may be waiting on this relocation.
-            timer = startOutsideStateLane(() => setTimeout(() => {
+            timer = (0, state_lane_1.startOutsideStateLane)(() => setTimeout(() => {
                 this.lane.tryPost(() => {
                     waiters.delete(waiter);
                     if (waiters.size === 0)
@@ -763,7 +883,7 @@ class ZLinkActorSessionBindingRegistry {
             if (signal.aborted)
                 onAbort();
             else
-                startOutsideStateLane(() => signal.addEventListener('abort', onAbort, { once: true }));
+                (0, state_lane_1.startOutsideStateLane)(() => signal.addEventListener('abort', onAbort, { once: true }));
         });
     }
     resolveActiveFrameWaiters(actorId) {
@@ -838,7 +958,7 @@ class ZLinkActorSessionBindingRegistry {
     startHeldOneWayDrain(actorId, queue) {
         if (queue.ingressDrain !== undefined)
             return;
-        const drain = startOutsideStateLane(async () => {
+        const drain = (0, state_lane_1.startOutsideStateLane)(async () => {
             for (;;) {
                 const next = await this.lane.run(() => {
                     if (this.relocations.get(actorId) !== queue)
@@ -859,7 +979,7 @@ class ZLinkActorSessionBindingRegistry {
             }
         });
         queue.ingressDrain = drain;
-        startOutsideStateLane(() => {
+        (0, state_lane_1.startOutsideStateLane)(() => {
             void drain.finally(async () => {
                 await this.lane.run(() => {
                     if (queue.ingressDrain !== drain)
@@ -878,19 +998,16 @@ exports.ZLinkActorSessionBindingRegistry = ZLinkActorSessionBindingRegistry;
 function assertRelocationClaim(state, claim) {
     if (state.actorGeneration !== claim.actorGeneration ||
         state.bindingGeneration !== claim.bindingGeneration ||
-        state.sessionIdentity !== claim.sessionIdentity ||
-        state.actorNodeRid !== claim.actorNodeRid ||
+        !(0, routing_id_1.routingIdsEqual)(state.sessionIdentity, claim.sessionIdentity) ||
+        !(0, routing_id_1.routingIdsEqual)(state.actorNodeRid, claim.actorNodeRid) ||
         state.actorNodeGeneration !== claim.actorNodeGeneration) {
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${claim.actorId}' repeated Session seal changed its exact identity.`, true);
     }
 }
-function startOutsideStateLane(work) {
-    return detachedStateLaneResource.runInAsyncScope(work);
-}
 function assertSuccessorSessionIdentity(predecessor, successor) {
     if (predecessor.actorGeneration !== successor.actorGeneration ||
         predecessor.bindingGeneration !== successor.bindingGeneration ||
-        predecessor.sessionIdentity !== successor.sessionIdentity) {
+        !(0, routing_id_1.routingIdsEqual)(predecessor.sessionIdentity, successor.sessionIdentity)) {
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${successor.actorId}' successor Session seal changed its exact Session identity.`, true);
     }
 }
@@ -901,7 +1018,7 @@ function routeMatchesFence(route, expected) {
         ref.bindingGeneration === expected.bindingGeneration);
 }
 function sessionIdentityFromContext(context) {
-    return context.routingId === undefined ? undefined : String(context.routingId);
+    return context.routingId;
 }
 function waitForSessionRelocation(operation, signal) {
     if (signal === undefined)

package/dist/runtime/streams/actor-session-binding-runtime-owner.d.ts

@@ -1,12 +1,16 @@
+import type { RoutingId } from '../../contracts';
+import type { ServiceSessionRelocationSeal, ServiceSessionRelocationRoute } from '../foundation/service-stateful-wire-codec';
 import type { ActorRef } from '../../contracts';
-import type { ZLinkActorSessionAuthorityFence, ZLinkActorSessionRelocationClaim, ZLinkActorSessionRelocationSnapshot, ZLinkActorSessionRouteFence } from './actor-session-binding-registry';
+import type { ZLinkActorSessionAuthorityFence, ZLinkActorSessionRelocationSnapshot, ZLinkPreparedSessionRelocationSeal } from './actor-session-binding-registry';
 export interface ZLinkActorSessionBindingRuntimeOwner {
-    actorSlot(actorId: string, sessionRid: string): Promise<number | undefined>;
-    sealRelocation(claim: ZLinkActorSessionRelocationClaim, expected: ZLinkActorSessionRouteFence, signal?: AbortSignal): Promise<void>;
+    prepareSessionRelocationSeal(value: ServiceSessionRelocationSeal, signal?: AbortSignal): Promise<ZLinkPreparedSessionRelocationSeal | undefined>;
+    acceptSessionRelocationRoute(value: ServiceSessionRelocationRoute, apply: () => Promise<void>): Promise<boolean>;
+    clearSessionRelocationResults(): Promise<void>;
+    actorSlot(actorId: string, sessionRid: RoutingId): Promise<number | undefined>;
     relocationSnapshot(actorId: string, sealId: string): Promise<ZLinkActorSessionRelocationSnapshot | undefined>;
     applyRelocation(actorId: string, sealId: string, applyFingerprint: string, commitOwnerTransition: () => Promise<void>): Promise<void>;
     observeRelocationTerminal(actorId: string, sealId: string, applyFingerprint: string): Promise<void>;
-    clearRelocation(actorId: string, error: unknown): Promise<void>;
+    clearRelocation(actorId: string, error: unknown, sealId?: string): Promise<void>;
     committedRoute(actorId: string): Promise<{
         readonly actor: ActorRef;
         readonly authorityFence?: ZLinkActorSessionAuthorityFence;

package/dist/runtime/streams/bound-actor-relay-sender.d.ts

@@ -7,13 +7,14 @@ import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle
 import { type ZLinkStreamFrameHeader } from './protocol';
 import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
 import { ZLinkStreamFrameMessageFactory } from './stream-frame-factory';
+import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
 export declare const DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS = 2000;
 export interface ZLinkBoundActorRelaySenderOptions {
     readonly dispatchErrors?: ZLinkDispatchErrorReporter;
     readonly actorBindTimeoutMs?: number;
     readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
     readonly relay?: (actor: ZLinkSessionActor, header: ZLinkStreamFrameHeader, payload: Message) => Promise<boolean>;
-    readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
+    readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal, binding?: ServiceStreamSessionBinding) => Promise<void>;
 }
 export declare class ZLinkBoundActorRelaySender {
     private readonly routes;

package/dist/runtime/streams/bound-actor-relay-sender.js

@@ -159,15 +159,18 @@ class ZLinkBoundActorRelaySender {
         const detached = await this.lifecycle.run(actor.actorId, async () => {
             await this.routes.requireCurrentToken(actor.actorId, actor.bindingToken);
             const route = await this.routes.requireRoute(actor.actorId);
+            const binding = route.context.stream instanceof managed_stream_1.ZLinkManagedStream
+                ? route.context.stream.actorBinding(actor.actorId)
+                : undefined;
             await this.routes.unbind(actor.actorId, route.context, actor.bindingToken);
-            return route;
+            return { route, binding };
         });
         if (unbindNative &&
-            detached.bindingToken === actor.bindingToken &&
-            detached.context.stream instanceof managed_stream_1.ZLinkManagedStream) {
-            await detached.context.stream.unbindActor(actor.actorId, this.options.actorBindTimeoutMs ?? exports.DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS, signal);
+            detached.route.bindingToken === actor.bindingToken &&
+            detached.route.context.stream instanceof managed_stream_1.ZLinkManagedStream) {
+            await detached.route.context.stream.unbindActor(actor.actorId, this.options.actorBindTimeoutMs ?? exports.DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS, signal);
         }
-        await this.options.notifyDisconnected?.(actor, signal);
+        await this.options.notifyDisconnected?.(actor, signal, detached.binding);
     }
     async notifyPhysicalDisconnect(context) {
         const snapshot = [...context.boundActors];
@@ -184,16 +187,20 @@ class ZLinkBoundActorRelaySender {
                 // The transport is already closed, so remove its exact route before
                 // invoking application lifecycle code. A reconnect can then install
                 // a successor while this best-effort notification is in flight.
+                const binding = context.stream instanceof managed_stream_1.ZLinkManagedStream
+                    ? context.stream.actorBinding(actor.actorId)
+                    : undefined;
                 await this.routes.unbind(actor.actorId, context, actor.bindingToken, actor_session_binding_registry_1.ZLinkActorSessionBindingTermination.PhysicalDisconnect);
-                return true;
+                return { binding };
             });
-            if (!detached)
+            if (detached === false)
                 return;
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), timeoutMs);
             try {
                 await Promise.race([
-                    this.options.notifyDisconnected?.(actor, controller.signal) ?? Promise.resolve(),
+                    this.options.notifyDisconnected?.(actor, controller.signal, detached.binding) ??
+                        Promise.resolve(),
                     new Promise((_, reject) => {
                         controller.signal.addEventListener('abort', () => reject(new Error(`Actor '${actor.actorId}' disconnect notification exceeded ${timeoutMs} ms.`)), { once: true });
                     })

package/dist/runtime/streams/bound-session-service.d.ts

@@ -38,7 +38,7 @@ export declare class ZLinkBoundSessionService {
     sendNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
     sendNativeBoundSessionResponse(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean, signal?: AbortSignal): Promise<void>;
     sendNativeBoundSessionError(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<void>;
-    disconnectNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, signal?: AbortSignal): Promise<void>;
+    disconnectNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, timeoutMs: number, signal?: AbortSignal): Promise<void>;
     disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
     /**
      * Closes the physical Session of one exact binding after its relocation

package/dist/runtime/streams/bound-session-service.js

@@ -86,22 +86,17 @@ class ZLinkBoundSessionService {
         (0, abort_1.throwIfAborted)(signal);
         await this.sendNativeBoundSessionPayload(node, actorRef, protocol_1.ZLinkStreamMessageKind.Error, packetName, metadata, false, requestSeq, (0, bound_session_response_target_1.boundSessionErrorPayload)(error), signal);
     }
-    async disconnectNativeBoundSession(node, actorRef, signal) {
+    async disconnectNativeBoundSession(node, actorRef, timeoutMs, signal) {
         (0, abort_1.throwIfAborted)(signal);
-        await node.closeActorBoundSession(actorRef, requireBoundSessionGeneration(actorRef), 0, signal);
+        await node.closeActorBoundSession(toBoundSessionSendActorRef(actorRef), requireBoundSessionGeneration(actorRef), timeoutMs, signal);
     }
     async disconnectBoundSession(actorId, signal) {
         (0, abort_1.throwIfAborted)(signal);
         const route = await this.routes.requireRoute(actorId);
-        try {
-            await this.requireTransport().disconnect(actorId, {
-                bindingToken: route.bindingToken,
-                signal
-            });
-        }
-        finally {
-            await this.routes.unbind(actorId, route.context, route.bindingToken);
-        }
+        await this.requireTransport().disconnect(actorId, {
+            bindingToken: route.bindingToken,
+            signal
+        });
     }
     /**
      * Closes the physical Session of one exact binding after its relocation

package/dist/runtime/streams/index.d.ts

@@ -9,6 +9,7 @@ import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import { ApplicationJobQueue } from '../host/application-job-queue';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import { type ZLinkActorSessionAuthorityFence } from './actor-session-binding-registry';
+import { type ZLinkBoundActorRelaySenderOptions } from './bound-actor-relay-sender';
 import { type ZLinkBoundSessionResponseTarget } from './bound-session-response-target';
 import { type ZLinkBoundSessionTransport } from './bound-session-service';
 import { ZLinkManagedStream } from './managed-stream';
@@ -45,7 +46,7 @@ export interface ZLinkStreamBindingRuntimeOptions {
         reportRuntimeTaskException(taskName: string, error: unknown): void;
     } | undefined;
     readonly relay?: (actor: ZLinkSessionActor, header: ZLinkStreamFrameHeader, payload: Message) => Promise<boolean>;
-    readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
+    readonly notifyDisconnected?: ZLinkBoundActorRelaySenderOptions['notifyDisconnected'];
     readonly flowCreationEnabled?: () => boolean;
     readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
 }
@@ -139,7 +140,7 @@ export declare class ZLinkStreamBindingRuntime {
     sendNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
     sendNativeBoundSessionResponse(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, packetName: string, requestSeq: bigint, message: unknown, metadata: ReadonlyMap<string, string>, compressPayload: boolean, signal?: AbortSignal): Promise<void>;
     sendNativeBoundSessionError(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<void>;
-    disconnectNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, signal?: AbortSignal): Promise<void>;
+    disconnectNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, timeoutMs: number, signal?: AbortSignal): Promise<void>;
     disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
     closeSessionBinding(actorId: string, expected: ZLinkSessionBindingIdentity, signal?: AbortSignal): Promise<void>;
     relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;

package/dist/runtime/streams/index.js

@@ -220,12 +220,14 @@ class ZLinkStreamBindingRuntime {
         this.sessionActors = new session_actor_coordinator_1.ZLinkSessionActorCoordinator(this.routes, this, runtimeOptions, actorSessionLifecycle);
         this.boundActorRelay = new bound_actor_relay_sender_1.ZLinkBoundActorRelaySender(this.routes, this.frameMessages, runtimeOptions, actorSessionLifecycle);
         (0, actor_session_binding_runtime_owner_1.registerActorSessionBindingRuntimeOwner)(this, {
+            prepareSessionRelocationSeal: (...args) => this.routes.prepareSessionRelocationSeal(...args),
+            acceptSessionRelocationRoute: (value, apply) => this.routes.acceptSessionRelocationRoute(value, apply),
+            clearSessionRelocationResults: () => this.routes.clearSessionRelocationResults(),
             actorSlot: async (actorId, sessionRid) => (await this.routes.routeForSessionBinding(actorId, sessionRid))?.actorSlot,
-            sealRelocation: (claim, expected, signal) => this.routes.sealRelocation(claim, expected, signal),
             relocationSnapshot: (actorId, sealId) => this.routes.relocationSnapshot(actorId, sealId),
             applyRelocation: (...args) => this.routes.applyRelocation(...args),
             observeRelocationTerminal: (...args) => this.routes.observeRelocationTerminal(...args),
-            clearRelocation: (actorId, error) => this.routes.clearRelocation(actorId, error),
+            clearRelocation: (...args) => this.routes.clearRelocation(...args),
             committedRoute: async (actorId) => {
                 const route = await this.routes.route(actorId);
                 return route === undefined
@@ -319,8 +321,8 @@ class ZLinkStreamBindingRuntime {
     async sendNativeBoundSessionError(node, actorRef, packetName, requestSeq, error, metadata, signal) {
         await this.boundSessions.sendNativeBoundSessionError(node, actorRef, packetName, requestSeq, error, metadata, signal);
     }
-    async disconnectNativeBoundSession(node, actorRef, signal) {
-        await this.boundSessions.disconnectNativeBoundSession(node, actorRef, signal);
+    async disconnectNativeBoundSession(node, actorRef, timeoutMs, signal) {
+        await this.boundSessions.disconnectNativeBoundSession(node, actorRef, timeoutMs, signal);
     }
     async disconnectBoundSession(actorId, signal) {
         await this.boundSessions.disconnectBoundSession(actorId, signal);

package/dist/runtime/streams/managed-stream.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkManagedStream = void 0;
 exports.streamSessionIdFromRoutingId = streamSessionIdFromRoutingId;
+const routing_id_1 = require("../routing-id");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const abort_1 = require("../abort");
@@ -140,7 +141,7 @@ class ZLinkManagedStream {
                 ? undefined
                 : (_actorId, retiredSession, replacedActor) => {
                     onBindingReplaced(replacedActor, retiredSession);
-                }, toStreamSessionActorAuthorityFence(authorityFence)), signal), `Actor '${actor.actorId}' native session bind`);
+                }, toStreamSessionActorAuthorityFence(authorityFence), () => this.close()), signal), `Actor '${actor.actorId}' native session bind`);
             const binding = route.service
                 .bindings(this.backendRoutingId())
                 .find((candidate) => candidate.actor.actorId === nativeActor.actorId &&
@@ -180,7 +181,7 @@ class ZLinkManagedStream {
                 resolved === undefined ||
                 resolved.actorId !== actor.actorId ||
                 resolved.generation !== actor.objectGeneration ||
-                String(resolved.nodeRid) !== String(actor.nodeRid)) {
+                !(0, routing_id_1.routingIdsEqual)(resolved.nodeRid, actor.nodeRid)) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${actor.actorId}' native route fence does not match its ActorRef ` +
                     `(expected ${String(actor.nodeRid)}/${actor.objectGeneration}, ` +
                     `resolved ${(0, diagnostic_text_1.diagnosticTextOrAbsent)(resolved === undefined