@zlink-systems/framework 0.30.1 → 0.30.2

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

@@ -1,3 +1,14 @@
+import type { RoutingId } from '../../contracts';
+import { type ServiceSessionRelocationRoute, type ServiceSessionRelocationSeal, type ServiceSessionRelocationSealed } from '../foundation/service-stateful-wire-codec';
+export interface ZLinkPreparedSessionRelocationSeal {
+    readonly response: ServiceSessionRelocationSealed;
+    readonly ready: Promise<void>;
+}
+interface SessionRelocationResult extends ZLinkPreparedSessionRelocationSeal {
+    readonly key: string;
+    readonly fingerprint: string;
+    readonly seal?: ZLinkActorSessionRelocationState;
+}
 export declare const DEFAULT_TERMINAL_RELOCATION_CAPACITY = 4096;
 export interface ZLinkActorSessionBindingActor {
     readonly actorId: string;
@@ -7,7 +18,7 @@ export interface ZLinkActorSessionBindingActor {
     };
 }
 export interface ZLinkActorSessionBindingContext<TActor extends ZLinkActorSessionBindingActor> {
-    readonly routingId?: unknown;
+    readonly routingId?: RoutingId;
     readonly actorSlotControls?: {
         enqueueBound(actorSlot: number, actorId: string): Promise<void>;
         enqueueUnbound(actorSlot: number): Promise<void>;
@@ -20,17 +31,18 @@ export interface ZLinkActorSessionRoute<TContext extends ZLinkActorSessionBindin
     readonly actor: TActor;
     readonly bindingToken: string;
     readonly actorSlot?: number;
-    readonly sessionIdentity?: string;
+    readonly sessionIdentity?: RoutingId;
     readonly activeFrames: ZLinkActorSessionActiveFrames;
     sealId?: string;
+    sessionRelocationResult?: SessionRelocationResult;
     authorityFence?: ZLinkActorSessionAuthorityFence;
 }
 export interface ZLinkActorSessionRelocationClaim {
     readonly actorId: string;
     readonly actorGeneration: bigint;
     readonly bindingGeneration: bigint;
-    readonly sessionIdentity?: string;
-    readonly actorNodeRid?: string;
+    readonly sessionIdentity?: RoutingId;
+    readonly actorNodeRid?: RoutingId;
     readonly actorNodeGeneration?: bigint;
     readonly sealId: string;
 }
@@ -57,6 +69,21 @@ interface ZLinkActorSessionActiveFrames {
         captureBySeal(): void;
     }>;
 }
+interface ZLinkActorSessionRelocationState {
+    readonly actorId: string;
+    readonly actorGeneration: bigint;
+    readonly bindingGeneration: bigint;
+    readonly sessionIdentity?: RoutingId;
+    readonly actorNodeRid?: RoutingId;
+    readonly actorNodeGeneration?: bigint;
+    readonly sealId: string;
+    phase: 'sealed' | 'applying' | 'applied' | 'terminal';
+    applyFingerprint?: string;
+    applyPromise?: Promise<void>;
+    readonly ready: Promise<void>;
+    readonly terminal: Promise<void>;
+    readonly resolveTerminal: () => void;
+}
 export interface ZLinkActorSessionAuthorityFence {
     readonly authorityOwnerGeneration: bigint;
     readonly ownerLeaseGeneration: bigint;
@@ -79,21 +106,22 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     private readonly sealWaiters;
     private readonly activeFrameWaiters;
     private readonly relocations;
+    private readonly absentSessionRelocationResults;
     private readonly terminalRelocations;
     constructor(terminalRelocationCapacity?: number, sealWaitTimeoutMs?: number, errorSink?: (() => {
         reportRuntimeTaskException(taskName: string, error: unknown): void;
     } | undefined) | undefined);
-    bind(context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string, commitActor?: () => void): Promise<void>;
+    bind(context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: RoutingId, commitActor?: () => void): Promise<void>;
     private commitCore;
     private issueActorSlot;
-    replace(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string, commitActor?: () => void): Promise<void>;
-    replaceAndReleaseSeal(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, sealId: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: string, commitActor?: () => void): Promise<void>;
+    replace(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: RoutingId, commitActor?: () => void): Promise<void>;
+    replaceAndReleaseSeal(previous: ZLinkActorSessionRoute<TContext, TActor>, context: TContext, actor: TActor, bindingToken: string, sealId: string, authorityFence?: ZLinkActorSessionAuthorityFence, sessionIdentity?: RoutingId, commitActor?: () => void): Promise<void>;
     private replaceAndReleaseSealCore;
     find(actorId: string): Promise<TActor | undefined>;
     private findCore;
     route(actorId: string): Promise<ZLinkActorSessionRoute<TContext, TActor> | undefined>;
     /** Selects the route only when it is the exact Session binding (§8.1 validation values). */
-    routeForSessionBinding(actorId: string, sessionRid: string, bindingGeneration?: bigint): Promise<ZLinkActorSessionRoute<TContext, TActor> | undefined>;
+    routeForSessionBinding(actorId: string, sessionRid: RoutingId, bindingGeneration?: bigint): Promise<ZLinkActorSessionRoute<TContext, TActor> | undefined>;
     private routeCore;
     capturePendingReplyClaim(actorId: string, actor: ZLinkActorSessionBindingActor, bindingToken: string): Promise<{
         readonly context: TContext;
@@ -131,11 +159,16 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     seal(actorId: string, sealId: string, expected: ZLinkActorSessionRouteFence): Promise<void>;
     private sealCore;
     sealAndWait(actorId: string, sealId: string, expected: ZLinkActorSessionRouteFence, signal?: AbortSignal): Promise<void>;
+    prepareSessionRelocationSeal(value: ServiceSessionRelocationSeal, signal?: AbortSignal): Promise<ZLinkPreparedSessionRelocationSeal | undefined>;
+    private prepareSessionRelocationSealCore;
+    acceptSessionRelocationRoute(value: ServiceSessionRelocationRoute, apply: () => Promise<void>): Promise<boolean>;
+    clearSessionRelocationResults(): Promise<void>;
     sealRelocation(claim: ZLinkActorSessionRelocationClaim, expected: ZLinkActorSessionRouteFence, signal?: AbortSignal): Promise<void>;
     private prepareRelocationSeal;
     relocationSnapshot(actorId: string, sealId: string): Promise<ZLinkActorSessionRelocationSnapshot | undefined>;
     private relocationSnapshotCore;
     applyRelocation(actorId: string, sealId: string, applyFingerprint: string, commitOwnerTransition: () => Promise<void>): Promise<void>;
+    private runRelocationApply;
     private prepareRelocationApply;
     private completeRelocationApply;
     private failRelocationApply;
@@ -149,7 +182,7 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
      * single physical route's disconnect, which must not disturb a relocation
      * seal it does not own (see `clearRouteRelocation`).
      */
-    clearRelocation(actorId: string, error: unknown): Promise<void>;
+    clearRelocation(actorId: string, error: unknown, sealId?: string): Promise<void>;
     private clearRelocationCore;
     /**
      * Spec 48 §137: a relocation seal's lifecycle is independent of any single
@@ -165,8 +198,6 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     private clearRouteRelocation;
     abortSeal(actorId: string, sealId: string): Promise<boolean>;
     private abortSealCore;
-    updateAuthorityFence(actorId: string, authorityFence: ZLinkActorSessionAuthorityFence): Promise<void>;
-    private updateAuthorityFenceCore;
     validateSeal(actorId: string, sealId: string): Promise<boolean>;
     private validateSealCore;
     /** True while a relocation seal currently holds this actor's ingress. */

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