@zlink-systems/framework 0.26.0 → 0.27.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,25 +1,33 @@
 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';
+  ZLinkDispatchErrorSurface,
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome
+} from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { throwIfAborted } from '../abort';
-import { captureZLinkExecutionTurn } from '../execution';
+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?: (
@@ -65,36 +73,47 @@ export class ZLinkBoundActorRelaySender {
           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);
+    throwIfAborted(signal);
+    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, undefined, 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(
@@ -105,12 +124,36 @@ export class ZLinkBoundActorRelaySender {
     );
   }
 
+  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 () => {
@@ -119,7 +162,8 @@ export class ZLinkBoundActorRelaySender {
         payload,
         signal,
         activeHeader,
-        requestAdmission
+        requestAdmission,
+        acceptedPayload
       );
       if (
         activeHeader.kind === ZLinkStreamMessageKind.Request &&
@@ -165,13 +209,15 @@ export class ZLinkBoundActorRelaySender {
     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);
     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);
@@ -198,7 +244,7 @@ export class ZLinkBoundActorRelaySender {
         framePayloadMessage.close();
       }
     } finally {
-      payloadMessage.close();
+      if (acceptedPayload === undefined) payloadMessage.close();
     }
   }
 
@@ -224,7 +270,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 +279,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;
 
@@ -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?: () =>
     | {
@@ -274,10 +282,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 +337,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 +378,7 @@ export class ZLinkStreamSessionRuntime extends ZLinkStreamSessionRuntimeCore {
     const bindingRuntime =
       options.bindingRuntime ??
       new ZLinkStreamBindingRuntime({
+        dispatchErrors: options.dispatchErrors,
         flowCreationEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
       });
     super(
@@ -396,6 +402,7 @@ export class ZLinkStreamSessionNodeRuntime extends ZLinkStreamSessionNodeRuntime
     const bindingRuntime =
       options.bindingRuntime ??
       new ZLinkStreamBindingRuntime({
+        dispatchErrors: options.dispatchErrors,
         flowCreationEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
       });
     super({
@@ -424,7 +431,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 +458,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,6 +747,14 @@ 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,

package/src/runtime/streams/managed-stream.ts

@@ -10,7 +10,11 @@ import type {
   ZLinkMessageSerializer,
   ZLinkStream
 } from '../../contracts';
-import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
+import {
+  ZLinkSubmitStatus,
+  classifySubmitResult,
+  type ZLinkSubmitResult
+} from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
 import { throwIfAborted } from '../abort';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
@@ -19,14 +23,16 @@ import type {
   ZLinkBackendSendFlags,
   ZLinkBackendStreamSocket
 } from '../backend/contracts';
-import { RequestResult, isBackendNotConnectedError } from '../backend/runtime-values';
+import { RequestResult, isZLinkBackendResultError } from '../backend/runtime-values';
 import { ZLinkBufferMessage as NativeMessage } from '../backend/runtime-message';
+import { diagnosticTextOrAbsent } from '../diagnostics/diagnostic-text';
 import type {
   StreamSessionActorAuthorityFence,
   StreamSessionService
 } from '../foundation/service-runtime-contracts';
 import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
 import type { ServiceActorRef } from '../foundation/service-stateful-registry';
+import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
 import {
   closeMeshCompletion,
   type ZLinkMeshCompletion,
@@ -55,7 +61,8 @@ export interface ZLinkNativeSessionRoute {
 
 interface ZLinkManagedActorBinding {
   readonly actor: ZLinkBackendActorRef;
-  readonly bindingGeneration?: bigint;
+  /** The Session owner's registry snapshot of this binding (Session–Actor binding §5-2). */
+  readonly binding?: ServiceStreamSessionBinding;
   readonly route?: ZLinkNativeSessionRoute;
 }
 
@@ -90,7 +97,12 @@ export class ZLinkManagedStream implements ZLinkStream {
   }
 
   actorBindingGeneration(actorId: string): bigint | undefined {
-    return this.nativeActorBindings.get(actorId)?.bindingGeneration;
+    return this.nativeActorBindings.get(actorId)?.binding?.bindingGeneration;
+  }
+
+  /** The Session owner's registry snapshot of the Actor's current native binding. */
+  actorBinding(actorId: string): ServiceStreamSessionBinding | undefined {
+    return this.nativeActorBindings.get(actorId)?.binding;
   }
 
   private isTransportClosed(): boolean {
@@ -128,7 +140,9 @@ export class ZLinkManagedStream implements ZLinkStream {
       await this.socket.submit(this.backendRoutingId(), payload, timeoutMs);
       return { status: ZLinkSubmitStatus.Submitted };
     } catch (error) {
-      if (isBackendNotConnectedError(error)) return { status: ZLinkSubmitStatus.Backpressured };
+      if (isZLinkBackendResultError(error) && error.operation === 'submit') {
+        return classifySubmitResult(error.result, 'STREAM submit', error.phase);
+      }
       throw error;
     }
   }
@@ -268,7 +282,7 @@ export class ZLinkManagedStream implements ZLinkStream {
       }
       this.nativeActorBindings.set(actor.actorId, {
         actor: nativeActor,
-        bindingGeneration: binding.bindingGeneration,
+        binding,
         route
       });
       return;
@@ -309,7 +323,11 @@ export class ZLinkManagedStream implements ZLinkStream {
           ZLinkFrameworkInternalErrorKind.ActorRouteNotFound,
           `Actor '${actor.actorId}' native route fence does not match its ActorRef ` +
             `(expected ${String(actor.nodeRid)}/${actor.objectGeneration}, ` +
-            `resolved ${resolved === undefined ? 'none' : `${String(resolved.nodeRid)}/${resolved.generation}`}, ` +
+            `resolved ${diagnosticTextOrAbsent(
+              resolved === undefined
+                ? undefined
+                : `${String(resolved.nodeRid)}/${resolved.generation}`
+            )}, ` +
             `terminal=${completion.terminalResult}, failure=${completion.failureErrno}).`
         );
       }
@@ -329,7 +347,8 @@ export class ZLinkManagedStream implements ZLinkStream {
     const binding = this.nativeActorBindings.get(actorId);
     if (binding?.route !== undefined) {
       const route = binding.route;
-      if (!this.hasNativeBinding(route, actorId, binding.bindingGeneration!)) {
+      const bindingGeneration = binding.binding!.bindingGeneration;
+      if (!this.hasNativeBinding(route, actorId, bindingGeneration)) {
         this.nativeActorBindings.delete(actorId);
         return;
       }
@@ -340,7 +359,7 @@ export class ZLinkManagedStream implements ZLinkStream {
               route.service.unbindActor(
                 this.backendRoutingId(),
                 binding.actor as never,
-                binding.bindingGeneration!,
+                bindingGeneration,
                 timeoutMs
               ),
             signal
@@ -356,7 +375,7 @@ export class ZLinkManagedStream implements ZLinkStream {
         // tombstone. A transport teardown can therefore report an internal
         // completion after the exact binding is already gone. Treat only that
         // exact missing binding as stale cleanup; preserve other failures.
-        if (this.hasNativeBinding(route, actorId, binding.bindingGeneration!)) {
+        if (this.hasNativeBinding(route, actorId, bindingGeneration)) {
           throw error;
         }
       }

package/src/runtime/streams/native-fallback-bound-session.ts

@@ -160,9 +160,8 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
   ): Promise<ZLinkSubmitResult> {
     const localActor = this.options.localActorProvider?.() === true;
     const remoteTarget = this.options.remoteBoundSessionTargetProvider();
-    const sealedRemoteTarget = remoteTarget?.relocationSealId !== undefined;
     let nativeAttempted = false;
-    if (localActor && !sealedRemoteTarget) {
+    if (localActor) {
       const result = await this.options.runtime.submitLocalBoundSession(
         this.options.actorId,
         this.message,
@@ -213,7 +212,6 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
         actorNodeRidHex: (actorRef?.nodeRid as { toHex?: () => string } | undefined)?.toHex?.(),
         actorGeneration: actorRef?.objectGeneration.toString(),
         actorOwnershipGeneration: ownershipGeneration?.toString(),
-        relocationSealId: remoteTarget.relocationSealId,
         message: this.message,
         boundPacketName: packetName,
         metadata: this.selectedMetadata,