@zlink-systems/framework 0.26.0 → 0.28.0

package/src/runtime/streams/actor-session-binding-runtime-owner.ts

@@ -1,10 +1,8 @@
 import type { ActorRef } from '../../contracts';
-import type { ServiceSessionBindingAdmissionResult } from '../foundation/service-session-binding-ingress-port';
 import type {
   ZLinkActorSessionAuthorityFence,
   ZLinkActorSessionRelocationClaim,
   ZLinkActorSessionRelocationSnapshot,
-  ZLinkActorSessionRetainedOutbound,
   ZLinkActorSessionRouteFence
 } from './actor-session-binding-registry';
 
@@ -19,12 +17,6 @@ export interface ZLinkActorSessionBindingRuntimeOwner {
     actorId: string,
     sealId: string
   ): Promise<ZLinkActorSessionRelocationSnapshot | undefined>;
-  retainRelocationOutbound(
-    actorId: string,
-    operation: ZLinkActorSessionRetainedOutbound,
-    sealId?: string
-  ): Promise<ServiceSessionBindingAdmissionResult>;
-  discardRelocationOutbound(actorId: string, sealId: string, error: unknown): Promise<void>;
   applyRelocation(
     actorId: string,
     sealId: string,

package/src/runtime/streams/bound-actor-relay-sender.ts

@@ -1,32 +1,38 @@
 import type { ZLinkMessage, ZLinkMessageSerializer, ZLinkSessionActor } from '../../contracts';
-import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
-import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
 import {
-  encodeStreamHeader,
-  messageToBytes,
-  type ZLinkStreamFrameHeader,
-  ZLinkStreamMessageKind
-} from './protocol';
-import { throwIfAborted } from '../abort';
-import { captureZLinkExecutionTurn } from '../execution';
+  ZLinkDispatchErrorSurface,
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome
+} from '../../contracts/Dispatch/ZLinkDispatchOptions';
+import type { ZLinkDispatchErrorReporter } from '../channels';
+import { flowIfEnabled } from '../diagnostics';
+import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
+import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
 import {
   ZLinkActorSessionBindingRegistry,
   ZLinkActorSessionBindingTermination
 } from './actor-session-binding-registry';
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 import { ZLinkManagedStream } from './managed-stream';
+import {
+  encodeStreamHeader,
+  messageToBytes,
+  ZLinkStreamMessageKind,
+  type ZLinkStreamFrameHeader
+} from './protocol';
 import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
 import { ZLinkStreamFrameMessageFactory } from './stream-frame-factory';
+export const DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS = 2000;
 
 export interface ZLinkBoundActorRelaySenderOptions {
+  readonly dispatchErrors?: ZLinkDispatchErrorReporter;
   readonly actorBindTimeoutMs?: number;
   readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
   readonly relay?: (
     actor: ZLinkSessionActor,
     header: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ) => Promise<boolean>;
   readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
 }
@@ -45,7 +51,6 @@ export class ZLinkBoundActorRelaySender {
   async relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     dispatchHeader?: ZLinkStreamFrameHeader
   ): Promise<ZLinkSubmitResult> {
     const header =
@@ -56,70 +61,98 @@ export class ZLinkBoundActorRelaySender {
       const operation = async (): Promise<ZLinkSubmitResult> => {
         const admission = await this.routes.beginAcceptedRequestFrameWhenReady(
           actor.actorId,
-          actor.bindingToken,
-          signal
+          actor.bindingToken
         );
         try {
-          return await this.relayAcceptedFrame(actor, payload, signal, header, admission);
+          return await this.relayAcceptedFrame(actor, payload, header, admission);
         } finally {
           await admission.complete();
         }
       };
-      if (
-        (await this.routes.isSealed(actor.actorId)) &&
-        captureZLinkExecutionTurn() !== undefined
-      ) {
-        void operation().catch(() => undefined);
-        return { status: ZLinkSubmitStatus.Submitted };
-      }
       return await operation();
     }
-    if ((await this.routes.isSealed(actor.actorId)) && captureZLinkExecutionTurn() !== undefined) {
-      //  Spec 32:62 — a Send completes once the source outbound queue
-      //  accepts it; spec 05 — infrastructure send progress must not depend
-      //  on the application turn. When the CALLER IS an application turn
-      //  (a lifecycle callback pushing to a bound actor), awaiting the seal
-      //  release here deadlocks: the relocation seal waits for that very
-      //  callback to finish (onJoinedActor -> push -> seal ->
-      //  onJoinedActor). Accept the frame now and deliver it after the
-      //  seal releases, in per-actor order through the lifecycle lane; the
-      //  bounded seal wait converts a stuck seal into a typed failure.
-      //  Non-turn callers (stream ingress relays) keep the waiting
-      //  semantics so a held frame across a failed rebind still
-      //  terminalizes to the caller.
-      void this.routes
-        .runAcceptedFrameWhenReady(
-          actor.actorId,
-          actor.bindingToken,
-          () => this.relayAcceptedFrame(actor, payload, signal),
-          signal
-        )
-        .catch(() => undefined);
+    const held = await this.routes.acceptOneWay(actor.actorId, actor.bindingToken, () => {
+      let heldMessage: Message | undefined = encodeFrameworkPayloadMessage(
+        payload,
+        this.options.messageSerializers
+      );
+      return {
+        deliver: async () => {
+          try {
+            const result = await this.routes.runAcceptedFrameWhenReady(
+              actor.actorId,
+              actor.bindingToken,
+              () => this.relayAcceptedFrame(actor, payload, header, undefined, heldMessage)
+            );
+            if (result.status !== ZLinkSubmitStatus.Submitted) {
+              this.traceHeldDrop(
+                header,
+                result.status === ZLinkSubmitStatus.Backpressured ||
+                  result.status === ZLinkSubmitStatus.TimedOut
+                  ? 'backpressure'
+                  : result.status === ZLinkSubmitStatus.Shutdown
+                    ? 'shutdown'
+                    : 'stale_target'
+              );
+            }
+          } finally {
+            heldMessage?.close();
+            heldMessage = undefined;
+          }
+        },
+        drop: (reason, error) => {
+          heldMessage?.close();
+          heldMessage = undefined;
+          this.traceHeldDrop(header, reason, error);
+        }
+      };
+    });
+    if (held) {
       return { status: ZLinkSubmitStatus.Submitted };
     }
-    return this.routes.runAcceptedFrameWhenReady(
-      actor.actorId,
-      actor.bindingToken,
-      () => this.relayAcceptedFrame(actor, payload, signal),
-      signal
+    return this.routes.runAcceptedFrameWhenReady(actor.actorId, actor.bindingToken, () =>
+      this.relayAcceptedFrame(actor, payload)
     );
   }
 
+  private traceHeldDrop(
+    header: ZLinkStreamFrameHeader,
+    reason: 'backpressure' | 'target_closed' | 'stale_target' | 'shutdown',
+    error?: unknown
+  ): void {
+    flowIfEnabled(
+      this.options.dispatchErrors?.flow,
+      ZLinkRuntimeMessageFlowOutcome.Dropped,
+      undefined,
+      header.flowId
+    )?.trace({
+      outcome: ZLinkRuntimeMessageFlowOutcome.Dropped,
+      surface: ZLinkDispatchErrorSurface.StreamSession,
+      messageKind: ZLinkDispatchMessageKind.Send,
+      packetName: header.name,
+      flowId: header.flowId,
+      flowOrigin: header.flowOrigin,
+      correlationId: header.correlationId,
+      errorReason: reason,
+      ...(error instanceof Error ? { errorType: error.name, errorMessage: error.message } : {})
+    });
+  }
+
   private async relayAcceptedFrame(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     header?: ZLinkStreamFrameHeader,
-    requestAdmission?: { beginSubmission(signal?: AbortSignal): Promise<void> | undefined }
+    requestAdmission?: { beginSubmission(signal?: AbortSignal): Promise<void> | undefined },
+    acceptedPayload?: Message
   ): Promise<ZLinkSubmitResult> {
     const activeHeader = header ?? (await this.currentHeader(actor));
     const started = await this.lifecycle.run(actor.actorId, async () => {
       const completion = this.relayInsideLifecycle(
         actor,
         payload,
-        signal,
         activeHeader,
-        requestAdmission
+        requestAdmission,
+        acceptedPayload
       );
       if (
         activeHeader.kind === ZLinkStreamMessageKind.Request &&
@@ -163,18 +196,18 @@ export class ZLinkBoundActorRelaySender {
   private async relayInsideLifecycle(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal: AbortSignal | undefined,
     currentHeader?: ZLinkStreamFrameHeader,
-    requestAdmission?: { beginSubmission(signal?: AbortSignal): Promise<void> | undefined }
+    requestAdmission?: { beginSubmission(signal?: AbortSignal): Promise<void> | undefined },
+    acceptedPayload?: Message
   ): Promise<ZLinkSubmitResult> {
     const header = currentHeader ?? (await this.currentHeader(actor));
-    const held = requestAdmission?.beginSubmission(signal);
+    const held = requestAdmission?.beginSubmission();
     if (held !== undefined) await held;
-    throwIfAborted(signal);
-    const payloadMessage = encodeFrameworkPayloadMessage(payload, this.options.messageSerializers);
+    const payloadMessage =
+      acceptedPayload ?? encodeFrameworkPayloadMessage(payload, this.options.messageSerializers);
     try {
       if (this.options.relay !== undefined) {
-        const handled = await this.options.relay(actor, header, payloadMessage, signal);
+        const handled = await this.options.relay(actor, header, payloadMessage);
         if (handled) {
           return { status: ZLinkSubmitStatus.Submitted };
         }
@@ -188,17 +221,16 @@ export class ZLinkBoundActorRelaySender {
         messageToBytes(payloadMessage)
       );
       try {
-        return await route.context.stream.submitBoundActor(
-          actor.actorId,
-          [headerMessage, framePayloadMessage],
-          signal
-        );
+        return await route.context.stream.submitBoundActor(actor.actorId, [
+          headerMessage,
+          framePayloadMessage
+        ]);
       } finally {
         headerMessage.close();
         framePayloadMessage.close();
       }
     } finally {
-      payloadMessage.close();
+      if (acceptedPayload === undefined) payloadMessage.close();
     }
   }
 
@@ -224,7 +256,7 @@ export class ZLinkBoundActorRelaySender {
     ) {
       await detached.context.stream.unbindActor(
         actor.actorId,
-        this.options.actorBindTimeoutMs ?? 2000,
+        this.options.actorBindTimeoutMs ?? DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS,
         signal
       );
     }
@@ -233,7 +265,7 @@ export class ZLinkBoundActorRelaySender {
 
   async notifyPhysicalDisconnect(context: DefaultZLinkSessionContext): Promise<void> {
     const snapshot = [...context.boundActors];
-    const timeoutMs = this.options.actorBindTimeoutMs ?? 2000;
+    const timeoutMs = this.options.actorBindTimeoutMs ?? DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS;
     await Promise.allSettled(
       snapshot.map(async (actor) => {
         const detached = await this.lifecycle.run(actor.actorId, async () => {

package/src/runtime/streams/bound-session-service.ts

@@ -23,6 +23,8 @@ import type { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './ses
 import { boundSessionErrorPayload } from './bound-session-response-target';
 import { ZLinkStreamFrameMessageFactory } from './stream-frame-factory';
 import { ZLinkManagedStream } from './managed-stream';
+import type { ZLinkSessionBindingIdentity } from './stream-binding-runtime-ports';
+import { REMOTE_BOUND_SESSION_BIND_PACKET } from '../spots/spot-remote-codec';
 
 const ZLINK_SEND_DONT_WAIT = 1;
 
@@ -127,7 +129,7 @@ export class ZLinkBoundSessionService {
       if ((await this.routes.route(actorId))?.bindingToken !== route.bindingToken) {
         return { status: ZLinkSubmitStatus.TargetNotFound };
       }
-      return await route.context.stream.submitRaw(frame, signal);
+      return await route.context.stream.submitRaw(frame);
     } finally {
       frame.close();
     }
@@ -301,12 +303,30 @@ export class ZLinkBoundSessionService {
     }
   }
 
+  /**
+   * Closes the physical Session of one exact binding after its relocation
+   * failed (Session–Actor binding §8.1). A newer binding of the same Actor is
+   * not selected.
+   */
+  async closeSessionBinding(
+    actorId: string,
+    expected: ZLinkSessionBindingIdentity,
+    signal?: AbortSignal
+  ): Promise<void> {
+    const route = await this.routes.routeForSessionBinding(
+      actorId,
+      expected.sessionRid,
+      expected.bindingGeneration
+    );
+    await route?.context.close(signal);
+  }
+
   async relayRemoteBoundSessionBind(stream: ZLinkManagedStream, actorRef: ActorRef): Promise<void> {
     const encodedBindHeader = encodeStreamHeader({
       kind: ZLinkStreamMessageKind.Send,
       codec: ZLinkStreamCodec.Raw,
       flags: ZLinkStreamHeaderFlags.None,
-      name: 'zlink.framework.actor.bound_session.bind',
+      name: REMOTE_BOUND_SESSION_BIND_PACKET,
       metadata: new Map()
     });
     //  encodeStreamHeader returns a fresh, unaliased array; view it without re-copying.

package/src/runtime/streams/index.ts

@@ -1,45 +1,45 @@
-import type { ZLinkListenerRecords } from '../foundation/listener-records';
-import type {
-  ActorRef,
-  Type,
-  ZLinkActor,
-  ZLinkBoundSession,
-  ZLinkSessionActor,
-  ZLinkSessionFactory,
-  ZLinkSession,
-  ZLinkMessageSerializer,
-  ZLinkStreamCompressionCodec,
-  ZLinkStreamCompressionOptions
+import {
+  type ActorRef,
+  type Type,
+  type ZLinkActor,
+  type ZLinkBoundSession,
+  type ZLinkMessageSerializer,
+  type ZLinkSession,
+  type ZLinkSessionActor,
+  type ZLinkSessionFactory,
+  type ZLinkStreamCompressionCodec,
+  type ZLinkStreamCompressionOptions,
+  ZLinkMessage
 } from '../../contracts';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
-import { ZLinkMessage } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import {
-  buildAdvertisedEndpoint,
-  ZLinkConfigurationException,
-  type ZLinkFrameworkRegistration
-} from '../configuration';
-import { ZLinkDispatchErrorReporter } from '../channels';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from '../../contracts/Configuration/InternalDefaults';
+import { zlinkDefaultLocationOptions } from '../../contracts/Locations/Options';
 import type {
-  ZLinkBackendAdapterFactory,
   ZLinkBackendActorSessionNode,
+  ZLinkBackendAdapterFactory,
   ZLinkBackendContext,
   ZLinkBackendMeshNode,
   ZLinkBackendSocketMonitor,
   ZLinkBackendStreamSocket
 } from '../backend/contracts';
 import type { ZLinkMeshCompletionTable } from '../backend/mesh-completion-table';
+import { ZLinkDispatchErrorReporter } from '../channels';
+import {
+  buildAdvertisedEndpoint,
+  ZLinkConfigurationException,
+  type ZLinkFrameworkRegistration
+} from '../configuration';
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { StreamSessionService } from '../foundation/service-runtime-contracts';
 import { registerServiceSessionBindingIngressPort } from '../foundation/service-session-binding-ingress-port';
 import {
-  messageToBytes,
-  ZLinkStreamCodec,
-  type ZLinkStreamFrameHeader,
-  ZLinkStreamMessageKind,
-  type ZLinkStreamReplyMessageKind
-} from './protocol';
+  ApplicationJobQueue,
+  resolveApplicationJobQueueConfiguration
+} from '../host/application-job-queue';
+import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import {
+  DEFAULT_TERMINAL_RELOCATION_CAPACITY,
   ZLinkActorSessionBindingRegistry,
   type ZLinkActorSessionAuthorityFence
 } from './actor-session-binding-registry';
@@ -48,38 +48,45 @@ import {
   registerActorSessionBindingRuntimeOwner
 } from './actor-session-binding-runtime-owner';
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
+import { ZLinkBoundActorRelaySender } from './bound-actor-relay-sender';
 import {
-  decompressStreamPayload,
-  resolveStreamCompressionCodec,
-  ZLinkStreamFrameMessageFactory
-} from './stream-frame-factory';
+  DefaultZLinkBoundSessionResponseTarget,
+  type ZLinkBoundSessionResponseTarget
+} from './bound-session-response-target';
+import { ZLinkBoundSessionService, type ZLinkBoundSessionTransport } from './bound-session-service';
+import { ZLinkManagedStream } from './managed-stream';
 import {
-  ApplicationJobQueue,
-  resolveApplicationJobQueueConfiguration
-} from '../host/application-job-queue';
-import { simpleMessage } from './stream-message-utils';
+  messageToBytes,
+  ZLinkStreamCodec,
+  ZLinkStreamMessageKind,
+  type ZLinkStreamFrameHeader,
+  type ZLinkStreamReplyMessageKind
+} from './protocol';
+import { ZLinkSessionActorCoordinator } from './session-actor-coordinator';
 import {
   DefaultZLinkBoundSession,
   DefaultZLinkSessionActor,
   DefaultZLinkSessionContext
 } from './session-context';
-import {
-  DefaultZLinkBoundSessionResponseTarget,
-  type ZLinkBoundSessionResponseTarget
-} from './bound-session-response-target';
-import { ZLinkBoundSessionService, type ZLinkBoundSessionTransport } from './bound-session-service';
-import { ZLinkSessionActorCoordinator } from './session-actor-coordinator';
-import { ZLinkBoundActorRelaySender } from './bound-actor-relay-sender';
-import { ZLinkManagedStream } from './managed-stream';
 import { createStreamSessionInstance } from './session-provider';
-import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from '../../contracts/Configuration/InternalDefaults';
+import type {
+  ZLinkActorRouteCommitOptions,
+  ZLinkSessionBindingConfirmationOptions,
+  ZLinkSessionBindingIdentity
+} from './stream-binding-runtime-ports';
+import {
+  decompressStreamPayload,
+  resolveStreamCompressionCodec,
+  ZLinkStreamFrameMessageFactory
+} from './stream-frame-factory';
+import { simpleMessage } from './stream-message-utils';
 import {
   ZLinkStreamSessionNodeRuntime as ZLinkStreamSessionNodeRuntimeCore,
   ZLinkStreamSessionRuntime as ZLinkStreamSessionRuntimeCore,
   type ZLinkStreamSessionNodeRuntimeOptions as ZLinkStreamSessionNodeRuntimeCoreOptions,
   type ZLinkStreamSessionRuntimeOptions as ZLinkStreamSessionRuntimeCoreOptions
 } from './stream-session-runtime';
-import type { ZLinkActorRouteCommitOptions } from './stream-binding-runtime-ports';
+const DEFAULT_STREAM_SERVICE_SHUTDOWN_TIMEOUT_MS = 1000;
 export { ZLinkPendingSessionRequest } from './session-requests';
 export { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 export { ZLinkActorSessionBindingRegistry } from './actor-session-binding-registry';
@@ -99,6 +106,7 @@ export type {
 } from './bound-session-service';
 
 export interface ZLinkStreamBindingRuntimeOptions {
+  readonly dispatchErrors?: ZLinkDispatchErrorReporter;
   readonly transport?: ZLinkBoundSessionTransport;
   readonly messageFactory?: ZLinkStreamMessageFactory;
   readonly streamPayloadCodec?: ZLinkStreamPayloadCodec;
@@ -121,7 +129,7 @@ export interface ZLinkStreamBindingRuntimeOptions {
     actor: ActorRef,
     sessionRid: ActorRef['nodeRid'],
     signal?: AbortSignal,
-    options?: { readonly waitForAcknowledgement?: boolean }
+    options?: ZLinkSessionBindingConfirmationOptions
   ) => Promise<void>;
   readonly errorSink?: () =>
     | {
@@ -131,8 +139,7 @@ export interface ZLinkStreamBindingRuntimeOptions {
   readonly relay?: (
     actor: ZLinkSessionActor,
     header: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ) => Promise<boolean>;
   readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
   readonly flowCreationEnabled?: () => boolean;
@@ -274,10 +281,7 @@ export class ZLinkStreamRuntimeManager {
           node.nativeSessionServices.push(service);
           const bindingOwner = actorSessionBindingRuntimeOwner(this.options.bindingRuntime);
           registerServiceSessionBindingIngressPort(service, {
-            actorSlot: (actorId, sessionRid) => bindingOwner.actorSlot(actorId, sessionRid),
-            retainOutbound: (actorId, delivery) =>
-              bindingOwner.retainRelocationOutbound(actorId, delivery),
-            clearOutbound: (actorId, error) => bindingOwner.clearRelocation(actorId, error)
+            actorSlot: (actorId, sessionRid) => bindingOwner.actorSlot(actorId, sessionRid)
           });
           nativeSessionRoutes.set(meshName, {
             service,
@@ -332,16 +336,16 @@ export class ZLinkStreamRuntimeManager {
 
   async dispose(): Promise<void> {
     const nodes = [...this.nodes.values()];
-    this.nodes.clear();
     for (const node of nodes.reverse()) {
       await node.runtime?.dispose();
       for (const service of node.nativeSessionServices) {
-        service.shutdown(1000);
+        service.shutdown(DEFAULT_STREAM_SERVICE_SHUTDOWN_TIMEOUT_MS);
         service.close();
       }
       await node.monitor?.dispose();
       await node.socket.dispose();
     }
+    this.nodes.clear();
   }
 
   async notifyServerDrain(meshName: string): Promise<void> {
@@ -373,6 +377,7 @@ export class ZLinkStreamSessionRuntime extends ZLinkStreamSessionRuntimeCore {
     const bindingRuntime =
       options.bindingRuntime ??
       new ZLinkStreamBindingRuntime({
+        dispatchErrors: options.dispatchErrors,
         flowCreationEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
       });
     super(
@@ -396,6 +401,7 @@ export class ZLinkStreamSessionNodeRuntime extends ZLinkStreamSessionNodeRuntime
     const bindingRuntime =
       options.bindingRuntime ??
       new ZLinkStreamBindingRuntime({
+        dispatchErrors: options.dispatchErrors,
         flowCreationEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
       });
     super({
@@ -424,7 +430,12 @@ export class ZLinkStreamBindingRuntime {
     this.routes = new ZLinkActorSessionBindingRegistry<
       DefaultZLinkSessionContext,
       DefaultZLinkSessionActor
-    >(4096, 4096, runtimeOptions.sessionRelocationSealTimeoutMs ?? 3_000, runtimeOptions.errorSink);
+    >(
+      DEFAULT_TERMINAL_RELOCATION_CAPACITY,
+      runtimeOptions.sessionRelocationSealTimeoutMs ??
+        zlinkDefaultLocationOptions.sessionRelocationSealTimeoutMs,
+      runtimeOptions.errorSink
+    );
     this.compressionCodec = resolveStreamCompressionCodec(runtimeOptions.streamCompression);
     this.frameMessages = new ZLinkStreamFrameMessageFactory(runtimeOptions);
     this.boundSessions = new ZLinkBoundSessionService(
@@ -446,19 +457,11 @@ export class ZLinkStreamBindingRuntime {
       actorSessionLifecycle
     );
     registerActorSessionBindingRuntimeOwner(this, {
-      actorSlot: async (actorId, sessionRid) => {
-        const route = await this.routes.route(actorId);
-        return route !== undefined && route.sessionIdentity === sessionRid
-          ? route.actorSlot
-          : undefined;
-      },
+      actorSlot: async (actorId, sessionRid) =>
+        (await this.routes.routeForSessionBinding(actorId, sessionRid))?.actorSlot,
       sealRelocation: (claim, expected, signal) =>
         this.routes.sealRelocation(claim, expected, signal),
       relocationSnapshot: (actorId, sealId) => this.routes.relocationSnapshot(actorId, sealId),
-      retainRelocationOutbound: (actorId, operation, sealId) =>
-        this.routes.retainRelocationOutbound(actorId, operation, sealId),
-      discardRelocationOutbound: (actorId, sealId, error) =>
-        this.routes.discardRelocationOutbound(actorId, sealId, error),
       applyRelocation: (...args) => this.routes.applyRelocation(...args),
       observeRelocationTerminal: (...args) => this.routes.observeRelocationTerminal(...args),
       clearRelocation: (actorId, error) => this.routes.clearRelocation(actorId, error),
@@ -743,13 +746,20 @@ export class ZLinkStreamBindingRuntime {
     await this.boundSessions.disconnectBoundSession(actorId, signal);
   }
 
+  async closeSessionBinding(
+    actorId: string,
+    expected: ZLinkSessionBindingIdentity,
+    signal?: AbortSignal
+  ): Promise<void> {
+    await this.boundSessions.closeSessionBinding(actorId, expected, signal);
+  }
+
   async relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     dispatchHeader?: ZLinkStreamFrameHeader
   ): Promise<ZLinkSubmitResult> {
-    return await this.boundActorRelay.relay(actor, payload, signal, dispatchHeader);
+    return await this.boundActorRelay.relay(actor, payload, dispatchHeader);
   }
 
   async notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void> {