@zlink-systems/framework 0.21.0 → 0.23.0

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

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkActorSessionBindingRegistry = void 0;
+exports.ZLinkActorSessionBindingRegistry = exports.ZLinkActorSessionBindingTermination = void 0;
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const abort_1 = require("../abort");
 const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
 const routing_id_1 = require("../routing-id");
 const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:actor-session-binding-registry');
+var ZLinkActorSessionBindingTermination;
+(function (ZLinkActorSessionBindingTermination) {
+    ZLinkActorSessionBindingTermination[ZLinkActorSessionBindingTermination["BindingEnd"] = 0] = "BindingEnd";
+    ZLinkActorSessionBindingTermination[ZLinkActorSessionBindingTermination["PhysicalDisconnect"] = 1] = "PhysicalDisconnect";
+})(ZLinkActorSessionBindingTermination || (exports.ZLinkActorSessionBindingTermination = ZLinkActorSessionBindingTermination = {}));
 class ZLinkActorSessionBindingRegistry {
     terminalRelocationCapacity;
     outboundCapacity;
     sealWaitTimeoutMs;
+    errorSink;
     lane = new state_lane_1.ZLinkStateLane();
     routes = new Map();
+    nextActorSlots = new WeakMap();
     sealWaiters = new Map();
     activeFrameWaiters = new Map();
     relocations = new Map();
@@ -24,10 +31,11 @@ class ZLinkActorSessionBindingRegistry {
     //  (the sealing side) must observe that bound; an unbounded wait here
     //  turns a lost control or a lifecycle interlock into a silent stall
     //  (spec 48:205 — transport/deadline limits apply during relocation).
-    sealWaitTimeoutMs = 3_000) {
+    sealWaitTimeoutMs = 3_000, errorSink) {
         this.terminalRelocationCapacity = terminalRelocationCapacity;
         this.outboundCapacity = outboundCapacity;
         this.sealWaitTimeoutMs = sealWaitTimeoutMs;
+        this.errorSink = errorSink;
         if (!Number.isSafeInteger(terminalRelocationCapacity) || terminalRelocationCapacity <= 0) {
             throw new RangeError('Session relocation terminal capacity must be a positive safe integer.');
         }
@@ -38,62 +46,78 @@ class ZLinkActorSessionBindingRegistry {
             throw new RangeError('Session relocation seal timeout must be a positive safe integer.');
         }
     }
-    async bind(context, actor, bindingToken, authorityFence, sessionIdentity) {
-        await this.lane.run(() => this.bindCore(context, actor, bindingToken, authorityFence, sessionIdentity));
+    async bind(context, actor, bindingToken, authorityFence, sessionIdentity, commitActor) {
+        await this.lane.run(() => this.commitCore(undefined, context, actor, bindingToken, authorityFence, sessionIdentity, commitActor));
     }
-    bindCore(context, actor, bindingToken, authorityFence, sessionIdentity) {
-        this.routes.set(actor.actorId, {
-            context,
-            actor,
-            bindingToken,
-            sessionIdentity: sessionIdentity ?? sessionIdentityFromContext(context),
-            activeFrames: { count: 0, requests: new Set() },
-            authorityFence
-        });
-        context.bindLocal(actor, bindingToken);
-    }
-    async replace(previous, context, actor, bindingToken, authorityFence, sessionIdentity) {
-        await this.lane.run(() => this.replaceCore(previous, context, actor, bindingToken, authorityFence, sessionIdentity));
-    }
-    replaceCore(previous, context, actor, bindingToken, authorityFence, sessionIdentity) {
+    async commitCore(previous, context, actor, bindingToken, authorityFence, sessionIdentity, commitActor) {
         const current = this.routes.get(actor.actorId);
         if (current !== previous) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `Actor '${actor.actorId}' session binding changed before route replacement.`, true);
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `Actor '${actor.actorId}' session binding changed before route commit.`, true);
         }
-        context.bindLocal(actor, bindingToken);
-        const sameLocalBinding = previous.context === context
-            && previous.bindingToken === bindingToken;
-        if (!sameLocalBinding) {
-            try {
+        const sameBinding = previous !== undefined &&
+            previous.context === context &&
+            previous.bindingToken === bindingToken;
+        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));
+                }
             }
-            catch (error) {
-                context.unbindLocal(actor.actorId, bindingToken);
-                previous.context.bindLocal(previous.actor, previous.bindingToken);
-                throw error;
+            if (!sameBinding && actorSlot !== undefined) {
+                await context.actorSlotControls.enqueueBound(actorSlot, actor.actorId);
             }
         }
+        catch (error) {
+            context.unbindLocal(actor.actorId, bindingToken);
+            throw error;
+        }
         this.routes.set(actor.actorId, {
             context,
             actor,
             bindingToken,
+            actorSlot,
             sessionIdentity: sessionIdentity ?? sessionIdentityFromContext(context),
-            activeFrames: previous.activeFrames,
-            sealId: previous.sealId,
-            authorityFence: authorityFence ?? previous.authorityFence
+            activeFrames: previous?.activeFrames ?? { count: 0, requests: new Set() },
+            sealId: previous?.sealId,
+            authorityFence: authorityFence ?? previous?.authorityFence
         });
     }
-    async replaceAndReleaseSeal(previous, context, actor, bindingToken, sealId, authorityFence, sessionIdentity) {
-        await this.lane.run(() => this.replaceAndReleaseSealCore(previous, context, actor, bindingToken, sealId, authorityFence, sessionIdentity));
+    issueActorSlot(context) {
+        if (context.actorSlotControls === undefined)
+            return undefined;
+        const actorSlot = this.nextActorSlots.get(context) ?? 1;
+        if (actorSlot > 0xffff) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Stream session '${String(context.routingId)}' exhausted its Actor slots.`);
+        }
+        this.nextActorSlots.set(context, actorSlot + 1);
+        return actorSlot;
+    }
+    async replace(previous, context, actor, bindingToken, authorityFence, sessionIdentity, commitActor) {
+        await this.lane.run(() => this.commitCore(previous, context, actor, bindingToken, authorityFence, sessionIdentity, commitActor));
+    }
+    async replaceAndReleaseSeal(previous, context, actor, bindingToken, sealId, authorityFence, sessionIdentity, commitActor) {
+        await this.lane.run(() => this.replaceAndReleaseSealCore(previous, context, actor, bindingToken, sealId, authorityFence, sessionIdentity, commitActor));
     }
-    replaceAndReleaseSealCore(previous, context, actor, bindingToken, sealId, authorityFence, sessionIdentity) {
+    async replaceAndReleaseSealCore(previous, context, actor, bindingToken, sealId, authorityFence, sessionIdentity, commitActor) {
         if (previous.sealId !== sealId) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${actor.actorId}' route switch did not match its relocation seal.`, true);
         }
         // JavaScript cannot interleave another ingress turn between these two
         // synchronous mutations. The replacement preserves the seal, then the
         // exact release publishes the route to held ingress as one owner turn.
-        this.replaceCore(previous, context, actor, bindingToken, authorityFence, sessionIdentity);
+        await this.commitCore(previous, context, actor, bindingToken, authorityFence, sessionIdentity, commitActor);
         if (!this.abortSealCore(actor.actorId, sealId)) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${actor.actorId}' route switch lost its relocation seal.`, true);
         }
@@ -120,10 +144,10 @@ class ZLinkActorSessionBindingRegistry {
         }
         return Object.freeze({ context: route.context });
     }
-    async unbind(actorId, context, bindingToken) {
-        await this.lane.run(() => this.unbindCore(actorId, context, bindingToken));
+    async unbind(actorId, context, bindingToken, termination = ZLinkActorSessionBindingTermination.BindingEnd) {
+        await this.lane.run(() => this.unbindCore(actorId, context, bindingToken, termination));
     }
-    unbindCore(actorId, context, bindingToken) {
+    async unbindCore(actorId, context, bindingToken, termination) {
         const route = this.routes.get(actorId);
         if (route === undefined || route.context !== context || route.bindingToken !== bindingToken) {
             return;
@@ -133,24 +157,28 @@ class ZLinkActorSessionBindingRegistry {
         this.rejectSealWaiters(actorId, new Error(`Actor '${actorId}' session binding was removed while ingress was held.`));
         this.rejectActiveFrameWaiters(actorId, new Error(`Actor '${actorId}' session binding was removed while accepted frames were active.`));
         this.clearRouteRelocation(actorId, route, new Error(`Actor '${actorId}' session binding was removed.`));
+        if (termination === ZLinkActorSessionBindingTermination.BindingEnd &&
+            route.actorSlot !== undefined) {
+            await context.actorSlotControls?.enqueueUnbound(route.actorSlot);
+        }
     }
     async unbindActor(actorId) {
         await this.lane.run(() => this.unbindActorCore(actorId));
     }
-    unbindActorCore(actorId) {
+    async unbindActorCore(actorId) {
         const route = this.routes.get(actorId);
         if (route === undefined) {
             return;
         }
-        this.unbindCore(actorId, route.context, route.bindingToken);
+        await this.unbindCore(actorId, route.context, route.bindingToken, ZLinkActorSessionBindingTermination.BindingEnd);
     }
     async cleanup(context) {
         await this.lane.run(() => this.cleanupCore(context));
     }
-    cleanupCore(context) {
+    async cleanupCore(context) {
         for (const route of [...this.routes.values()]) {
             if (route.context === context) {
-                this.unbindCore(route.actor.actorId, context, route.bindingToken);
+                await this.unbindCore(route.actor.actorId, context, route.bindingToken, ZLinkActorSessionBindingTermination.PhysicalDisconnect);
             }
         }
     }
@@ -238,8 +266,8 @@ class ZLinkActorSessionBindingRegistry {
                 return;
             completed = true;
             route.activeFrames.count--;
-            if (route.activeFrames.count === 0
-                && this.routes.get(actorId)?.activeFrames === route.activeFrames) {
+            if (route.activeFrames.count === 0 &&
+                this.routes.get(actorId)?.activeFrames === route.activeFrames) {
                 this.resolveActiveFrameWaiters(actorId);
             }
         };
@@ -356,9 +384,7 @@ class ZLinkActorSessionBindingRegistry {
             assertRelocationClaim(existing, claim);
             return { kind: 'existing', wait: existing.ready };
         }
-        const predecessor = queue?.activeSealId === undefined
-            ? undefined
-            : queue.seals.get(queue.activeSealId);
+        const predecessor = queue?.activeSealId === undefined ? undefined : queue.seals.get(queue.activeSealId);
         if (predecessor !== undefined && predecessor.phase !== 'terminal') {
             if (predecessor.sessionIdentity === undefined || claim.sessionIdentity === undefined) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${claim.actorId}' session ingress is sealed by another relocation.`, true);
@@ -368,7 +394,9 @@ class ZLinkActorSessionBindingRegistry {
         }
         this.sealCore(claim.actorId, claim.sealId, expected);
         let resolveTerminal;
-        const terminal = new Promise((resolve) => { resolveTerminal = resolve; });
+        const terminal = new Promise((resolve) => {
+            resolveTerminal = resolve;
+        });
         const ready = this.waitForActiveFramesCore(claim.actorId, signal);
         const actorQueue = queue ?? {
             actorId: claim.actorId,
@@ -402,10 +430,10 @@ class ZLinkActorSessionBindingRegistry {
         if (sealId !== undefined) {
             const queue = this.relocations.get(actorId);
             const state = queue?.seals.get(sealId);
-            if (queue === undefined
-                || state === undefined
-                || (queue.activeSealId !== sealId
-                    && !(queue.activeSealId === undefined && state.phase === 'terminal'))) {
+            if (queue === undefined ||
+                state === undefined ||
+                (queue.activeSealId !== sealId &&
+                    !(queue.activeSealId === undefined && state.phase === 'terminal'))) {
                 failRetainedOutbound(operation, new Error(`Actor '${actorId}' Session outbound did not match its exact relocation seal.`));
                 return 'rejected';
             }
@@ -417,9 +445,7 @@ class ZLinkActorSessionBindingRegistry {
     }
     admitRelocationOutboundCore(claim, operation) {
         const queue = this.relocations.get(claim.actorId);
-        const state = queue?.activeSealId === undefined
-            ? undefined
-            : queue.seals.get(queue.activeSealId);
+        const state = queue?.activeSealId === undefined ? undefined : queue.seals.get(queue.activeSealId);
         const error = this.outboundAdmissionError(claim);
         if (error !== undefined) {
             failRetainedOutbound(operation, error);
@@ -437,14 +463,11 @@ class ZLinkActorSessionBindingRegistry {
         if (state.phase === 'sealed' || state.phase === 'applying') {
             const matchesSource = matchesRelocationSourceProof(state, claim);
             const matchesCurrent = this.matchesCurrentProducerNode(claim);
-            const authorization = matchesSource || matchesCurrent
-                ? 'source'
-                : 'pendingTarget';
+            const authorization = matchesSource || matchesCurrent ? 'source' : 'pendingTarget';
             return this.retainRelocationOutboundCore(claim.actorId, operation, authorization, claim);
         }
         const acceptedProof = state.acceptedProducerProof;
-        if (acceptedProof === undefined
-            || !matchesAcceptedProducerProof(acceptedProof, claim)) {
+        if (acceptedProof === undefined || !matchesAcceptedProducerProof(acceptedProof, claim)) {
             failRetainedOutbound(operation, new Error(`Actor '${claim.actorId}' Session outbound admission did not match its accepted producer proof.`));
             return 'rejected';
         }
@@ -452,9 +475,7 @@ class ZLinkActorSessionBindingRegistry {
     }
     retainRelocationOutboundCore(actorId, operation, authorization, claim) {
         const queue = this.relocations.get(actorId);
-        const state = queue?.activeSealId === undefined
-            ? undefined
-            : queue.seals.get(queue.activeSealId);
+        const state = queue?.activeSealId === undefined ? undefined : queue.seals.get(queue.activeSealId);
         if (queue === undefined)
             return 'passThrough';
         if (state === undefined || state.phase === 'applied' || state.phase === 'terminal') {
@@ -535,9 +556,9 @@ class ZLinkActorSessionBindingRegistry {
             }
             return { queue, state, applyPromise: state.applyPromise };
         }
-        if (action === 'commit'
-            && acceptedProducerProof !== undefined
-            && !validAcceptedTargetProof(state, acceptedProducerProof)) {
+        if (action === 'commit' &&
+            acceptedProducerProof !== undefined &&
+            !validAcceptedTargetProof(state, acceptedProducerProof)) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${actorId}' command 44 target producer proof did not match its Session seal.`, true);
         }
         if (action === 'abort' && acceptedProducerProof !== undefined) {
@@ -567,7 +588,7 @@ class ZLinkActorSessionBindingRegistry {
     completeRelocationApply(prepared) {
         const { queue, state, action, acceptedProducerProof, actorId, sealId } = prepared;
         const proof = action === 'commit'
-            ? acceptedProducerProof ?? this.currentProducerProof(actorId)
+            ? (acceptedProducerProof ?? this.currentProducerProof(actorId))
             : relocationSourceProof(state);
         state.acceptedProducerProof = proof;
         for (let index = queue.outbound.length - 1; index >= 0; index--) {
@@ -578,10 +599,10 @@ class ZLinkActorSessionBindingRegistry {
                 entry.released = true;
                 continue;
             }
-            if (action === 'commit'
-                && proof !== undefined
-                && entry.claim !== undefined
-                && matchesAcceptedProducerProof(proof, entry.claim)) {
+            if (action === 'commit' &&
+                proof !== undefined &&
+                entry.claim !== undefined &&
+                matchesAcceptedProducerProof(proof, entry.claim)) {
                 entry.released = true;
                 continue;
             }
@@ -601,16 +622,16 @@ class ZLinkActorSessionBindingRegistry {
         const route = this.routes.get(actorId);
         const actorRef = (route?.actor).ref;
         const sessionIdentity = route?.sessionIdentity;
-        if (route === undefined
-            || actorRef === undefined
-            || sessionIdentity === undefined
-            || actorRef.ownerNodeGeneration === undefined)
+        if (route === undefined ||
+            actorRef === undefined ||
+            sessionIdentity === undefined ||
+            actorRef.ownerNodeGeneration === undefined)
             return undefined;
         return {
             actorId,
-            objectGeneration: BigInt(actorRef.objectGeneration
-                ?? actorRef.generation
-                ?? -1),
+            objectGeneration: BigInt(actorRef.objectGeneration ??
+                actorRef.generation ??
+                -1),
             actorNodeRid: String(actorRef.nodeRid ?? ''),
             actorNodeGeneration: BigInt(actorRef.ownerNodeGeneration),
             sessionIdentity: String(sessionIdentity),
@@ -623,10 +644,10 @@ class ZLinkActorSessionBindingRegistry {
     observeRelocationTerminalCore(actorId, sealId, applyFingerprint) {
         const queue = this.relocations.get(actorId);
         const state = queue?.seals.get(sealId);
-        if (queue === undefined
-            || state === undefined
-            || state.applyFingerprint !== applyFingerprint
-            || (state.phase !== 'applied' && state.phase !== 'terminal')) {
+        if (queue === undefined ||
+            state === undefined ||
+            state.applyFingerprint !== applyFingerprint ||
+            (state.phase !== 'applied' && state.phase !== 'terminal')) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${actorId}' Session relocation terminal did not match its exact route apply.`, true);
         }
         if (state.phase === 'terminal') {
@@ -680,9 +701,9 @@ class ZLinkActorSessionBindingRegistry {
             return;
         const activeSealId = queue.activeSealId;
         const activeState = activeSealId === undefined ? undefined : queue.seals.get(activeSealId);
-        const ownsActiveSeal = activeState !== undefined
-            && activeState.phase !== 'terminal'
-            && activeState.sessionIdentity === route.sessionIdentity;
+        const ownsActiveSeal = activeState !== undefined &&
+            activeState.phase !== 'terminal' &&
+            activeState.sessionIdentity === route.sessionIdentity;
         if (!ownsActiveSeal) {
             // Nothing this exact route still holds open — leave terminal
             // retention and any other Session's active seal untouched.
@@ -725,8 +746,7 @@ class ZLinkActorSessionBindingRegistry {
     }
     validateSealCore(actorId, sealId) {
         const route = this.routes.get(actorId);
-        return route !== undefined
-            && route.sealId === sealId;
+        return route !== undefined && route.sealId === sealId;
     }
     /** True while a relocation seal currently holds this actor's ingress. */
     async isSealed(actorId) {
@@ -952,30 +972,30 @@ class ZLinkActorSessionBindingRegistry {
         failRetainedOutbound(entry.operation, error);
     }
     outboundAdmissionError(claim) {
-        if (claim.actorId.length === 0
-            || claim.objectGeneration <= 0n
-            || claim.actorNodeRid.length === 0
-            || claim.actorNodeGeneration <= 0n
-            || claim.producerNodeRid.length === 0
-            || claim.producerNodeGeneration <= 0n
-            || claim.bindingGeneration <= 0n
-            || claim.sessionIdentity.length === 0
-            || !(0, routing_id_1.routingIdsEqual)(claim.producerNodeRid, claim.actorNodeRid)
-            || claim.producerNodeGeneration !== claim.actorNodeGeneration) {
+        if (claim.actorId.length === 0 ||
+            claim.objectGeneration <= 0n ||
+            claim.actorNodeRid.length === 0 ||
+            claim.actorNodeGeneration <= 0n ||
+            claim.producerNodeRid.length === 0 ||
+            claim.producerNodeGeneration <= 0n ||
+            claim.bindingGeneration <= 0n ||
+            claim.sessionIdentity.length === 0 ||
+            !(0, routing_id_1.routingIdsEqual)(claim.producerNodeRid, claim.actorNodeRid) ||
+            claim.producerNodeGeneration !== claim.actorNodeGeneration) {
             return new Error(`Actor '${claim.actorId}' Session outbound admission claim is invalid.`);
         }
         const route = this.routes.get(claim.actorId);
         const ref = route?.actor;
         const actorRef = ref?.ref;
         const routeSessionIdentity = route?.sessionIdentity;
-        if (route === undefined
-            || actorRef === undefined
-            || String(actorRef.actorId ?? claim.actorId) !== claim.actorId
-            || BigInt(actorRef.objectGeneration
-                ?? actorRef.generation
-                ?? -1) !== claim.objectGeneration
-            || BigInt(actorRef.bindingGeneration ?? -1) !== claim.bindingGeneration
-            || String(routeSessionIdentity ?? '') !== claim.sessionIdentity) {
+        if (route === undefined ||
+            actorRef === undefined ||
+            String(actorRef.actorId ?? claim.actorId) !== claim.actorId ||
+            BigInt(actorRef.objectGeneration ??
+                actorRef.generation ??
+                -1) !== claim.objectGeneration ||
+            BigInt(actorRef.bindingGeneration ?? -1) !== claim.bindingGeneration ||
+            String(routeSessionIdentity ?? '') !== claim.sessionIdentity) {
             return new Error(`Actor '${claim.actorId}' Session outbound admission was fenced by its current binding.`);
         }
         return undefined;
@@ -983,9 +1003,9 @@ class ZLinkActorSessionBindingRegistry {
     matchesCurrentProducerNode(claim) {
         const route = this.routes.get(claim.actorId);
         const actorRef = (route?.actor).ref;
-        return route !== undefined
-            && actorRef !== undefined
-            && (0, routing_id_1.routingIdsEqual)(String(actorRef.nodeRid ?? ''), claim.actorNodeRid);
+        return (route !== undefined &&
+            actorRef !== undefined &&
+            (0, routing_id_1.routingIdsEqual)(String(actorRef.nodeRid ?? ''), claim.actorNodeRid));
     }
     rememberTerminalRelocation(state) {
         this.terminalRelocations.delete(state);
@@ -1003,11 +1023,11 @@ class ZLinkActorSessionBindingRegistry {
         }
     }
     deleteEmptyRelocationQueue(queue) {
-        if (queue.activeSealId === undefined
-            && queue.seals.size === 0
-            && queue.outbound.length === 0
-            && queue.drainPromise === undefined
-            && this.relocations.get(queue.actorId) === queue) {
+        if (queue.activeSealId === undefined &&
+            queue.seals.size === 0 &&
+            queue.outbound.length === 0 &&
+            queue.drainPromise === undefined &&
+            this.relocations.get(queue.actorId) === queue) {
             this.relocations.delete(queue.actorId);
         }
     }
@@ -1030,11 +1050,11 @@ class ZLinkActorSessionBindingRegistry {
 }
 exports.ZLinkActorSessionBindingRegistry = ZLinkActorSessionBindingRegistry;
 function assertRelocationClaim(state, claim) {
-    if (state.actorGeneration !== claim.actorGeneration
-        || state.bindingGeneration !== claim.bindingGeneration
-        || state.sessionIdentity !== claim.sessionIdentity
-        || state.actorNodeRid !== claim.actorNodeRid
-        || state.actorNodeGeneration !== claim.actorNodeGeneration) {
+    if (state.actorGeneration !== claim.actorGeneration ||
+        state.bindingGeneration !== claim.bindingGeneration ||
+        state.sessionIdentity !== claim.sessionIdentity ||
+        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);
     }
 }
@@ -1042,34 +1062,34 @@ function startOutsideStateLane(work) {
     return detachedStateLaneResource.runInAsyncScope(work);
 }
 function matchesRelocationSourceProof(state, claim) {
-    return state.actorId === claim.actorId
-        && state.actorGeneration === claim.objectGeneration
-        && state.bindingGeneration === claim.bindingGeneration
-        && state.sessionIdentity === claim.sessionIdentity
-        && state.actorNodeRid !== undefined
-        && (0, routing_id_1.routingIdsEqual)(state.actorNodeRid, claim.actorNodeRid)
-        && state.actorNodeGeneration === claim.actorNodeGeneration;
+    return (state.actorId === claim.actorId &&
+        state.actorGeneration === claim.objectGeneration &&
+        state.bindingGeneration === claim.bindingGeneration &&
+        state.sessionIdentity === claim.sessionIdentity &&
+        state.actorNodeRid !== undefined &&
+        (0, routing_id_1.routingIdsEqual)(state.actorNodeRid, claim.actorNodeRid) &&
+        state.actorNodeGeneration === claim.actorNodeGeneration);
 }
 function matchesAcceptedProducerProof(proof, claim) {
-    return proof.actorId === claim.actorId
-        && proof.objectGeneration === claim.objectGeneration
-        && (0, routing_id_1.routingIdsEqual)(proof.actorNodeRid, claim.actorNodeRid)
-        && proof.actorNodeGeneration === claim.actorNodeGeneration
-        && proof.sessionIdentity === claim.sessionIdentity
-        && proof.bindingGeneration === claim.bindingGeneration;
+    return (proof.actorId === claim.actorId &&
+        proof.objectGeneration === claim.objectGeneration &&
+        (0, routing_id_1.routingIdsEqual)(proof.actorNodeRid, claim.actorNodeRid) &&
+        proof.actorNodeGeneration === claim.actorNodeGeneration &&
+        proof.sessionIdentity === claim.sessionIdentity &&
+        proof.bindingGeneration === claim.bindingGeneration);
 }
 function validAcceptedTargetProof(state, proof) {
-    return proof.actorId === state.actorId
-        && proof.objectGeneration === state.actorGeneration
-        && proof.actorNodeRid.length > 0
-        && proof.actorNodeGeneration > 0n
-        && proof.sessionIdentity === state.sessionIdentity
-        && proof.bindingGeneration === state.bindingGeneration;
+    return (proof.actorId === state.actorId &&
+        proof.objectGeneration === state.actorGeneration &&
+        proof.actorNodeRid.length > 0 &&
+        proof.actorNodeGeneration > 0n &&
+        proof.sessionIdentity === state.sessionIdentity &&
+        proof.bindingGeneration === state.bindingGeneration);
 }
 function relocationSourceProof(state) {
-    if (state.sessionIdentity === undefined
-        || state.actorNodeRid === undefined
-        || state.actorNodeGeneration === undefined)
+    if (state.sessionIdentity === undefined ||
+        state.actorNodeRid === undefined ||
+        state.actorNodeGeneration === undefined)
         return undefined;
     return {
         actorId: state.actorId,
@@ -1090,17 +1110,17 @@ function failRetainedOutbound(operation, error) {
     }
 }
 function assertSuccessorSessionIdentity(predecessor, successor) {
-    if (predecessor.actorGeneration !== successor.actorGeneration
-        || predecessor.bindingGeneration !== successor.bindingGeneration
-        || predecessor.sessionIdentity !== successor.sessionIdentity) {
+    if (predecessor.actorGeneration !== successor.actorGeneration ||
+        predecessor.bindingGeneration !== successor.bindingGeneration ||
+        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);
     }
 }
 function routeMatchesFence(route, expected) {
     const ref = route.actor.ref;
-    return ref !== undefined
-        && BigInt(ref.objectGeneration ?? ref.generation ?? -1n) === expected.objectGeneration
-        && ref.bindingGeneration === expected.bindingGeneration;
+    return (ref !== undefined &&
+        BigInt(ref.objectGeneration ?? ref.generation ?? -1n) === expected.objectGeneration &&
+        ref.bindingGeneration === expected.bindingGeneration);
 }
 function sessionIdentityFromContext(context) {
     return context.routingId === undefined ? undefined : String(context.routingId);
@@ -1119,7 +1139,7 @@ function waitForSessionRelocation(operation, signal) {
         operation.then(() => {
             signal.removeEventListener('abort', onAbort);
             resolve();
-        }, error => {
+        }, (error) => {
             signal.removeEventListener('abort', onAbort);
             reject(error);
         });

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

@@ -2,6 +2,7 @@ import type { ActorRef } from '../../contracts';
 import type { ServiceSessionBindingAdmissionClaim, ServiceSessionBindingAdmissionResult } from '../foundation/service-session-binding-ingress-port';
 import type { ZLinkActorSessionAuthorityFence, ZLinkActorSessionAcceptedProducerProof, ZLinkActorSessionRelocationClaim, ZLinkActorSessionRelocationSnapshot, ZLinkActorSessionRetainedOutbound, ZLinkActorSessionRouteFence } 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>;
     relocationSnapshot(actorId: string, sealId: string): Promise<ZLinkActorSessionRelocationSnapshot | undefined>;
     retainRelocationOutbound(actorId: string, operation: ZLinkActorSessionRetainedOutbound, sealId?: string): Promise<ServiceSessionBindingAdmissionResult>;

package/dist/runtime/streams/actor-session-lifecycle-coordinator.js

@@ -6,7 +6,9 @@ class ZLinkActorSessionLifecycleCoordinator {
     async run(actorId, operation) {
         const previous = this.tails.get(actorId) ?? Promise.resolve();
         let release;
-        const current = new Promise((resolve) => { release = resolve; });
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
         const tail = previous.catch(() => undefined).then(() => current);
         this.tails.set(actorId, tail);
         await previous.catch(() => undefined);