@zlink-systems/framework 0.27.0 → 0.29.0

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

@@ -5,7 +5,6 @@ import {
   ZLinkDispatchMessageKind,
   ZLinkRuntimeMessageFlowOutcome
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import { throwIfAborted } from '../abort';
 import type { ZLinkDispatchErrorReporter } from '../channels';
 import { flowIfEnabled } from '../diagnostics';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
@@ -33,8 +32,7 @@ export interface ZLinkBoundActorRelaySenderOptions {
   readonly relay?: (
     actor: ZLinkSessionActor,
     header: ZLinkStreamFrameHeader,
-    payload: Message,
-    signal?: AbortSignal
+    payload: Message
   ) => Promise<boolean>;
   readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
 }
@@ -53,7 +51,6 @@ export class ZLinkBoundActorRelaySender {
   async relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     dispatchHeader?: ZLinkStreamFrameHeader
   ): Promise<ZLinkSubmitResult> {
     const header =
@@ -64,18 +61,16 @@ 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();
         }
       };
       return await operation();
     }
-    throwIfAborted(signal);
     const held = await this.routes.acceptOneWay(actor.actorId, actor.bindingToken, () => {
       let heldMessage: Message | undefined = encodeFrameworkPayloadMessage(
         payload,
@@ -87,8 +82,7 @@ export class ZLinkBoundActorRelaySender {
             const result = await this.routes.runAcceptedFrameWhenReady(
               actor.actorId,
               actor.bindingToken,
-              () =>
-                this.relayAcceptedFrame(actor, payload, undefined, header, undefined, heldMessage)
+              () => this.relayAcceptedFrame(actor, payload, header, undefined, heldMessage)
             );
             if (result.status !== ZLinkSubmitStatus.Submitted) {
               this.traceHeldDrop(
@@ -116,11 +110,8 @@ export class ZLinkBoundActorRelaySender {
     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)
     );
   }
 
@@ -150,7 +141,6 @@ export class ZLinkBoundActorRelaySender {
   private async relayAcceptedFrame(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     header?: ZLinkStreamFrameHeader,
     requestAdmission?: { beginSubmission(signal?: AbortSignal): Promise<void> | undefined },
     acceptedPayload?: Message
@@ -160,7 +150,6 @@ export class ZLinkBoundActorRelaySender {
       const completion = this.relayInsideLifecycle(
         actor,
         payload,
-        signal,
         activeHeader,
         requestAdmission,
         acceptedPayload
@@ -207,20 +196,18 @@ export class ZLinkBoundActorRelaySender {
   private async relayInsideLifecycle(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal: AbortSignal | undefined,
     currentHeader?: ZLinkStreamFrameHeader,
     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 =
       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 };
         }
@@ -234,11 +221,10 @@ 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();

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

@@ -129,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();
     }

package/src/runtime/streams/index.ts

@@ -87,7 +87,6 @@ import {
   type ZLinkStreamSessionRuntimeOptions as ZLinkStreamSessionRuntimeCoreOptions
 } from './stream-session-runtime';
 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';
 export { zlinkStreamLz4CompressionCodec } from './stream-frame-factory';
@@ -139,8 +138,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;
@@ -306,6 +304,9 @@ export class ZLinkStreamRuntimeManager {
       const readablePoller = streamAdapter.createReadablePoller(socket);
       const runtime = new ZLinkStreamSessionNodeRuntimeCore({
         nodeName,
+        heartbeatIntervalMs: streamNode.heartbeatIntervalMs,
+        heartbeatTimeoutMs: streamNode.heartbeatTimeoutMs,
+        idleTimeoutMs: streamNode.idleTimeoutMs,
         socket,
         createPacket: () => streamAdapter.createStreamPacket(),
         readablePoller,
@@ -758,10 +759,9 @@ export class ZLinkStreamBindingRuntime {
   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> {

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

@@ -130,14 +130,9 @@ 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 (isZLinkBackendResultError(error) && error.operation === 'submit') {
@@ -147,12 +142,7 @@ export class ZLinkManagedStream implements ZLinkStream {
     }
   }
 
-  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 };

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,19 +142,16 @@ 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();
     let nativeAttempted = false;
@@ -166,8 +160,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
         this.options.actorId,
         this.message,
         packetName,
-        this.selectedMetadata,
-        signal
+        this.selectedMetadata
       );
       if (result.status !== ZLinkSubmitStatus.TargetNotFound) {
         this.traceSubmitted(result, packetName);
@@ -188,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);
@@ -234,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;
@@ -251,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);
@@ -272,8 +262,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
         actorRef,
         this.message,
         packetName,
-        this.selectedMetadata,
-        signal
+        this.selectedMetadata
       );
       this.traceSubmitted(result, packetName);
       return result;
@@ -289,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

@@ -175,19 +175,6 @@ export function decodeStreamHeader(header: Uint8Array, flowEnabled = true): ZLin
   const decoded = decodeStreamWireHeader(header, undefined, flowEnabled);
   const kind = decoded.kind as ZLinkStreamMessageKind;
   const flags = decoded.flags as ZLinkStreamHeaderFlags;
-  const hasRequestSeq = (flags & ZLinkStreamHeaderFlags.HasRequestSeq) !== 0;
-  const hasMetadata = (flags & ZLinkStreamHeaderFlags.HasMetadata) !== 0;
-  const hasCorrelation = (flags & ZLinkStreamHeaderFlags.HasCorrelationId) !== 0;
-  const hasFlow = (flags & ZLinkStreamHeaderFlags.HasFlowId) !== 0;
-  const hasActorSlot = (flags & ZLinkStreamHeaderFlags.HasActorSlot) !== 0;
-  if (
-    kind === ZLinkStreamMessageKind.Control &&
-    (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)
-  ) {
-    throw new Error(
-      'Control packet must not contain a request sequence, metadata, correlation id, or flow id.'
-    );
-  }
   const metadata = publicStreamMetadata(decoded.metadata);
   return {
     kind,

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

@@ -4,9 +4,6 @@ import type {
   ZLinkSessionSendCall
 } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import { ZLINK_MAX_SEND_TIMEOUT_MS } from '../../contracts/Configuration/SendTimeoutValidation';
-import { throwIfAborted } from '../abort';
-import { ZLinkConfigurationException } from '../configuration';
 import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import { type ZLinkSubmitResult, requireOneWayCompletion } from '../messaging/submission-result';
 
@@ -23,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(
@@ -88,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,
@@ -112,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(
@@ -135,21 +124,10 @@ export class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
     return this;
   }
 
-  timeout(timeoutMs: number): this {
-    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > ZLINK_MAX_SEND_TIMEOUT_MS) {
-      throw new ZLinkConfigurationException(
-        `STREAM session send timeout must be an integer from 1 through ${ZLINK_MAX_SEND_TIMEOUT_MS} 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,
@@ -159,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 {
@@ -182,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;
@@ -190,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,
@@ -202,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,

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

@@ -33,7 +33,6 @@ import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import { type ZLinkSubmitResult, requireOneWayCompletion } from '../messaging/submission-result';
 
 import {
-  messageToBytes,
   ZLinkStreamHeaderFlags,
   ZLinkStreamMessageKind,
   type ZLinkStreamFrameHeader,
@@ -45,11 +44,10 @@ import {
   DefaultZLinkSessionSendCall
 } from './session-calls';
 import { ZLinkSessionLocalActorBindings } from './session-local-actors';
-import { ZLinkSessionRequestTracker, type ZLinkPendingSessionRequest } from './session-requests';
 
 export interface ZLinkSessionContextStream extends ZLinkStream {
   writeRaw(payload: Message, flags?: number): boolean;
-  submitRaw(payload: Message, signal?: AbortSignal, timeoutMs?: number): Promise<ZLinkSubmitResult>;
+  submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
   enqueueActorBound?(actorSlot: number, actorId: string): Promise<void>;
   enqueueActorUnbound?(actorSlot: number): Promise<void>;
 }
@@ -88,7 +86,6 @@ interface ZLinkSessionContextRuntime {
   relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     dispatchHeader?: ZLinkStreamFrameHeader
   ): Promise<ZLinkSubmitResult>;
   notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void>;
@@ -120,7 +117,6 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
   private readonly handlerRegistry: DefaultZLinkSessionHandlerRegistry;
   readonly handlers: ZLinkSessionHandlerRegistry;
   private readonly localActors = new ZLinkSessionLocalActorBindings<DefaultZLinkSessionActor>();
-  private readonly requests = new ZLinkSessionRequestTracker();
   private currentDispatchHeader: ZLinkStreamFrameHeader | undefined;
   private currentReplyClaimed = false;
   private actorBindingReplacementHandler?: ZLinkActorBindingReplacementHandler;
@@ -319,23 +315,6 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
     this.currentReplyClaimed = true;
   }
 
-  startRequest(timeoutMs?: number): ZLinkPendingSessionRequest {
-    return this.requests.start(timeoutMs);
-  }
-
-  tryCompleteResponse(header: ZLinkStreamFrameHeader, payload: Message): boolean {
-    if (header.requestSeq === undefined) {
-      return false;
-    }
-    if (header.kind === ZLinkStreamMessageKind.Response) {
-      return this.requests.complete(header.requestSeq, payload);
-    }
-    if (header.kind === ZLinkStreamMessageKind.Error) {
-      return this.requests.fail(header.requestSeq, decodeStreamErrorPayload(payload));
-    }
-    return false;
-  }
-
   payloadForHeader(header: ZLinkStreamFrameHeader, payload: Message): Message {
     if ((header.flags & ZLinkStreamHeaderFlags.PayloadCompressed) === 0) {
       return payload;
@@ -538,30 +517,22 @@ export class DefaultZLinkSessionActor implements ZLinkSessionActor {
     this.currentRef = ref;
   }
 
-  async relay(payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
-  async relay(
-    dispatch: ZLinkSessionDispatchContext,
-    payload: ZLinkMessage,
-    signal?: AbortSignal
-  ): Promise<void>;
+  async relay(payload: ZLinkMessage): Promise<void>;
+  async relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage): Promise<void>;
   async relay(
     dispatchOrPayload: ZLinkSessionDispatchContext | ZLinkMessage,
-    payloadOrSignal?: ZLinkMessage | AbortSignal,
-    signal?: AbortSignal
+    selectedPayload?: ZLinkMessage
   ): Promise<void> {
     const dispatch = isSessionDispatchContext(dispatchOrPayload) ? dispatchOrPayload : undefined;
     let payload: ZLinkMessage;
-    let relaySignal: AbortSignal | undefined;
     let header: ZLinkStreamFrameHeader | undefined;
     if (dispatch === undefined) {
       payload = dispatchOrPayload as ZLinkMessage;
-      relaySignal = payloadOrSignal as AbortSignal | undefined;
     } else {
-      payload = payloadOrSignal as ZLinkMessage;
-      relaySignal = signal;
+      payload = selectedPayload as ZLinkMessage;
       header = sessionDispatchHeader(dispatch);
     }
-    const result = await this.runtime.relay(this, payload, relaySignal, header);
+    const result = await this.runtime.relay(this, payload, header);
     requireOneWayCompletion(
       result,
       'Session Actor relay',
@@ -632,18 +603,6 @@ export class DefaultZLinkBoundSessionFactory implements ZLinkBoundSessionFactory
   }
 }
 
-function decodeStreamErrorPayload(payload: Message): Error {
-  try {
-    const value = JSON.parse(Buffer.from(messageToBytes(payload)).toString()) as {
-      readonly code?: unknown;
-      readonly message?: unknown;
-    };
-    return new Error(typeof value.message === 'string' ? value.message : 'Stream request failed.');
-  } catch {
-    return new Error('Stream request failed.');
-  }
-}
-
 function sameRetiredSession(
   left: ServiceRetiredBoundSessionRouteFence,
   right: ServiceRetiredBoundSessionRouteFence

package/src/runtime/streams/session-serial-executor.ts

@@ -36,14 +36,6 @@ export class ZLinkSessionSerialExecutor {
     return this.submit(work, 'lifecycle', options, onRejected);
   }
 
-  executeInfrastructure(
-    work: () => Promise<void>,
-    options: Omit<ZLinkSerialWorkOptions, 'lane'> = {},
-    onRejected?: (error?: unknown) => void
-  ): boolean {
-    return this.submit(work, 'lifecycle', options, onRejected);
-  }
-
   executeFinal(work: () => Promise<void>): Promise<void> {
     if (this.closed) {
       return Promise.reject(

package/src/runtime/streams/stream-message-utils.ts

@@ -1,35 +1,9 @@
 import type { Message } from '../../contracts/Common/Message';
 import { parseFrameworkJsonV1 } from '../messaging/framework-json-v1';
-import { utf8Decode, utf8Encode } from './protocol';
+import { utf8Decode } from './protocol';
 
 const EMPTY_MESSAGE_BYTES = new Uint8Array(0);
 
-export function copyMessage(message: Message): Message {
-  const value = message as unknown as {
-    copy?: () => Message;
-    toBytes?: () => Uint8Array;
-    data?: () => Uint8Array;
-    bytes?: Uint8Array;
-    getString?: () => string;
-  };
-  if (value.copy !== undefined) {
-    return value.copy();
-  }
-  if (value.toBytes !== undefined) {
-    return simpleMessage(value.toBytes()) as Message;
-  }
-  if (value.data !== undefined) {
-    return simpleMessage(value.data()) as Message;
-  }
-  if (value.bytes !== undefined) {
-    return simpleMessage(value.bytes) as Message;
-  }
-  if (value.getString !== undefined) {
-    return simpleMessage(utf8Encode(value.getString())) as Message;
-  }
-  throw new Error('Stream response payload cannot be copied.');
-}
-
 export function simpleMessage(bytes: Uint8Array): unknown {
   return createSimpleMessage(new Uint8Array(bytes), false);
 }