@zlink-systems/framework 0.26.0 → 0.28.0

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 {
@@ -118,27 +130,19 @@ export class ZLinkManagedStream implements ZLinkStream {
     return this.socket.send(this.backendRoutingId(), payload, flags ?? 0);
   }
 
-  async submitRaw(
-    payload: Message,
-    signal?: AbortSignal,
-    timeoutMs?: number
-  ): Promise<ZLinkSubmitResult> {
+  async submitRaw(payload: Message): Promise<ZLinkSubmitResult> {
     try {
-      throwIfAborted(signal);
-      await this.socket.submit(this.backendRoutingId(), payload, timeoutMs);
+      await this.socket.submit(this.backendRoutingId(), payload);
       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;
     }
   }
 
-  async submitBoundActor(
-    actorId: string,
-    parts: readonly Message[],
-    signal?: AbortSignal
-  ): Promise<ZLinkSubmitResult> {
-    throwIfAborted(signal);
+  async submitBoundActor(actorId: string, parts: readonly Message[]): Promise<ZLinkSubmitResult> {
     return (await this.sendBoundActor(actorId, parts, ZLINK_SEND_DONT_WAIT))
       ? { status: ZLinkSubmitStatus.Submitted }
       : { status: ZLinkSubmitStatus.Backpressured };
@@ -268,7 +272,7 @@ export class ZLinkManagedStream implements ZLinkStream {
       }
       this.nativeActorBindings.set(actor.actorId, {
         actor: nativeActor,
-        bindingGeneration: binding.bindingGeneration,
+        binding,
         route
       });
       return;
@@ -309,7 +313,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 +337,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 +349,7 @@ export class ZLinkManagedStream implements ZLinkStream {
               route.service.unbindActor(
                 this.backendRoutingId(),
                 binding.actor as never,
-                binding.bindingGeneration!,
+                bindingGeneration,
                 timeoutMs
               ),
             signal
@@ -356,7 +365,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

@@ -32,7 +32,6 @@ import {
   type ZLinkStreamFrameHeader
 } from './protocol';
 import type { ZLinkNativeFallbackBoundSessionPort } from './stream-binding-runtime-ports';
-import { throwIfAborted } from '../abort';
 import type { ZLinkBackendActorSessionNode } from '../backend';
 import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import { currentOrCreateFlow, runWithOutboundFlow } from '../diagnostics/flow-context';
@@ -87,8 +86,7 @@ export class ZLinkNativeFallbackBoundSession implements ZLinkBoundSession {
         return;
       }
       await this.options.routedTransport.sendToSpot(target, payload, {
-        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-        signal
+        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
       });
       return;
     }
@@ -126,7 +124,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
     return this;
   }
 
-  async submit(signal?: AbortSignal): Promise<void> {
+  async submit(): Promise<void> {
     if (this.executed) {
       throwAlreadySubmitted('Bound session send call');
     }
@@ -136,8 +134,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
       'Bound session'
     );
     this.executed = true;
-    throwIfAborted(signal);
-    const result = await this.execute(packetName, signal);
+    const result = await this.execute(packetName);
     requireOneWayCompletion(
       result,
       'Bound session send',
@@ -145,30 +142,25 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
     );
   }
 
-  private execute(packetName: string, signal?: AbortSignal): Promise<ZLinkSubmitResult> {
+  private execute(packetName: string): Promise<ZLinkSubmitResult> {
     // Call-scoped flow (spec 27 §4): the relay JSON flow pair and any nested
     // routed-transport envelope share one ambient flow that does not outlive
     // this submit call.
     return runWithOutboundFlow(this.options.flowCreationEnabled?.() ?? true, () =>
-      this.executeScoped(packetName, signal)
+      this.executeScoped(packetName)
     );
   }
 
-  private async executeScoped(
-    packetName: string,
-    signal?: AbortSignal
-  ): Promise<ZLinkSubmitResult> {
+  private async executeScoped(packetName: string): 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,
         packetName,
-        this.selectedMetadata,
-        signal
+        this.selectedMetadata
       );
       if (result.status !== ZLinkSubmitStatus.TargetNotFound) {
         this.traceSubmitted(result, packetName);
@@ -189,8 +181,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
           actorRef,
           this.message,
           packetName,
-          this.selectedMetadata,
-          signal
+          this.selectedMetadata
         );
         if (result.status !== ZLinkSubmitStatus.TargetNotFound) {
           this.traceSubmitted(result, packetName);
@@ -213,7 +204,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,
@@ -236,15 +226,14 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
                 spotKind: ZLinkSpotKind.Entry
               },
               payload,
-              { packetName: ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, signal }
+              { packetName: ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET }
             )
           : await submit.call(
               this.options.routedTransport,
               remoteTarget.routerChannelId,
               String(remoteTarget.targetNodeRid),
               ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET,
-              payload,
-              signal
+              payload
             );
       this.traceSubmitted(result, packetName);
       return result;
@@ -253,8 +242,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
       this.options.actorId,
       this.message,
       packetName,
-      this.selectedMetadata,
-      signal
+      this.selectedMetadata
     );
     if (localResult.status !== ZLinkSubmitStatus.TargetNotFound) {
       this.traceSubmitted(localResult, packetName);
@@ -274,8 +262,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
         actorRef,
         this.message,
         packetName,
-        this.selectedMetadata,
-        signal
+        this.selectedMetadata
       );
       this.traceSubmitted(result, packetName);
       return result;
@@ -291,8 +278,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
       this.options.actorId,
       this.message,
       packetName,
-      this.selectedMetadata,
-      signal
+      this.selectedMetadata
     );
     this.traceSubmitted(result, packetName);
     return result;

package/src/runtime/streams/protocol.ts

@@ -1,90 +1,52 @@
-import type { Message } from '../../contracts/Common/Message';
-import type { ZLinkFlowOrigin } from '../../contracts';
-import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import {
+  ZlinkStreamCloseReasonCode as ZLinkStreamCloseReasonCode,
+  ZlinkStreamCodec as ZLinkStreamCodec,
+  ZlinkStreamHeaderFlags as ZLinkStreamHeaderFlags,
+  ZlinkStreamMessageKind as ZLinkStreamMessageKind,
+  ZlinkStreamControlPacket,
   decodeStreamWireFrame,
   decodeStreamWireHeader,
+  defaultMaxDecompressedPayloadSize,
+  encodeStreamWireActorBoundPayload,
+  encodeStreamWireActorUnboundPayload,
   encodeStreamWireFrame,
   encodeStreamWireHeader,
+  encodeStreamWireSessionClosingPayload,
   lz4PickleUncompressed,
   lz4UnpicklePayload,
   tryDecodeStreamWireFrame,
-  utf8Encode
+  streamCodecContentType as wireCodecContentType,
+  streamCodecForContentType as wireCodecForContentType
 } from '@zlink-systems/stream-wire';
+import type { ZLinkFlowOrigin } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import { throwAlreadySubmitted } from '../messaging/submission-result';
+export {
+  ZlinkStreamMessageKind as ZLinkStreamMessageKind,
+  ZlinkStreamHeaderFlags as ZLinkStreamHeaderFlags,
+  ZlinkStreamCloseReasonCode as ZLinkStreamCloseReasonCode
+} from '@zlink-systems/stream-wire';
 
 export { utf8Decode, utf8Encode } from '@zlink-systems/stream-wire';
 
-const defaultMaxDecompressedPayloadSize = 64 * 1024;
 const actorRequestDeadlineMetadataKey = '$zlink.actor-request-deadline-unix-ms';
 //  Shared empty metadata for the dominant no-metadata frame; ReadonlyMap
 //  keeps every consumer from mutating it.
 const EMPTY_STREAM_METADATA: ReadonlyMap<string, string> = new Map();
 
-export enum ZLinkStreamCodec {
-  Raw = 0,
-  Json = 1,
-  MessagePack = 2,
-  Protobuf = 3
-}
+export { ZlinkStreamCodec as ZLinkStreamCodec } from '@zlink-systems/stream-wire';
 
 export function streamCodecContentType(codec: ZLinkStreamCodec): string {
-  switch (codec) {
-    case ZLinkStreamCodec.Json:
-      return 'application/json';
-    case ZLinkStreamCodec.MessagePack:
-      return 'application/x-msgpack';
-    case ZLinkStreamCodec.Protobuf:
-      return 'application/x-protobuf';
-    case ZLinkStreamCodec.Raw:
-      return 'application/octet-stream';
-  }
-  throw new TypeError(`Unsupported STREAM codec '${codec}'.`);
+  return wireCodecContentType(codec);
 }
 
 export function streamCodecForContentType(contentType: string): ZLinkStreamCodec {
-  switch (contentType) {
-    case 'application/json':
-      return ZLinkStreamCodec.Json;
-    case 'application/x-msgpack':
-      return ZLinkStreamCodec.MessagePack;
-    case 'application/x-protobuf':
-      return ZLinkStreamCodec.Protobuf;
-    case 'application/octet-stream':
-      return ZLinkStreamCodec.Raw;
-  }
-  throw new TypeError(`Unsupported STREAM content type '${contentType}'.`);
+  return wireCodecForContentType(contentType);
 }
 
-export enum ZLinkStreamMessageKind {
-  Send = 1,
-  Request = 2,
-  Response = 3,
-  Error = 4,
-  Control = 5
-}
-
-export enum ZLinkStreamHeaderFlags {
-  None = 0,
-  HasRequestSeq = 0x01,
-  HasMetadata = 0x02,
-  PayloadCompressed = 0x04,
-  HasCorrelationId = 0x08,
-  HasFlowId = 0x10,
-  HasActorSlot = 0x20
-}
-
-export enum ZLinkStreamCloseReasonCode {
-  ClientClose = 1,
-  IdleTimeout = 2,
-  HeartbeatTimeout = 3,
-  ServerDrain = 4,
-  ProtocolError = 5,
-  TransportError = 6
-}
-
-export const ZLINK_STREAM_HEARTBEAT_PING = '$zlink.heartbeat.ping';
-export const ZLINK_STREAM_HEARTBEAT_PONG = '$zlink.heartbeat.pong';
+export const ZLINK_STREAM_HEARTBEAT_PING = ZlinkStreamControlPacket.HeartbeatPing;
+export const ZLINK_STREAM_HEARTBEAT_PONG = ZlinkStreamControlPacket.HeartbeatPong;
 
 export interface ZLinkStreamFrameHeader {
   readonly kind: ZLinkStreamMessageKind;
@@ -142,48 +104,32 @@ export function encodeStreamControlFrame(name: string): Uint8Array {
 }
 
 export function encodeActorBoundFrame(actorSlot: number, actorId: string): Uint8Array {
-  const actorIdBytes = utf8Encode(actorId);
-  if (actorIdBytes.length < 1 || actorIdBytes.length > 0xff) {
-    throw new Error('Actor id length is invalid for a STREAM binding control packet.');
-  }
-  const payload = new Uint8Array(4 + actorIdBytes.length);
-  payload[0] = 1;
-  payload[1] = actorSlot >>> 8;
-  payload[2] = actorSlot & 0xff;
-  payload[3] = actorIdBytes.length;
-  payload.set(actorIdBytes, 4);
-  return encodeStreamFrame(controlHeader('$zlink.actor.bound'), payload);
+  return encodeStreamFrame(
+    controlHeader(ZlinkStreamControlPacket.ActorBound),
+    encodeStreamWireActorBoundPayload(actorSlot, actorId)
+  );
 }
 
 export function encodeActorUnboundFrame(actorSlot: number): Uint8Array {
-  const payload = new Uint8Array(3);
-  payload[0] = 1;
-  payload[1] = actorSlot >>> 8;
-  payload[2] = actorSlot & 0xff;
-  return encodeStreamFrame(controlHeader('$zlink.actor.unbound'), payload);
+  return encodeStreamFrame(
+    controlHeader(ZlinkStreamControlPacket.ActorUnbound),
+    encodeStreamWireActorUnboundPayload(actorSlot)
+  );
 }
 
 export function encodeSessionClosingFrame(
   diagnostic = '',
   reason = ZLinkStreamCloseReasonCode.ServerDrain
 ): Uint8Array {
-  const diagnosticBytes = utf8Encode(diagnostic);
-  if (diagnosticBytes.length > 512) throw new Error('Session-closing diagnostic is too large.');
-  const payload = new Uint8Array(4 + diagnosticBytes.length);
-  payload[0] = 1;
-  payload[1] = reason;
-  payload[2] = diagnosticBytes.length >>> 8;
-  payload[3] = diagnosticBytes.length & 0xff;
-  payload.set(diagnosticBytes, 4);
   return encodeStreamFrame(
     {
       kind: ZLinkStreamMessageKind.Control,
       codec: ZLinkStreamCodec.Raw,
       flags: ZLinkStreamHeaderFlags.None,
-      name: 'session-closing',
+      name: ZlinkStreamControlPacket.SessionClosing,
       metadata: new Map()
     },
-    payload
+    encodeStreamWireSessionClosingPayload(reason, diagnostic)
   );
 }
 

package/src/runtime/streams/session-actor-coordinator.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS } from './bound-actor-relay-sender';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
@@ -13,6 +14,7 @@ import {
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 import { ZLinkManagedStream } from './managed-stream';
 import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
+import type { ZLinkSessionBindingConfirmationOptions } from './stream-binding-runtime-ports';
 
 export interface ZLinkSessionActorCoordinatorOptions {
   readonly actorBindTimeoutMs?: number;
@@ -31,7 +33,7 @@ export interface ZLinkSessionActorCoordinatorOptions {
     actor: ActorRef,
     sessionRid: ActorRef['nodeRid'],
     signal?: AbortSignal,
-    options?: { readonly waitForAcknowledgement?: boolean }
+    options?: ZLinkSessionBindingConfirmationOptions
   ) => Promise<void>;
   readonly errorSink?: () =>
     | {
@@ -181,7 +183,13 @@ export class ZLinkSessionActorCoordinator {
         boundActorRef,
         this.actorBindingRoutingId(context),
         undefined,
-        { waitForAcknowledgement }
+        {
+          waitForAcknowledgement,
+          binding:
+            context.stream instanceof ZLinkManagedStream
+              ? context.stream.actorBinding(actorRef.actorId)
+              : undefined
+        }
       );
       const reportFailure = (error: unknown) => {
         // A fire-and-forget route update retains the already-current binding;
@@ -204,7 +212,7 @@ export class ZLinkSessionActorCoordinator {
             if (context.stream instanceof ZLinkManagedStream) {
               await context.stream.unbindActor(
                 actorRef.actorId,
-                this.options.actorBindTimeoutMs ?? 2000
+                this.options.actorBindTimeoutMs ?? DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS
               );
             }
           } catch (cleanupError) {
@@ -354,7 +362,11 @@ export class ZLinkSessionActorCoordinator {
             true
           );
         }
-        route.actor.updateRef(normalizedActorRef);
+        // A location refresh never changes the route's Session binding
+        // generation; the native bind owns it.
+        route.actor.updateRef(
+          withBindingGeneration(normalizedActorRef, bindingGenerationOf(route.actor.ref), undefined)
+        );
         if (authorityFence !== undefined) {
           await this.routes.updateAuthorityFence(normalizedActorRef.actorId, authorityFence);
         }
@@ -463,7 +475,7 @@ export class ZLinkSessionActorCoordinator {
     try {
       await context.stream.bindActor(
         actorRef,
-        this.options.actorBindTimeoutMs ?? 2000,
+        this.options.actorBindTimeoutMs ?? DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS,
         signal,
         context.actorBindingReplacedHandler,
         authorityFence

package/src/runtime/streams/session-calls.ts

@@ -1,14 +1,12 @@
-import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import type {
   ZLinkBoundSessionSendCall,
   ZLinkSessionReplyCall,
   ZLinkSessionSendCall
 } from '../../contracts';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
-import { requireOneWayCompletion } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
-import { throwIfAborted } from '../abort';
-import { ZLinkConfigurationException } from '../configuration';
+import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
+import { type ZLinkSubmitResult, requireOneWayCompletion } from '../messaging/submission-result';
+
 import {
   ensureSingleSubmit,
   resolvePacketName,
@@ -22,19 +20,14 @@ export interface ZLinkBoundSessionSendRuntime {
     actorId: string,
     message: unknown,
     packetName: string | undefined,
-    metadata: ReadonlyMap<string, string>,
-    signal?: AbortSignal
+    metadata: ReadonlyMap<string, string>
   ): Promise<ZLinkSubmitResult>;
 }
 
 export interface ZLinkSessionCallContext {
   readonly stream: {
     writeRaw(payload: Message): boolean;
-    submitRaw(
-      payload: Message,
-      signal?: AbortSignal,
-      timeoutMs?: number
-    ): Promise<ZLinkSubmitResult>;
+    submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
   };
   readonly dispatchHeader: ZLinkStreamFrameHeader | undefined;
   createJsonFrameMessage(
@@ -87,17 +80,15 @@ export class DefaultZLinkBoundSessionSendCall implements ZLinkBoundSessionSendCa
     return this;
   }
 
-  async submit(signal?: AbortSignal): Promise<void> {
+  async submit(): Promise<void> {
     ensureSingleSubmit(this.executed);
     const packetName = resolvePacketName(this.message, this.selectedPacketName);
     this.executed = true;
-    throwIfAborted(signal);
     const result = await this.runtime.sendBoundSession(
       this.actorId,
       this.message,
       packetName,
-      this.selectedMetadata,
-      signal
+      this.selectedMetadata
     );
     requireOneWayCompletion(
       result,
@@ -111,7 +102,6 @@ export class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
   private selectedPacketName: string | undefined;
   private readonly selectedMetadata = new Map<string, string>();
   private compressionEnabled = false;
-  private selectedTimeoutMs: number | undefined;
   private executed = false;
 
   constructor(
@@ -134,21 +124,10 @@ export class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
     return this;
   }
 
-  timeout(timeoutMs: number): this {
-    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647) {
-      throw new ZLinkConfigurationException(
-        'STREAM session send timeout must be an integer from 1 through 2147483647 milliseconds.'
-      );
-    }
-    this.selectedTimeoutMs = timeoutMs;
-    return this;
-  }
-
-  async submit(signal?: AbortSignal): Promise<void> {
+  async submit(): Promise<void> {
     ensureSingleSubmit(this.executed);
     const packetName = resolvePacketName(this.message, this.selectedPacketName);
     this.executed = true;
-    throwIfAborted(signal);
     const message = this.context.createJsonFrameMessage(
       ZLinkStreamMessageKind.Send,
       packetName,
@@ -158,7 +137,7 @@ export class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
       this.message
     );
     try {
-      const result = await this.context.stream.submitRaw(message, signal, this.selectedTimeoutMs);
+      const result = await this.context.stream.submitRaw(message);
       requireOneWayCompletion(result, 'STREAM session send');
       this.context.traceFrameWritten?.(ZLinkStreamMessageKind.Send, packetName, undefined);
     } finally {
@@ -181,7 +160,7 @@ export class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCall {
     return this;
   }
 
-  async submit(signal?: AbortSignal): Promise<void> {
+  async submit(): Promise<void> {
     ensureSingleSubmit(this.executed);
     this.executed = true;
     const requestHeader = this.context.dispatchHeader;
@@ -189,10 +168,6 @@ export class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCall {
       throw new Error('Reply is only available while handling a request packet.');
     }
     this.context.claimReply(requestHeader);
-    // Reply-token validity wins over caller cancellation. Claiming before the
-    // pre-cancel check keeps duplicate calls deterministic while still making
-    // a pre-cancelled first call perform no transport admission.
-    throwIfAborted(signal);
     const message = this.context.createJsonReplyFrameMessage(
       requestHeader,
       ZLinkStreamMessageKind.Response,
@@ -201,7 +176,7 @@ export class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCall {
       this.message
     );
     try {
-      const result = await this.context.stream.submitRaw(message, signal);
+      const result = await this.context.stream.submitRaw(message);
       requireOneWayCompletion(result, 'STREAM session reply');
       this.context.traceFrameWritten?.(
         ZLinkStreamMessageKind.Response,