@zlink-systems/framework 0.24.0 → 0.26.0

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

@@ -1,4 +1,4 @@
-import type { ServiceSessionBindingAdmissionClaim, ServiceSessionBindingAdmissionResult } from '../foundation/service-session-binding-ingress-port';
+import type { ServiceSessionBindingAdmissionResult } from '../foundation/service-session-binding-ingress-port';
 export interface ZLinkActorSessionBindingActor {
     readonly actorId: string;
 }
@@ -34,14 +34,6 @@ export interface ZLinkActorSessionRetainedOutbound {
     deliver(): Promise<boolean>;
     fail(error: unknown): void;
 }
-export interface ZLinkActorSessionAcceptedProducerProof {
-    readonly actorId: string;
-    readonly objectGeneration: bigint;
-    readonly actorNodeRid: string;
-    readonly actorNodeGeneration: bigint;
-    readonly sessionIdentity: string;
-    readonly bindingGeneration: bigint;
-}
 export interface ZLinkActorSessionRelocationSnapshot extends ZLinkActorSessionRelocationClaim {
     readonly phase: 'sealed' | 'applying' | 'applied' | 'terminal';
     readonly applyFingerprint?: string;
@@ -139,16 +131,24 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     private relocationSnapshotCore;
     retainRelocationOutbound(actorId: string, operation: ZLinkActorSessionRetainedOutbound, sealId?: string): Promise<ServiceSessionBindingAdmissionResult>;
     private retainRelocationOutboundCorePublic;
-    admitRelocationOutbound(claim: ServiceSessionBindingAdmissionClaim, operation: ZLinkActorSessionRetainedOutbound): Promise<ServiceSessionBindingAdmissionResult>;
-    private admitRelocationOutboundCore;
+    /**
+     * Session–Actor binding §8.1: the Session owner holds a push only while the
+     * binding's relocation seal is open, and keeps it behind earlier held pushes.
+     * Whether the push names the current binding was decided once by the Session
+     * owner's binding record before this call.
+     */
     private retainRelocationOutboundCore;
     discardRelocationOutbound(actorId: string, sealId: string, error: unknown): Promise<void>;
     private discardRelocationOutboundCore;
-    applyRelocation(actorId: string, sealId: string, applyFingerprint: string, action: 'commit' | 'abort', commitOwnerTransition: () => Promise<void>, acceptedProducerProof?: ZLinkActorSessionAcceptedProducerProof): Promise<void>;
+    applyRelocation(actorId: string, sealId: string, applyFingerprint: string, commitOwnerTransition: () => Promise<void>): Promise<void>;
     private prepareRelocationApply;
+    /**
+     * Command 44 commit or abort releases every push held under this seal in
+     * arrival order (Session–Actor binding §8.1). The held pushes were admitted
+     * by the current binding; the route change does not judge them again.
+     */
     private completeRelocationApply;
     private failRelocationApply;
-    private currentProducerProof;
     observeRelocationTerminal(actorId: string, sealId: string, applyFingerprint: string): Promise<void>;
     private observeRelocationTerminalCore;
     /**
@@ -192,8 +192,6 @@ export declare class ZLinkActorSessionBindingRegistry<TContext extends ZLinkActo
     private reserveOutbound;
     private settleOutbound;
     private failOutbound;
-    private outboundAdmissionError;
-    private matchesCurrentProducerNode;
     private rememberTerminalRelocation;
     private deleteEmptyRelocationQueue;
     private resolveSealWaiters;

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

@@ -5,7 +5,6 @@ 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) {
@@ -438,42 +437,15 @@ class ZLinkActorSessionBindingRegistry {
                 return 'rejected';
             }
         }
-        return this.retainRelocationOutboundCore(actorId, operation, 'legacy');
+        return this.retainRelocationOutboundCore(actorId, operation);
     }
-    async admitRelocationOutbound(claim, operation) {
-        return await this.lane.run(() => this.admitRelocationOutboundCore(claim, operation));
-    }
-    admitRelocationOutboundCore(claim, operation) {
-        const queue = this.relocations.get(claim.actorId);
-        const state = queue?.activeSealId === undefined ? undefined : queue.seals.get(queue.activeSealId);
-        const error = this.outboundAdmissionError(claim);
-        if (error !== undefined) {
-            failRetainedOutbound(operation, error);
-            return 'rejected';
-        }
-        if (queue === undefined || state === undefined) {
-            if (!this.matchesCurrentProducerNode(claim)) {
-                failRetainedOutbound(operation, new Error(`Actor '${claim.actorId}' Session outbound admission was fenced by its current binding.`));
-                return 'rejected';
-            }
-            if (queue === undefined)
-                return 'passThrough';
-            return this.retainRelocationOutboundCore(claim.actorId, operation, 'source', claim);
-        }
-        if (state.phase === 'sealed' || state.phase === 'applying') {
-            const matchesSource = matchesRelocationSourceProof(state, claim);
-            const matchesCurrent = this.matchesCurrentProducerNode(claim);
-            const authorization = matchesSource || matchesCurrent ? 'source' : 'pendingTarget';
-            return this.retainRelocationOutboundCore(claim.actorId, operation, authorization, claim);
-        }
-        const acceptedProof = state.acceptedProducerProof;
-        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';
-        }
-        return this.retainRelocationOutboundCore(claim.actorId, operation, 'source', claim);
-    }
-    retainRelocationOutboundCore(actorId, operation, authorization, claim) {
+    /**
+     * Session–Actor binding §8.1: the Session owner holds a push only while the
+     * binding's relocation seal is open, and keeps it behind earlier held pushes.
+     * Whether the push names the current binding was decided once by the Session
+     * owner's binding record before this call.
+     */
+    retainRelocationOutboundCore(actorId, operation) {
         const queue = this.relocations.get(actorId);
         const state = queue?.activeSealId === undefined ? undefined : queue.seals.get(queue.activeSealId);
         if (queue === undefined)
@@ -485,9 +457,7 @@ class ZLinkActorSessionBindingRegistry {
                 return 'rejected';
             queue.outbound.push({
                 operation,
-                authorization,
                 arrivalOrder: queue.nextArrivalOrder++,
-                ...(claim === undefined ? {} : { claim }),
                 released: true,
                 settled: false
             });
@@ -499,9 +469,7 @@ class ZLinkActorSessionBindingRegistry {
         queue.outbound.push({
             sealId: state.sealId,
             operation,
-            authorization,
             arrivalOrder: queue.nextArrivalOrder++,
-            ...(claim === undefined ? {} : { claim }),
             released: false,
             settled: false
         });
@@ -523,8 +491,8 @@ class ZLinkActorSessionBindingRegistry {
         }
         this.deleteEmptyRelocationQueue(queue);
     }
-    async applyRelocation(actorId, sealId, applyFingerprint, action, commitOwnerTransition, acceptedProducerProof) {
-        const prepared = await this.lane.run(() => this.prepareRelocationApply(actorId, sealId, applyFingerprint, action, acceptedProducerProof));
+    async applyRelocation(actorId, sealId, applyFingerprint, commitOwnerTransition) {
+        const prepared = await this.lane.run(() => this.prepareRelocationApply(actorId, sealId, applyFingerprint));
         if (prepared.applyPromise !== undefined) {
             await prepared.applyPromise;
             return;
@@ -544,7 +512,7 @@ class ZLinkActorSessionBindingRegistry {
         });
         await prepared.promise;
     }
-    prepareRelocationApply(actorId, sealId, applyFingerprint, action, acceptedProducerProof) {
+    prepareRelocationApply(actorId, sealId, applyFingerprint) {
         const queue = this.relocations.get(actorId);
         const state = queue?.seals.get(sealId);
         if (queue === undefined || state === undefined) {
@@ -556,14 +524,6 @@ class ZLinkActorSessionBindingRegistry {
             }
             return { queue, state, applyPromise: state.applyPromise };
         }
-        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) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${actorId}' abort route supplied a target producer proof.`, true);
-        }
         state.phase = 'applying';
         state.applyFingerprint = applyFingerprint;
         let resolve;
@@ -576,38 +536,22 @@ class ZLinkActorSessionBindingRegistry {
         return {
             queue,
             state,
-            action,
-            acceptedProducerProof,
             promise,
             resolve,
             reject,
-            actorId,
             sealId
         };
     }
+    /**
+     * Command 44 commit or abort releases every push held under this seal in
+     * arrival order (Session–Actor binding §8.1). The held pushes were admitted
+     * by the current binding; the route change does not judge them again.
+     */
     completeRelocationApply(prepared) {
-        const { queue, state, action, acceptedProducerProof, actorId, sealId } = prepared;
-        const proof = action === 'commit'
-            ? (acceptedProducerProof ?? this.currentProducerProof(actorId))
-            : relocationSourceProof(state);
-        state.acceptedProducerProof = proof;
-        for (let index = queue.outbound.length - 1; index >= 0; index--) {
-            const entry = queue.outbound[index];
-            if (entry.sealId !== sealId)
-                continue;
-            if (entry.authorization !== 'pendingTarget') {
-                entry.released = true;
-                continue;
-            }
-            if (action === 'commit' &&
-                proof !== undefined &&
-                entry.claim !== undefined &&
-                matchesAcceptedProducerProof(proof, entry.claim)) {
+        const { queue, state, sealId } = prepared;
+        for (const entry of queue.outbound) {
+            if (entry.sealId === sealId)
                 entry.released = true;
-                continue;
-            }
-            queue.outbound.splice(index, 1);
-            this.failOutbound(queue, entry, new Error(`Actor '${actorId}' pending Session producer did not match command 44 proof.`));
         }
         this.startOutboundDrain(queue);
         state.phase = 'applied';
@@ -616,27 +560,6 @@ class ZLinkActorSessionBindingRegistry {
         prepared.state.phase = 'sealed';
         prepared.state.applyFingerprint = undefined;
         prepared.state.applyPromise = undefined;
-        prepared.state.acceptedProducerProof = undefined;
-    }
-    currentProducerProof(actorId) {
-        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)
-            return undefined;
-        return {
-            actorId,
-            objectGeneration: BigInt(actorRef.objectGeneration ??
-                actorRef.generation ??
-                -1),
-            actorNodeRid: String(actorRef.nodeRid ?? ''),
-            actorNodeGeneration: BigInt(actorRef.ownerNodeGeneration),
-            sessionIdentity: String(sessionIdentity),
-            bindingGeneration: BigInt(actorRef.bindingGeneration ?? -1)
-        };
     }
     async observeRelocationTerminal(actorId, sealId, applyFingerprint) {
         await this.lane.run(() => this.observeRelocationTerminalCore(actorId, sealId, applyFingerprint));
@@ -971,42 +894,6 @@ class ZLinkActorSessionBindingRegistry {
         this.settleOutbound(queue, entry);
         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) {
-            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) {
-            return new Error(`Actor '${claim.actorId}' Session outbound admission was fenced by its current binding.`);
-        }
-        return undefined;
-    }
-    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));
-    }
     rememberTerminalRelocation(state) {
         this.terminalRelocations.delete(state);
         this.terminalRelocations.set(state, true);
@@ -1061,45 +948,6 @@ function assertRelocationClaim(state, claim) {
 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);
-}
-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);
-}
-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);
-}
-function relocationSourceProof(state) {
-    if (state.sessionIdentity === undefined ||
-        state.actorNodeRid === undefined ||
-        state.actorNodeGeneration === undefined)
-        return undefined;
-    return {
-        actorId: state.actorId,
-        objectGeneration: state.actorGeneration,
-        actorNodeRid: state.actorNodeRid,
-        actorNodeGeneration: state.actorNodeGeneration,
-        sessionIdentity: state.sessionIdentity,
-        bindingGeneration: state.bindingGeneration
-    };
-}
 function failRetainedOutbound(operation, error) {
     try {
         operation.fail(error);

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

@@ -1,14 +1,13 @@
 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';
+import type { ServiceSessionBindingAdmissionResult } from '../foundation/service-session-binding-ingress-port';
+import type { ZLinkActorSessionAuthorityFence, 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>;
-    admitRelocationOutbound(claim: ServiceSessionBindingAdmissionClaim, operation: ZLinkActorSessionRetainedOutbound): Promise<ServiceSessionBindingAdmissionResult>;
     discardRelocationOutbound(actorId: string, sealId: string, error: unknown): Promise<void>;
-    applyRelocation(actorId: string, sealId: string, applyFingerprint: string, action: 'commit' | 'abort', commitOwnerTransition: () => Promise<void>, acceptedProducerProof?: ZLinkActorSessionAcceptedProducerProof): Promise<void>;
+    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>;
     committedRoute(actorId: string): Promise<{

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

@@ -157,7 +157,7 @@ class ZLinkBoundSessionService {
     async submitNativeBoundSessionFrame(node, actorRef, frame, signal) {
         const backendActorRef = toBoundSessionSendActorRef(actorRef);
         (0, abort_1.throwIfAborted)(signal);
-        return await node.sendActorBoundSession(backendActorRef, requireBoundSessionGeneration(actorRef), [frame], ZLINK_SEND_DONT_WAIT, boundSessionSendFence(node, backendActorRef, actorRef));
+        return await node.sendActorBoundSession(backendActorRef, requireBoundSessionGeneration(actorRef), [frame], ZLINK_SEND_DONT_WAIT);
     }
     requireTransport() {
         if (this.options.transport === undefined) {
@@ -184,20 +184,3 @@ function toBoundSessionSendActorRef(actor) {
         generation: actor.objectGeneration
     };
 }
-function boundSessionSendFence(node, backendActor, actor) {
-    const internal = actor;
-    const ownerNodeGeneration = internal.ownerNodeGeneration ?? node.actorNodeGeneration?.(backendActor);
-    if (internal.ownershipGeneration === undefined ||
-        internal.ownershipGeneration <= 0n ||
-        internal.ownerLeaseGeneration === undefined ||
-        internal.ownerLeaseGeneration <= 0n ||
-        ownerNodeGeneration === undefined ||
-        ownerNodeGeneration <= 0n) {
-        return undefined;
-    }
-    return Object.freeze({
-        targetNodeGeneration: ownerNodeGeneration,
-        authorityOwnerGeneration: internal.ownershipGeneration,
-        ownerLeaseGeneration: internal.ownerLeaseGeneration
-    });
-}

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

@@ -1,3 +1,4 @@
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { ActorRef, ZLinkActor, ZLinkBoundSession, ZLinkSessionActor, ZLinkMessageSerializer, ZLinkStreamCompressionOptions } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
@@ -68,6 +69,7 @@ export interface ZLinkStreamSessionNodeRuntimeOptions extends Omit<ZLinkStreamSe
     readonly bindingRuntime?: ZLinkStreamBindingRuntime;
 }
 export interface ZLinkStreamRuntimeManagerOptions {
+    readonly listenerRecords?: ZLinkListenerRecords;
     readonly registration: ZLinkFrameworkRegistration;
     readonly backendAdapterFactory: ZLinkBackendAdapterFactory;
     readonly context: ZLinkBackendContext;

package/dist/runtime/streams/index.js

@@ -56,6 +56,12 @@ class ZLinkStreamRuntimeManager {
             const nativeMeshNode = actorDispatchEnabled ? this.options.nativeMeshNode : undefined;
             const meshCompletions = actorDispatchEnabled ? this.options.meshCompletions : undefined;
             const socket = streamAdapter.createStreamSocket(this.options.context);
+            const node = {
+                meshName: applicationMeshName,
+                socket,
+                nativeSessionServices: []
+            };
+            this.nodes.set(nodeName, node);
             // Core uses -1 as the explicit unlimited value. The Framework value 0
             // means that it adds no separate STREAM cap, so preserve that meaning
             // when applying the socket option.
@@ -71,7 +77,6 @@ class ZLinkStreamRuntimeManager {
             if (advertisedEndpoint === undefined) {
                 throw new configuration_1.ZLinkConfigurationException(`STREAM node '${nodeName}' advertised host requires a TCP endpoint, received '${boundEndpoint}'.`);
             }
-            const readablePoller = streamAdapter.createReadablePoller(socket);
             const nativeSessionRoutes = new Map();
             if (actorDispatchEnabled) {
                 for (const [meshName, mesh] of this.options.registration.spotNodes) {
@@ -86,10 +91,11 @@ class ZLinkStreamRuntimeManager {
                     if (typeof createService !== 'function' || completions === undefined)
                         continue;
                     const service = createService.call(meshNode, socket.nativeInstance);
+                    node.nativeSessionServices.push(service);
                     const bindingOwner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.bindingRuntime);
                     (0, service_session_binding_ingress_port_1.registerServiceSessionBindingIngressPort)(service, {
                         actorSlot: (actorId, sessionRid) => bindingOwner.actorSlot(actorId, sessionRid),
-                        retainOutbound: (claim, delivery) => bindingOwner.admitRelocationOutbound(claim, delivery),
+                        retainOutbound: (actorId, delivery) => bindingOwner.retainRelocationOutbound(actorId, delivery),
                         clearOutbound: (actorId, error) => bindingOwner.clearRelocation(actorId, error)
                     });
                     nativeSessionRoutes.set(meshName, {
@@ -102,8 +108,12 @@ class ZLinkStreamRuntimeManager {
                 ? undefined
                 : nativeSessionRoutes.get(applicationMeshName)?.service;
             const monitor = monitoringAdapter.openSocketMonitor(socket);
+            node.monitor = monitor;
             const sessionType = streamNode.session;
             const sessionHandlerTypes = streamNode[Symbol.for('@zlink-systems/framework:session-handler-types')] ?? [];
+            // The runtime disposes the poller, so the poller is created where nothing
+            // can fail before the runtime owns it.
+            const readablePoller = streamAdapter.createReadablePoller(socket);
             const runtime = new stream_session_runtime_1.ZLinkStreamSessionNodeRuntime({
                 nodeName,
                 socket,
@@ -123,42 +133,33 @@ class ZLinkStreamRuntimeManager {
                 replacementCallbackTimeoutMs: this.options.registration.sessionReplacementCallbackTimeoutMs,
                 sessionFactory: (context) => (0, session_provider_1.createStreamSessionInstance)(sessionType, this.options.providerResolver, context, sessionHandlerTypes)
             });
+            node.runtime = runtime;
             runtime.start();
-            this.nodes.set(nodeName, {
-                meshName: applicationMeshName,
-                advertisedEndpoint,
-                runtime,
-                socket,
-                monitor,
-                nativeSessionService,
-                nativeSessionServices: [...nativeSessionRoutes.values()].map((route) => route.service)
-            });
+            this.options.listenerRecords?.record('stream', nodeName, advertisedEndpoint);
         }
     }
     async dispose() {
         const nodes = [...this.nodes.values()];
         this.nodes.clear();
         for (const node of nodes.reverse()) {
-            await node.runtime.dispose();
-            const nativeServices = node.nativeSessionServices ??
-                (node.nativeSessionService === undefined ? [] : [node.nativeSessionService]);
-            for (const service of nativeServices) {
+            await node.runtime?.dispose();
+            for (const service of node.nativeSessionServices) {
                 service.shutdown(1000);
                 service.close();
             }
-            await node.monitor.dispose();
+            await node.monitor?.dispose();
             await node.socket.dispose();
         }
     }
     async notifyServerDrain(meshName) {
         await Promise.all([...this.nodes.values()]
             .filter((node) => node.meshName === meshName)
-            .map((node) => node.runtime.drainCloseSessions()));
+            .map((node) => node.runtime?.drainCloseSessions()));
     }
     async notifyUnscopedServerDrain() {
         await Promise.all([...this.nodes.values()]
             .filter((node) => node.meshName === undefined)
-            .map((node) => node.runtime.drainCloseSessions()));
+            .map((node) => node.runtime?.drainCloseSessions()));
     }
 }
 exports.ZLinkStreamRuntimeManager = ZLinkStreamRuntimeManager;
@@ -224,7 +225,6 @@ class ZLinkStreamBindingRuntime {
             sealRelocation: (claim, expected, signal) => this.routes.sealRelocation(claim, expected, signal),
             relocationSnapshot: (actorId, sealId) => this.routes.relocationSnapshot(actorId, sealId),
             retainRelocationOutbound: (actorId, operation, sealId) => this.routes.retainRelocationOutbound(actorId, operation, sealId),
-            admitRelocationOutbound: (claim, operation) => this.routes.admitRelocationOutbound(claim, operation),
             discardRelocationOutbound: (actorId, sealId, error) => this.routes.discardRelocationOutbound(actorId, sealId, error),
             applyRelocation: (...args) => this.routes.applyRelocation(...args),
             observeRelocationTerminal: (...args) => this.routes.observeRelocationTerminal(...args),

package/dist/runtime/streams/session-serial-executor.js

@@ -22,8 +22,8 @@ class ZLinkSessionSerialExecutor {
         }
         const boundWork = (0, application_job_queue_scope_1.bindApplicationJobPermit)(work);
         return (0, application_job_queue_scope_1.hasApplicationJobPermit)()
-            ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'lifecycle' })
-            : this.scheduler.submit(boundWork, { lane: 'lifecycle' });
+            ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'application' })
+            : this.scheduler.submit(boundWork, { lane: 'application' });
     }
     submit(work, lane, options = {}, onRejected) {
         if (this.closed)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.24.0",
-    "@zlink-systems/zlink": "1.6.0"
+    "@zlink-systems/stream-wire": "0.26.0",
+    "@zlink-systems/zlink": "1.10.0"
   }
 }

package/src/contracts/Channels/IZLinkFanoutClient.ts

@@ -1,13 +1,6 @@
 import type { ZLinkFanoutPublishCall } from './Calls';
 
-export interface ZLinkFanoutListenerStatus {
-  readonly channelName: string;
-  readonly endpoint: string;
-  readonly observedAt: Date;
-}
-
 export interface ZLinkFanoutClient {
   publish(channelName: string, event: unknown): ZLinkFanoutPublishCall;
   publish(channelName: string, topic: string, event: unknown): ZLinkFanoutPublishCall;
-  getListenerStatus(channelName: string): ZLinkFanoutListenerStatus;
 }

package/src/contracts/RouteMesh/RuntimeTopology.ts

@@ -142,12 +142,22 @@ export interface ZLinkHostCapacityStatus {
 
 export interface ZLinkFrameworkRuntime {
   readonly status: ZLinkFrameworkRuntimeStatus;
+  getListenerStatus(kind: ZLinkListenerKind, name: string): ZLinkListenerStatus;
   observe(signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkFrameworkRuntimeStatus>>;
   resetCapacityMetrics(): void;
   relocate(options: ZLinkFrameworkRelocationOptions): Promise<ZLinkFrameworkRelocationResult>;
   shutdown(options?: ZLinkFrameworkLifecycleOptions): Promise<ZLinkFrameworkTerminationResult>;
 }
 
+export type ZLinkListenerKind = 'routeMesh' | 'clientServer' | 'fanout' | 'stream';
+
+export interface ZLinkListenerStatus {
+  readonly kind: ZLinkListenerKind;
+  readonly name: string;
+  readonly endpoint: string;
+  readonly observedAt: Date;
+}
+
 export type ZLinkClientServerRole = 'client' | 'server' | 'clientAndServer';
 
 export interface ZLinkClientServerTargetStatus {

package/src/internal.ts

@@ -3,6 +3,7 @@ export * from './index';
 export * from './runtime/diagnostics';
 export * from './runtime/host';
 export * from './runtime/admission';
+export * from './runtime/activation-admission';
 export * from './runtime/streams';
 export * from './runtime/streams/protocol';
 export * from './runtime/actors';

package/src/runtime/activation-admission.ts

@@ -0,0 +1,78 @@
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from './framework-errors-internal';
+
+/** Current activation admission count and limit of one MeshNode. */
+export interface ZLinkActivationConcurrency {
+  readonly active: number;
+  readonly limit: number;
+}
+
+interface ZLinkActivationRecord {
+  readonly meshName: string;
+  readonly limit: number;
+  active: number;
+}
+
+/**
+ * MeshNode §5.1 "Pending activation": the single per-MeshNode record of activation admissions.
+ *
+ * Actor creation, User Spot creation, Instance Spot cold activation and a relocation target's
+ * Restore each hold one admission from the moment the target MeshNode receives the operation
+ * until Ready or its target commit, or until it ends by rejection, failure or cleanup. Entry Spot
+ * and Actor Join never acquire one. The limit is enforced here, and the status current value and
+ * the placement `IsAvailable` headroom both read this record.
+ */
+export class ZLinkActivationAdmission {
+  private readonly records = new Map<string, ZLinkActivationRecord>();
+
+  constructor(
+    private readonly limitOf: (meshName: string) => number,
+    private readonly changed?: (meshName: string) => void
+  ) {}
+
+  current(meshName: string): ZLinkActivationConcurrency {
+    const record = this.records.get(meshName);
+    return { active: record?.active ?? 0, limit: record?.limit ?? this.limitOf(meshName) };
+  }
+
+  hasHeadroom(meshName: string): boolean {
+    const { active, limit } = this.current(meshName);
+    return active < limit;
+  }
+
+  /**
+   * Holds one admission for `meshName`. A MeshNode without headroom does not accept a new
+   * admission (MeshNode §5.1): the operation fails as Unavailable at once. The returned release
+   * is idempotent.
+   */
+  async acquire(meshName: string, signal?: AbortSignal): Promise<() => void> {
+    signal?.throwIfAborted();
+    const record = this.record(meshName);
+    if (record.active >= record.limit) {
+      throw createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted,
+        `MeshNode '${meshName}' has no activation admission headroom.`
+      );
+    }
+    record.active += 1;
+    this.changed?.(meshName);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      record.active -= 1;
+      this.changed?.(meshName);
+    };
+  }
+
+  private record(meshName: string): ZLinkActivationRecord {
+    let record = this.records.get(meshName);
+    if (record === undefined) {
+      record = { meshName, limit: this.limitOf(meshName), active: 0 };
+      this.records.set(meshName, record);
+    }
+    return record;
+  }
+}