@zlink-systems/framework 0.26.0 → 0.27.0

package/dist/runtime/handlers/handler-instance-scope.d.ts

@@ -1,5 +1,6 @@
 import type { Type, ZLinkMessageContext } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import type { ZLinkDetachedTaskRunner } from '../spots/spot-actor-join-dispatch';
 export interface ZLinkHandlerInstanceScope {
     resolve<T>(type: Type<T>): Promise<T>;
     dispose(): Promise<void>;
@@ -7,5 +8,6 @@ export interface ZLinkHandlerInstanceScope {
 export declare function runInHandlerInstanceScope<T>(providerResolver: ZLinkProviderResolver | undefined, context: ZLinkMessageContext | undefined, callback: (scope: ZLinkHandlerInstanceScope) => Promise<T>): Promise<T>;
 export declare function resolveLifecycleHandler<T>(owner: object, type: Type<T>, providerResolver?: ZLinkProviderResolver): Promise<T>;
 export declare function runWithLifecycleHandler<THandler, TResult>(owner: object, type: Type<THandler>, providerResolver: ZLinkProviderResolver | undefined, callback: (handler: THandler) => Promise<TResult>): Promise<TResult>;
-export declare function disposeLifecycleHandlers(owner: object): Promise<void>;
+export declare function disposeLifecycleHandlers(owner: object, detachedTaskRunner: ZLinkDetachedTaskRunner): Promise<void>;
 export declare function disposeOwnedInstance(instance: unknown): Promise<void>;
+export declare function disposeOwnedInstances(instances: readonly unknown[]): Promise<void>;

package/dist/runtime/handlers/handler-instance-scope.js

@@ -5,12 +5,12 @@ exports.resolveLifecycleHandler = resolveLifecycleHandler;
 exports.runWithLifecycleHandler = runWithLifecycleHandler;
 exports.disposeLifecycleHandlers = disposeLifecycleHandlers;
 exports.disposeOwnedInstance = disposeOwnedInstance;
+exports.disposeOwnedInstances = disposeOwnedInstances;
 const node_async_hooks_1 = require("node:async_hooks");
-const state_lane_1 = require("../execution/state-lane");
 const HANDLER_SCOPE_FACTORY = Symbol.for('@zlink-systems/framework.handler-instance-scope-factory');
 const activeHandlerScope = new node_async_hooks_1.AsyncLocalStorage();
 const activeLifecycleScope = new node_async_hooks_1.AsyncLocalStorage();
-const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:handler-instance-scope');
+const detachedLifecycleResource = new node_async_hooks_1.AsyncResource('zlink:handler-instance-scope');
 const dispatchScopes = new WeakMap();
 const lifecycleScopes = new WeakMap();
 async function runInHandlerInstanceScope(providerResolver, context, callback) {
@@ -39,27 +39,27 @@ async function runInHandlerInstanceScope(providerResolver, context, callback) {
     }
 }
 async function resolveLifecycleHandler(owner, type, providerResolver) {
-    let scope = lifecycleScopes.get(owner);
-    if (scope === undefined) {
-        scope = Promise.resolve(new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver)));
-        lifecycleScopes.set(owner, scope);
-    }
-    return (await scope).resolve(type);
+    return lifecycleHandlerScope(owner, providerResolver).resolve(type);
 }
 async function runWithLifecycleHandler(owner, type, providerResolver, callback) {
+    return lifecycleHandlerScope(owner, providerResolver).run(type, callback);
+}
+function lifecycleHandlerScope(owner, providerResolver) {
     let scope = lifecycleScopes.get(owner);
     if (scope === undefined) {
-        scope = Promise.resolve(new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver)));
+        scope = new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver));
         lifecycleScopes.set(owner, scope);
     }
-    return (await scope).run(type, callback);
+    return scope;
 }
-async function disposeLifecycleHandlers(owner) {
+async function disposeLifecycleHandlers(owner, detachedTaskRunner) {
+    if (detachedTaskRunner === undefined) {
+        throw new Error('Lifecycle handler disposal requires a detached task runner.');
+    }
     const scope = lifecycleScopes.get(owner);
     if (scope === undefined)
         return;
-    const resolved = await scope;
-    await resolved.dispose();
+    await scope.dispose(detachedTaskRunner);
     // Keep the closed scope as a tombstone for the lifetime of the owner object.
     // A late dispatch must fail instead of creating a second activation.
 }
@@ -79,68 +79,49 @@ function isHandlerInstanceScopeFactory(value) {
 }
 class DefaultHandlerInstanceScope {
     providerResolver;
-    lane = new state_lane_1.ZLinkStateLane();
     instances = new Map();
     owned = [];
     disposed = false;
     constructor(providerResolver) {
         this.providerResolver = providerResolver;
     }
-    async resolve(type) {
-        const resolution = await this.lane.run(() => this.resolveCore(type));
-        if (resolution.activation !== undefined) {
-            startOutsideStateLane(() => {
-                void this.activate(type, resolution.activation);
-            });
-        }
-        return await resolution.promise;
-    }
-    async dispose() {
-        const disposal = await this.lane.run(() => this.beginDisposeCore());
-        if (disposal === undefined)
-            return;
-        await Promise.allSettled(disposal.pending);
-        for (const instance of disposal.owned) {
-            await disposeOwnedInstance(instance);
-        }
-        await this.lane.run(() => this.completeDisposeCore());
-    }
-    resolveCore(type) {
+    resolve(type) {
         if (this.disposed) {
-            throw new Error('Handler instance scope is already disposed.');
+            return Promise.reject(new Error('Handler instance scope is already disposed.'));
         }
-        let instance = this.instances.get(type);
-        if (instance !== undefined)
-            return { promise: instance };
+        const existing = this.instances.get(type);
+        if (existing !== undefined)
+            return existing;
         const activation = createDeferred();
-        instance = activation.promise;
         this.instances.set(type, activation.promise);
-        return { promise: instance, activation };
+        void this.activate(type, activation);
+        return activation.promise;
     }
-    beginDisposeCore() {
+    async dispose() {
         if (this.disposed)
-            return undefined;
+            return;
         this.disposed = true;
-        return {
-            pending: [...this.instances.values()],
-            owned: [...this.owned].reverse()
-        };
-    }
-    completeDisposeCore() {
-        this.owned.length = 0;
-        this.instances.clear();
+        await Promise.allSettled(this.instances.values());
+        try {
+            await disposeOwnedInstances(this.owned);
+        }
+        finally {
+            this.owned.length = 0;
+            this.instances.clear();
+        }
     }
     async activate(type, activation) {
         let instance;
         try {
-            instance = (await this.providerResolver?.create?.(type)) ?? new type();
+            const created = this.providerResolver?.create?.(type);
+            instance = created === undefined ? new type() : await created;
         }
         catch (error) {
             activation.reject(error);
             return;
         }
-        const accepted = await this.lane.run(() => this.acceptActivationCore(instance));
-        if (accepted) {
+        if (!this.disposed) {
+            this.owned.push(instance);
             activation.resolve(instance);
             return;
         }
@@ -152,16 +133,9 @@ class DefaultHandlerInstanceScope {
             activation.reject(error);
         }
     }
-    acceptActivationCore(instance) {
-        if (this.disposed)
-            return false;
-        this.owned.push(instance);
-        return true;
-    }
 }
 class LifecycleHandlerInstanceScope {
     instances;
-    lane = new state_lane_1.ZLinkStateLane();
     activeInvocations = 0;
     closing = false;
     idle;
@@ -170,36 +144,34 @@ class LifecycleHandlerInstanceScope {
     constructor(instances) {
         this.instances = instances;
     }
-    async resolve(type) {
-        const resolution = await this.lane.run(() => ({ promise: this.resolveCore(type) }));
-        return await resolution.promise;
-    }
-    resolveCore(type) {
+    resolve(type) {
         this.throwIfClosingCore();
         return this.instances.resolve(type);
     }
     async run(type, callback) {
-        await this.lane.run(() => this.beginInvocationCore());
+        this.beginInvocationCore();
         try {
             return await activeLifecycleScope.run(this, async () => callback(await this.instances.resolve(type)));
         }
         finally {
-            await this.lane.run(() => this.completeInvocationCore());
+            this.completeInvocationCore();
         }
     }
-    async dispose() {
+    async dispose(detachedTaskRunner) {
         const disposeFromActiveInvocation = activeLifecycleScope.getStore() === this;
-        const disposal = await this.lane.run(() => this.beginDisposeCore());
+        const disposal = this.beginDisposeCore();
         if (disposal.deferred !== undefined) {
-            startOutsideStateLane(() => {
+            startOutsideLifecycleInvocation(() => {
                 void this.disposeWhenIdle(disposal);
+                if (disposeFromActiveInvocation) {
+                    detachedTaskRunner.runDetached(LifecycleHandlerInstanceScope.name, () => disposal.completion);
+                }
             });
         }
         if (disposeFromActiveInvocation) {
             // Waiting here would make the current handler wait for its own terminal
             // completion. The same disposal promise continues after run() releases
             // the final active invocation.
-            void disposal.completion.catch(() => undefined);
             return;
         }
         await disposal.completion;
@@ -245,7 +217,7 @@ class LifecycleHandlerInstanceScope {
             deferred.resolve();
         }
         catch (error) {
-            await this.lane.run(() => this.failDisposalCore(deferred.promise));
+            this.failDisposalCore(deferred.promise);
             deferred.reject(error);
         }
     }
@@ -264,8 +236,8 @@ function createDeferred() {
     });
     return { promise, resolve, reject };
 }
-function startOutsideStateLane(work) {
-    return detachedStateLaneResource.runInAsyncScope(work);
+function startOutsideLifecycleInvocation(work) {
+    return detachedLifecycleResource.runInAsyncScope(work);
 }
 async function disposeOwnedInstance(instance) {
     if (instance === null || instance === undefined)
@@ -281,3 +253,18 @@ async function disposeOwnedInstance(instance) {
         await value.onModuleDestroy();
     }
 }
+async function disposeOwnedInstances(instances) {
+    const failures = [];
+    for (let index = instances.length - 1; index >= 0; index -= 1) {
+        try {
+            await disposeOwnedInstance(instances[index]);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length > 1)
+        throw new AggregateError(failures, 'Handler scope cleanup failed.');
+}

package/dist/runtime/host/actor-packet-relay.d.ts

@@ -5,7 +5,7 @@ import { type ZLinkActorRoutedJoinTransport, type ZLinkRemoteActorPacketTarget,
 import type { DefaultZLinkActorManager } from '../actors';
 import type { DefaultZLinkSpotManager, ZLinkSpotNodeRuntimeManager } from '../spots';
 import type { ZLinkDetachedTaskRunner } from '../spots/spot-actor-join-dispatch';
-import type { ZLinkBoundSessionResponsePort, ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
+import type { ZLinkBoundSessionResponsePort, ZLinkSessionBindingConfirmationOptions, ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
 import { type ZLinkStreamFrameHeader } from '../streams/protocol';
 import type { MeshRouterResolver } from './mesh-router-resolver';
 import type { ZLinkStoreLocationResolvers } from '../locations';
@@ -32,7 +32,7 @@ export declare class ZLinkActorPacketRelay {
     notifyBoundActorDisconnected(actor: ZLinkSessionActor, signal?: AbortSignal): Promise<void>;
     clearRemoteActorPacketTarget(actorId: string): void;
     updateRemoteActorPacketTarget(actorId: string, value: unknown): Promise<void>;
-    actorPacketTargetForState(actorId: string, routerChannelIdHint?: string): ZLinkRemoteActorPacketTarget | undefined;
+    actorPacketTargetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined;
     notifyActorDisconnectedById(actorId: string, signal?: AbortSignal): Promise<void>;
     notifyLocalActorDisconnectedById(actorId: string, signal?: AbortSignal): Promise<void>;
     receiveRemoteActorPacketRelay(payload: unknown, _routeContext: ZLinkRouteMessageContext): Promise<{
@@ -44,10 +44,13 @@ export declare class ZLinkActorPacketRelay {
         readonly actorPacketTarget?: unknown;
     }>;
     relayActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message, signal?: AbortSignal): Promise<boolean>;
-    confirmRemoteSessionBinding(actor: ActorRef, sessionNodeRid: RoutingId, sessionRid: RoutingId, signal?: AbortSignal, options?: {
-        readonly waitForAcknowledgement?: boolean;
-    }): Promise<void>;
-    private retryRemoteSessionBindingSend;
+    confirmRemoteSessionBinding(actor: ActorRef, sessionNodeRid: RoutingId, sessionRid: RoutingId, signal?: AbortSignal, options?: ZLinkSessionBindingConfirmationOptions): Promise<void>;
+    /**
+     * Session–Actor binding §5·§6 (.NET ZLinkSessionActorCoordinator rule): a
+     * same-node bind installs the Session owner's registry identity through the
+     * same install a remote command 38 uses, so relocation seals and carries it.
+     */
+    private installSameNodeSessionBinding;
     relayRemoteActorPacket(actor: ZLinkSessionActor, frameHeader: ZLinkStreamFrameHeader, payload: Message, signal?: AbortSignal): Promise<boolean>;
     notifyRemoteActorDisconnected(actorId: string, remoteTarget: ZLinkRemoteBoundSessionTarget | ZLinkRemoteActorPacketTarget, signal?: AbortSignal, bindingActorRef?: ActorRef): Promise<void>;
     private requireCurrentRemoteBinding;

package/dist/runtime/host/actor-packet-relay.js

@@ -6,7 +6,6 @@ const runtime_message_1 = require("../backend/runtime-message");
 const contracts_1 = require("../../contracts");
 const ConfigurationException_1 = require("../../contracts/Configuration/ConfigurationException");
 const actors_1 = require("../actors");
-const actor_runtime_state_1 = require("../actors/actor-runtime-state");
 const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const actor_routed_json_request_1 = require("../actors/actor-routed-json-request");
 const actor_message_follow_context_1 = require("../actors/actor-message-follow-context");
@@ -16,9 +15,6 @@ const submission_result_1 = require("../messaging/submission-result");
 const actor_session_binding_runtime_owner_1 = require("../streams/actor-session-binding-runtime-owner");
 const protocol_1 = require("../streams/protocol");
 const remote_actor_packet_target_store_1 = require("./remote-actor-packet-target-store");
-const REMOTE_SESSION_BIND_RETRY_DEADLINE_MS = 30_000;
-const REMOTE_SESSION_BIND_RETRY_INITIAL_DELAY_MS = 25;
-const REMOTE_SESSION_BIND_RETRY_MAX_DELAY_MS = 1_000;
 class ZLinkActorPacketRelay {
     options;
     targets;
@@ -38,9 +34,7 @@ class ZLinkActorPacketRelay {
     }
     async notifyBoundActorDisconnected(actor, signal) {
         const state = this.options.actorManager()?.getState(actor.actorId);
-        const currentRemoteBoundSessionTarget = state?.spotId === undefined
-            ? undefined
-            : (0, actor_runtime_state_1.preferredRemoteBoundSessionTarget)(state.remoteBoundSessionTarget, state.boundSessionTransferTarget);
+        const currentRemoteBoundSessionTarget = state?.spotId === undefined ? undefined : state.remoteBoundSessionTarget;
         const currentRemoteActorPacketTarget = state?.spotId === undefined ? undefined : state.remoteActorPacketTarget;
         const remoteTarget = currentRemoteBoundSessionTarget ??
             currentRemoteActorPacketTarget ??
@@ -68,14 +62,14 @@ class ZLinkActorPacketRelay {
     async updateRemoteActorPacketTarget(actorId, value) {
         await this.targets.updateFromWire(actorId, value);
     }
-    actorPacketTargetForState(actorId, routerChannelIdHint) {
-        return this.targets.targetForState(actorId, routerChannelIdHint);
+    actorPacketTargetForState(actorId) {
+        return this.targets.targetForState(actorId);
     }
     async notifyActorDisconnectedById(actorId, signal) {
         const state = this.options.actorManager()?.getState(actorId);
         const remoteTarget = state === undefined
             ? undefined
-            : ((0, actor_runtime_state_1.preferredRemoteBoundSessionTarget)(state.remoteBoundSessionTarget, state.boundSessionTransferTarget) ?? state.remoteActorPacketTarget);
+            : (state.remoteBoundSessionTarget ?? state.remoteActorPacketTarget);
         if (remoteTarget !== undefined) {
             await this.notifyRemoteActorDisconnected(actorId, remoteTarget, signal);
             return;
@@ -152,48 +146,25 @@ class ZLinkActorPacketRelay {
                 if (frameHeader.kind !== protocol_1.ZLinkStreamMessageKind.Send) {
                     throw new Error('Remote actor session binding requires a send frame.');
                 }
-                const { sessionNodeRid, sessionRid } = (0, actor_packet_relay_wire_1.decodeRemoteActorSessionBinding)((0, protocol_1.messageToBytes)(body));
+                const { sessionNodeRid } = (0, actor_packet_relay_wire_1.decodeRemoteActorSessionBinding)((0, protocol_1.messageToBytes)(body));
                 if (!(0, routing_id_1.routingIdsEqual)(sessionNodeRid, _routeContext.sourceNodeRid)) {
                     throw new Error('Remote actor session binding source did not match the declared session node.');
                 }
+                // The Actor owner installs the binding from the Session owner's
+                // command 38 (Session–Actor binding §5); this relay confirmation only
+                // acknowledges that the Actor is still owned here.
                 const state = this.options.actorManager()?.getState(relay.actorId);
-                const actorRef = state?.nativeActorRef;
-                if (state === undefined || actorRef === undefined) {
+                if (state?.nativeActorRef === undefined) {
                     throw new Error(`Actor '${relay.actorId}' does not have a concrete actor ref.`);
                 }
-                if (this.requireSpotNodeRuntime().primaryMeshNode === undefined) {
-                    throw new Error('MeshNode actor runtime is not started.');
-                }
-                const target = relay.routerChannelId === undefined
-                    ? this.options.meshRouters.remoteBoundSessionTargetForSource(sessionNodeRid)
-                    : {
-                        routerChannelId: relay.routerChannelId,
-                        targetNodeRid: sessionNodeRid,
-                        spotId: sessionNodeRid
-                    };
-                if (target === undefined) {
-                    throw new Error('Remote actor session binding did not declare a return router.');
-                }
-                const bindingGeneration = fallbackActorRef?.bindingGeneration;
-                const refreshedTarget = (0, actor_runtime_state_1.mergeRemoteBoundSessionTarget)({
-                    ...target,
-                    sessionNodeRid,
-                    sessionRid,
-                    ...(bindingGeneration === undefined ? {} : { bindingGeneration })
-                }, (0, actor_runtime_state_1.preferredRemoteBoundSessionTarget)(state.remoteBoundSessionTarget, state.boundSessionTransferTarget));
-                state.setRemoteBoundSessionTarget(refreshedTarget);
                 return { ok: true, response: { acknowledged: true } };
             }
             if (frameHeader.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
                 this.requireCurrentRemoteBinding(relay, _routeContext);
-                this.options
-                    .actorManager()
-                    ?.getState(relay.actorId)
-                    ?.setRemoteBoundSessionTarget(undefined);
                 await this.notifyLocalActorDisconnectedById(relay.actorId);
                 return {
                     ok: true,
-                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId, relay.routerChannelId))
+                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
                 };
             }
             if (remoteBoundSessionTarget !== undefined) {
@@ -229,7 +200,7 @@ class ZLinkActorPacketRelay {
                 });
                 return {
                     ok: true,
-                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId, relay.routerChannelId))
+                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
                 };
             }
             if (frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Request &&
@@ -274,7 +245,7 @@ class ZLinkActorPacketRelay {
                 return {
                     ok: true,
                     deferredResponse: true,
-                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId, relay.routerChannelId))
+                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
                 };
             }
             const response = state?.spotId === undefined
@@ -283,7 +254,7 @@ class ZLinkActorPacketRelay {
             return {
                 ok: true,
                 response,
-                actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId, relay.routerChannelId))
+                actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
             };
         }
         catch (error) {
@@ -303,36 +274,17 @@ class ZLinkActorPacketRelay {
         }
     }
     async relayActorPacket(actor, frameHeader, payload, signal) {
-        //  Spec 32:87 — a route/owner that is not currently usable is
-        //  Unavailable and retryable within the request deadline. Right after a
-        //  relocation the cached packet target can carry a transiently
-        //  incomplete Ready authority fence (route publication still
-        //  converging); failing the request on the fence check would surface a
-        //  NotFound for a Spot that exists and is Ready on its owner. Clear the
-        //  stale hint and re-resolve with a short bound instead.
-        const fenceRetryDeadlineMs = performance.now() + 1_000;
-        for (;;) {
-            try {
-                if (await this.relayRemoteActorPacket(actor, frameHeader, payload, signal)) {
-                    return true;
-                }
-                return await this.relayLocalActorPacket(actor, frameHeader, payload, signal);
-            }
-            catch (error) {
-                if (!(error instanceof Error && error.message.includes('no complete Ready authority fence')) ||
-                    performance.now() >= fenceRetryDeadlineMs) {
-                    throw error;
-                }
-                this.targets.clear(actor.actorId);
-                this.options.actorManager()?.getState(actor.actorId)?.setRemoteActorPacketTarget(undefined);
-                await new Promise((resolve) => setTimeout(resolve, 25));
-            }
+        if (await this.relayRemoteActorPacket(actor, frameHeader, payload, signal)) {
+            return true;
         }
+        return this.relayLocalActorPacket(actor, frameHeader, payload, signal);
     }
     async confirmRemoteSessionBinding(actor, sessionNodeRid, sessionRid, signal, options) {
         const target = this.targets.targetForActorRef(actor);
-        if (target === undefined)
+        if (target === undefined) {
+            this.installSameNodeSessionBinding(actor.actorId, options?.binding);
             return;
+        }
         const header = (0, protocol_1.encodeStreamHeader)({
             kind: protocol_1.ZLinkStreamMessageKind.Send,
             codec: protocol_1.ZLinkStreamCodec.Json,
@@ -350,7 +302,9 @@ class ZLinkActorPacketRelay {
             payload: (0, actor_packet_relay_wire_1.encodeRemoteActorSessionBinding)({ sessionNodeRid, sessionRid })
         });
         if (options?.waitForAcknowledgement === false) {
-            await this.retryRemoteSessionBindingSend(withDefaultSpotKind(target), request, performance.now() + REMOTE_SESSION_BIND_RETRY_DEADLINE_MS, REMOTE_SESSION_BIND_RETRY_INITIAL_DELAY_MS);
+            await this.options.routeTransport.sendToSpot(withDefaultSpotKind(target), request, {
+                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
+            });
             return;
         }
         const reply = await this.requestRemoteTarget(withDefaultSpotKind(target), request, `Remote actor session binding is not available for '${actor.actorId}'.`, (parts) => JSON.parse(parts[0]?.getString('utf8') ?? '{}'), signal);
@@ -369,26 +323,31 @@ class ZLinkActorPacketRelay {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(remoteKind, `Actor '${actor.actorId}' did not acknowledge its remote session binding: ${JSON.stringify(reply)}`, reply.error);
         }
     }
-    async retryRemoteSessionBindingSend(target, request, deadline, delayMs) {
-        try {
-            await this.options.routeTransport.sendToSpot(target, request, {
-                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
-            });
-        }
-        catch (error) {
-            if (performance.now() >= deadline) {
-                //  Spec 32-framework-error-model: DeadlineExceeded(7). Retry
-                //  exhaustion on the one-way bind send remains diagnostics-only but
-                //  the caller waits for its bounded submission terminal so later
-                //  application relay cannot overtake it.
-                this.options
-                    .errorSink()
-                    .reportRuntimeTaskException('remote session binding send', (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, 'Remote actor session binding send retries exceeded their deadline.', error));
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-            await this.retryRemoteSessionBindingSend(target, request, deadline, Math.min(delayMs * 2, REMOTE_SESSION_BIND_RETRY_MAX_DELAY_MS));
-        }
+    /**
+     * Session–Actor binding §5·§6 (.NET ZLinkSessionActorCoordinator rule): a
+     * same-node bind installs the Session owner's registry identity through the
+     * same install a remote command 38 uses, so relocation seals and carries it.
+     */
+    installSameNodeSessionBinding(actorId, binding) {
+        // The Actor is gone (destroyed or relocated away): nothing to record.
+        const state = this.options.actorManager()?.getState(actorId);
+        // No registry binding exists only for a native-fallback bind, which has no
+        // Session owner registry (managed-stream.ts `bindActor` fallback).
+        if (state === undefined || binding === undefined)
+            return;
+        const route = this.options.meshRouters.remoteBoundSessionTargetForSource(binding.sessionOwnerNodeRid);
+        if (route === undefined) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${actorId}' Session route is unavailable.`);
+        }
+        state.installBoundSessionBinding({
+            ...route,
+            sessionNodeRid: binding.sessionOwnerNodeRid,
+            sessionRid: binding.sessionRid,
+            sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
+            sessionOwnerId: binding.sessionOwnerId,
+            sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
+            bindingGeneration: binding.bindingGeneration
+        });
     }
     async relayRemoteActorPacket(actor, frameHeader, payload, signal) {
         const streamRuntime = this.options.streamBindingRuntime();
@@ -544,9 +503,7 @@ class ZLinkActorPacketRelay {
     }
     requireCurrentRemoteBinding(relay, routeContext) {
         const state = this.options.actorManager()?.getState(relay.actorId);
-        const current = state === undefined
-            ? undefined
-            : (0, actor_runtime_state_1.preferredRemoteBoundSessionTarget)(state.remoteBoundSessionTarget, state.boundSessionTransferTarget);
+        const current = state?.boundSession;
         if (current === undefined ||
             current.sessionNodeRid === undefined ||
             !(0, routing_id_1.routingIdsEqual)(current.sessionNodeRid, routeContext.sourceNodeRid) ||

package/dist/runtime/host/actor-placement-coordinator.js

@@ -7,6 +7,7 @@ const runtime_values_1 = require("../backend/runtime-values");
 const contracts_1 = require("../../contracts");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
 const creation_operation_id_1 = require("../locations/creation-operation-id");
+const diagnostic_text_1 = require("../diagnostics/diagnostic-text");
 const actor_authority_publication_1 = require("../actors/actor-authority-publication");
 const user_spot_creation_coordinator_1 = require("./user-spot-creation-coordinator");
 const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
@@ -20,9 +21,10 @@ class ZLinkActorPlacementCoordinator {
         this.options = options;
     }
     async create(actorId, stableType, createOnly, meshName, requestPayload, timeoutMs, signal) {
-        const deadline = createDeadline(timeoutMs, signal);
-        const deadlineMs = performance.now() + timeoutMs;
         const deadlineUnixMs = Date.now() + timeoutMs;
+        const remainingMs = Math.max(0, deadlineUnixMs - Date.now());
+        const deadline = createDeadline(remainingMs, signal);
+        const deadlineMs = performance.now() + remainingMs;
         const contentReference = (0, user_spot_creation_coordinator_1.encodeLocationCreationContent)(requestPayload);
         const requestSha256 = (0, node_crypto_1.createHash)('sha256').update(requestPayload).digest();
         const excluded = new Set();
@@ -60,7 +62,7 @@ class ZLinkActorPlacementCoordinator {
                     target: reservationTarget(target),
                     creatingPayload,
                     capacity: { actors: 1, spots: 0 }
-                }, deadline.signal);
+                }, deadline.signal, BigInt(deadlineUnixMs));
                 const existing = existingActor(reserved, actorId, stableType);
                 if (existing !== undefined) {
                     if (createOnly) {
@@ -110,13 +112,13 @@ class ZLinkActorPlacementCoordinator {
                     //  83-118, 99-108). Backpressured(113) still surfaces as target
                     //  placement capacity -> Unavailable through the shared path.
                     throw (0, framework_errors_internal_1.wireReplyFailureException)(remote.terminalResult, remote.failureCode, `Remote Actor '${actorId}' creation failed with result ${remote.terminalResult}, ` +
-                        `failure code ${remote.failureCode}, and tail ${remote.tail?.kind ?? 'none'}.`);
+                        `failure code ${remote.failureCode}, and tail ${(0, diagnostic_text_1.diagnosticTextOrAbsent)(remote.tail?.kind)}.`);
                 }
                 if (remote.tail?.kind !== 'actorCreate') {
                     //  An OK terminal whose reply lacks the actorCreate tail is a
                     //  protocol violation, not a create failure.
                     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError, `Remote Actor '${actorId}' create reply carried tail ` +
-                        `${remote.tail?.kind ?? 'none'} on an OK terminal.`);
+                        `${(0, diagnostic_text_1.diagnosticTextOrAbsent)(remote.tail?.kind)} on an OK terminal.`);
                 }
                 if (remote.tail.createResult === 'rejected') {
                     return {

package/dist/runtime/host/actor-runtime-options-factory.d.ts

@@ -29,6 +29,8 @@ export interface ZLinkActorRuntimeOptionsFactoryOptions {
     readonly meshNode: (meshName: string) => ZLinkBackendMeshNode | undefined;
     readonly meshCompletions: (meshName: string) => ZLinkMeshCompletionTable | undefined;
     readonly notifyEntrySpotActorCreated: (nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, signal?: AbortSignal) => Promise<import('../../contracts').ZLinkActorCreateResponse | undefined>;
+    readonly notifyEntrySpotActorJoined: (actor: ZLinkActor, signal?: AbortSignal) => Promise<void>;
+    readonly notifyEntrySpotActorLeft: (actor: ZLinkActor, signal?: AbortSignal) => Promise<void>;
     readonly locationLifecycle: () => ZLinkLocationLifecycle | undefined;
     readonly primaryMeshName: () => string | undefined;
     readonly actorMeshName: (actorType: string) => string | undefined;

package/dist/runtime/host/actor-runtime-options-factory.js

@@ -27,6 +27,22 @@ class ZLinkActorRuntimeOptionsFactory {
                 completionTableProvider: this.options.primaryMeshCompletions,
                 spotRouteResolver: this.options.createLocationSpotRouteResolver(),
                 locationLifecycle: this.options.locationLifecycle(),
+                localSpotJoin: (spotId, actor, request, commit, signal, leaveSource, contentType) => {
+                    const manager = this.options.spotManager();
+                    if (manager === undefined)
+                        throw new Error('Actor Spot membership runtime is not started.');
+                    return manager.admitActorJoin(spotId, actor, request, commit, signal, leaveSource, contentType);
+                },
+                localEntryJoin: this.options.notifyEntrySpotActorJoined,
+                reportSourceLeaveError: this.options.reportPostCommitError,
+                localSourceLeave: async (actor, spotId, signal) => {
+                    if (spotId === undefined)
+                        return this.options.notifyEntrySpotActorLeft(actor, signal);
+                    const manager = this.options.spotManager();
+                    if (manager === undefined)
+                        throw new Error('Actor Spot membership runtime is not started.');
+                    return manager.notifyActorLeftAfterTransfer(spotId, actor, signal);
+                },
                 postCommitErrorReporter: this.options.reportPostCommitError,
                 sourceTransfer: this.options.actorTransferRuntime,
                 actorJoinRelocation: this.options.actorJoinRelocation,
@@ -89,10 +105,7 @@ class ZLinkActorRuntimeOptionsFactory {
                     return node === undefined ? undefined : (0, backend_1.meshActorSessionNodeAdapter)(node, completions);
                 },
                 localActorProvider: () => this.options.actorManager()?.getState(actorId)?.actor !== undefined,
-                remoteBoundSessionTargetProvider: () => {
-                    const state = this.options.actorManager()?.getState(actorId);
-                    return (0, actors_1.preferredRemoteBoundSessionTarget)(state?.remoteBoundSessionTarget, state?.boundSessionTransferTarget);
-                },
+                remoteBoundSessionTargetProvider: () => this.options.actorManager()?.getState(actorId)?.remoteBoundSessionTarget,
                 remoteActorPacketTargetProvider: () => this.options.actorPacketTargetForState(actorId),
                 requestTimeoutMs: this.options.registration.requestTimeoutMs,
                 actorId,