@zlink-systems/framework 0.27.0 → 0.28.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

@@ -139,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;
@@ -758,10 +757,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/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

@@ -49,7 +49,7 @@ import { ZLinkSessionRequestTracker, type ZLinkPendingSessionRequest } from './s
 
 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 +88,6 @@ interface ZLinkSessionContextRuntime {
   relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,
-    signal?: AbortSignal,
     dispatchHeader?: ZLinkStreamFrameHeader
   ): Promise<ZLinkSubmitResult>;
   notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void>;
@@ -538,30 +537,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',