@zlink-systems/framework 0.27.0 → 0.28.0

package/dist/runtime/messaging/submission-result.js

@@ -5,6 +5,7 @@ exports.submitToRequestResult = submitToRequestResult;
 exports.classifySubmitResult = classifySubmitResult;
 exports.requireOneWayCompletion = requireOneWayCompletion;
 exports.requirePublishCompletion = requirePublishCompletion;
+exports.requireClassicFanoutCompletion = requireClassicFanoutCompletion;
 exports.throwAlreadySubmitted = throwAlreadySubmitted;
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const contracts_1 = require("../../contracts");
@@ -18,7 +19,7 @@ var ZLinkSubmitStatus;
     ZLinkSubmitStatus["RouteNotConnected"] = "routeNotConnected";
     ZLinkSubmitStatus["Shutdown"] = "shutdown";
 })(ZLinkSubmitStatus || (exports.ZLinkSubmitStatus = ZLinkSubmitStatus = {}));
-/** Projects the Core submit result once; phase only determines capacity refusal meaning. */
+/** Projects immediate refusal and pending admission failure from their Core phase. */
 function submitToRequestResult(result, phase) {
     switch (result) {
         case runtime_values_1.SubmitResult.Ok:
@@ -28,7 +29,7 @@ function submitToRequestResult(result, phase) {
         case runtime_values_1.SubmitResult.NotConnected:
             return runtime_values_1.RequestResult.NotConnected;
         case runtime_values_1.SubmitResult.NotFound:
-            return runtime_values_1.RequestResult.NotFound;
+            return phase === 'submit' ? runtime_values_1.RequestResult.NotFound : runtime_values_1.RequestResult.NotConnected;
         case runtime_values_1.SubmitResult.NotAdmitted:
             return runtime_values_1.RequestResult.Rejected;
         case runtime_values_1.SubmitResult.InvalidHandle:
@@ -45,7 +46,7 @@ function submitToRequestResult(result, phase) {
             return runtime_values_1.RequestResult.InternalError;
     }
 }
-function classifySubmitResult(result, operation, phase = 'completion') {
+function classifySubmitResult(result, operation, phase = 'submit') {
     const terminal = submitToRequestResult(result, phase);
     switch (terminal) {
         case runtime_values_1.RequestResult.Ok:
@@ -67,8 +68,9 @@ function requireOneWayCompletion(result, operation, notFoundKind = framework_err
         case ZLinkSubmitStatus.Submitted:
             return;
         case ZLinkSubmitStatus.TimedOut:
-        case ZLinkSubmitStatus.Backpressured:
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `${operation} did not obtain admission before its deadline.`, true);
+        case ZLinkSubmitStatus.Backpressured:
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operation} has no admission wait token.`, true);
         case ZLinkSubmitStatus.TargetNotFound:
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(notFoundKind, `${operation} target was not found.`);
         case ZLinkSubmitStatus.RouteNotConnected:
@@ -80,6 +82,11 @@ function requireOneWayCompletion(result, operation, notFoundKind = framework_err
 function requirePublishCompletion(result, operation) {
     requireOneWayCompletion(result, operation);
 }
+function requireClassicFanoutCompletion(result, operation) {
+    requireOneWayCompletion(result.status === ZLinkSubmitStatus.Backpressured
+        ? { status: ZLinkSubmitStatus.TimedOut }
+        : result, operation);
+}
 function throwAlreadySubmitted(operation) {
     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.AlreadySubmitted, `${operation} has already been submitted.`);
 }

package/dist/runtime/spots/spot-outbound.d.ts

@@ -48,7 +48,7 @@ export interface ZLinkSpotAddressCallOptions {
  * activation. Public callers never handle an owner or generation fence.
  */
 export interface ZLinkSpotAddressTransport {
-    sendToSpotAddress(spotId: RoutingId, message: unknown, options: ZLinkSpotAddressCallOptions): Promise<ZLinkSubmitResult>;
+    sendToSpotAddress(spotId: RoutingId, message: unknown, options: Omit<ZLinkSpotAddressCallOptions, 'timeoutMs' | 'signal'>): Promise<ZLinkSubmitResult>;
     requestToSpotAddress<TReply = unknown>(spotId: RoutingId, request: unknown, options: ZLinkSpotAddressCallOptions): Promise<TReply>;
 }
 export interface ZLinkSpotRoutedTransport {
@@ -60,13 +60,11 @@ export interface ZLinkSpotRoutedTransport {
 export interface ZLinkSpotRoutedSendOptions {
     readonly instanceSpot?: boolean;
     readonly packetName?: string;
-    /** Internal end-to-end budget remaining for route admission. */
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
     readonly metadata?: ReadonlyMap<string, string>;
 }
 export interface ZLinkSpotRoutedRequestOptions extends ZLinkSpotRoutedSendOptions {
     readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
 }
 export interface ZLinkSpotHandleCallOptions {
     readonly metadata?: ReadonlyMap<string, string>;
@@ -75,5 +73,5 @@ export interface ZLinkSpotHandleCallOptions {
     readonly spotRouterChannelIdForMesh?: (meshName: string) => string;
     readonly sourceSpot?: ZLinkBackendSpot;
 }
-export declare function sendToSpotHandle(transport: ZLinkSpotRoutedTransport, spot: SpotHandle, message: unknown, options?: ZLinkSpotHandleCallOptions): Promise<ZLinkSubmitResult>;
+export declare function sendToSpotHandle(transport: ZLinkSpotRoutedTransport, spot: SpotHandle, message: unknown, options?: Omit<ZLinkSpotHandleCallOptions, 'timeoutMs' | 'signal'>): Promise<ZLinkSubmitResult>;
 export declare function requestToSpotHandle<TReply = unknown>(transport: ZLinkSpotRoutedTransport, spot: SpotHandle, request: unknown, options?: ZLinkSpotHandleCallOptions): Promise<TReply>;

package/dist/runtime/spots/spot-outbound.js

@@ -103,10 +103,10 @@ function createAddressedSpotSendCall(serial, transport, spotId, message, sourceS
             options.initialMeshName = requireAddressValue(meshName, 'Mesh name', CoreTypes_1.ZLINK_MAX_MESH_NAME_BYTES);
             return this;
         },
-        async submit(signal) {
+        async submit() {
             markSubmitted(options);
             const pending = startRequestOnSerial(serial, () => ({
-                pending: transport.sendToSpotAddress(spotId, message, freezeAddressCallOptions(options, signal, sourceSpotProvider?.()))
+                pending: transport.sendToSpotAddress(spotId, message, freezeAddressCallOptions(options, sourceSpotProvider?.()))
             }));
             const result = await (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending));
             (0, submission_result_1.requireOneWayCompletion)(result, 'Spot send', framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotRouteNotFound);
@@ -119,7 +119,11 @@ function createAddressedSpotRequestCall(serial, transport, spotId, request, sour
         markSubmitted(options);
         rejectSameSpotAsyncRequest(serial, spotId, waitPolicy);
         return startRequestOnSerial(serial, () => ({
-            pending: transport.requestToSpotAddress(spotId, request, freezeAddressCallOptions(options, signal, sourceSpotProvider?.()))
+            pending: transport.requestToSpotAddress(spotId, request, {
+                ...freezeAddressCallOptions(options, sourceSpotProvider?.()),
+                timeoutMs: options.timeoutMs,
+                signal
+            })
         }));
     };
     return {
@@ -200,14 +204,12 @@ function markSubmitted(options) {
     }
     options.submitted = true;
 }
-function freezeAddressCallOptions(options, signal, sourceSpot) {
+function freezeAddressCallOptions(options, sourceSpot) {
     return {
         ...(options.metadataPresent ? { metadata: new Map(options.metadata) } : {}),
         instanceSpot: options.instanceSpot,
         instanceSpotType: options.instanceSpotType,
         initialMeshName: options.initialMeshName,
-        timeoutMs: options.timeoutMs,
-        signal,
         sourceSpot
     };
 }
@@ -227,8 +229,8 @@ function wrapSendCall(serial, inner) {
                 inner.metadata(key);
             return this;
         },
-        async submit(signal) {
-            const result = await runInternalTransportStart(serial, () => inner.submit(signal));
+        async submit() {
+            const result = await runInternalTransportStart(serial, () => inner.submit());
             return result;
         }
     };
@@ -302,11 +304,10 @@ function wrapRoutedSpotSendCall(serial, transport, spot, message, spotRouterChan
             }
             return this;
         },
-        async submit(signal) {
+        async submit() {
             const pending = startRequestOnSerial(serial, () => ({
                 pending: sendToSpotHandle(transport, spot, message, {
                     metadata,
-                    signal,
                     spotRouterChannelIdForMesh,
                     sourceSpot: sourceSpotProvider?.()
                 })
@@ -376,19 +377,15 @@ async function sendToSpotHandle(transport, spot, message, options = {}) {
         if (options.sourceSpot !== undefined && transport.sendFromSpotToSpot !== undefined) {
             return transport.sendFromSpotToSpot(options.sourceSpot, target, message, {
                 packetName,
-                timeoutMs: options.timeoutMs,
-                signal: options.signal,
                 metadata: options.metadata
             });
         }
         return transport.sendToSpot(target, message, {
             packetName,
-            timeoutMs: options.timeoutMs,
-            signal: options.signal,
             metadata: options.metadata
         });
     };
-    return sendResolved(await requireSpotRef(spot, options.signal));
+    return sendResolved(await requireSpotRef(spot));
 }
 async function requestToSpotHandle(transport, spot, request, options = {}) {
     const packetName = (0, packet_name_1.resolveFrameworkPacketName)(request, undefined, 'SPOT');

package/dist/runtime/streams/bound-actor-relay-sender.d.ts

@@ -12,7 +12,7 @@ export interface ZLinkBoundActorRelaySenderOptions {
     readonly dispatchErrors?: ZLinkDispatchErrorReporter;
     readonly actorBindTimeoutMs?: number;
     readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
-    readonly relay?: (actor: ZLinkSessionActor, header: ZLinkStreamFrameHeader, payload: Message, signal?: AbortSignal) => Promise<boolean>;
+    readonly relay?: (actor: ZLinkSessionActor, header: ZLinkStreamFrameHeader, payload: Message) => Promise<boolean>;
     readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
 }
 export declare class ZLinkBoundActorRelaySender {
@@ -21,7 +21,7 @@ export declare class ZLinkBoundActorRelaySender {
     private readonly options;
     private readonly lifecycle;
     constructor(routes: ZLinkActorSessionBindingRegistry<DefaultZLinkSessionContext, DefaultZLinkSessionActor>, frameMessages: ZLinkStreamFrameMessageFactory, options?: ZLinkBoundActorRelaySenderOptions, lifecycle?: ZLinkActorSessionLifecycleCoordinator);
-    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, signal?: AbortSignal, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
+    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
     private traceHeldDrop;
     private relayAcceptedFrame;
     private currentHeader;

package/dist/runtime/streams/bound-actor-relay-sender.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkBoundActorRelaySender = exports.DEFAULT_RELAY_ACTOR_BIND_TIMEOUT_MS = void 0;
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
-const abort_1 = require("../abort");
 const diagnostics_1 = require("../diagnostics");
 const payload_codec_1 = require("../messaging/payload-codec");
 const submission_result_1 = require("../messaging/submission-result");
@@ -22,15 +21,15 @@ class ZLinkBoundActorRelaySender {
         this.options = options;
         this.lifecycle = lifecycle;
     }
-    async relay(actor, payload, signal, dispatchHeader) {
+    async relay(actor, payload, dispatchHeader) {
         const header = dispatchHeader === undefined
             ? await this.currentHeader(actor)
             : await this.requireDispatchHeader(actor, dispatchHeader);
         if (header.kind === protocol_1.ZLinkStreamMessageKind.Request && header.requestSeq !== undefined) {
             const operation = async () => {
-                const admission = await this.routes.beginAcceptedRequestFrameWhenReady(actor.actorId, actor.bindingToken, signal);
+                const admission = await this.routes.beginAcceptedRequestFrameWhenReady(actor.actorId, actor.bindingToken);
                 try {
-                    return await this.relayAcceptedFrame(actor, payload, signal, header, admission);
+                    return await this.relayAcceptedFrame(actor, payload, header, admission);
                 }
                 finally {
                     await admission.complete();
@@ -38,13 +37,12 @@ class ZLinkBoundActorRelaySender {
             };
             return await operation();
         }
-        (0, abort_1.throwIfAborted)(signal);
         const held = await this.routes.acceptOneWay(actor.actorId, actor.bindingToken, () => {
             let heldMessage = (0, payload_codec_1.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));
+                        const result = await this.routes.runAcceptedFrameWhenReady(actor.actorId, actor.bindingToken, () => this.relayAcceptedFrame(actor, payload, header, undefined, heldMessage));
                         if (result.status !== submission_result_1.ZLinkSubmitStatus.Submitted) {
                             this.traceHeldDrop(header, result.status === submission_result_1.ZLinkSubmitStatus.Backpressured ||
                                 result.status === submission_result_1.ZLinkSubmitStatus.TimedOut
@@ -69,7 +67,7 @@ class ZLinkBoundActorRelaySender {
         if (held) {
             return { status: submission_result_1.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));
     }
     traceHeldDrop(header, reason, error) {
         (0, diagnostics_1.flowIfEnabled)(this.options.dispatchErrors?.flow, ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, undefined, header.flowId)?.trace({
@@ -84,10 +82,10 @@ class ZLinkBoundActorRelaySender {
             ...(error instanceof Error ? { errorType: error.name, errorMessage: error.message } : {})
         });
     }
-    async relayAcceptedFrame(actor, payload, signal, header, requestAdmission, acceptedPayload) {
+    async relayAcceptedFrame(actor, payload, header, requestAdmission, acceptedPayload) {
         const activeHeader = header ?? (await this.currentHeader(actor));
         const started = await this.lifecycle.run(actor.actorId, async () => {
-            const completion = this.relayInsideLifecycle(actor, payload, signal, activeHeader, requestAdmission, acceptedPayload);
+            const completion = this.relayInsideLifecycle(actor, payload, activeHeader, requestAdmission, acceptedPayload);
             if (activeHeader.kind === protocol_1.ZLinkStreamMessageKind.Request &&
                 activeHeader.requestSeq !== undefined) {
                 // A routed REQUEST only needs this lane while its ordered submission
@@ -119,16 +117,15 @@ class ZLinkBoundActorRelaySender {
         }
         return header;
     }
-    async relayInsideLifecycle(actor, payload, signal, currentHeader, requestAdmission, acceptedPayload) {
+    async relayInsideLifecycle(actor, payload, currentHeader, requestAdmission, acceptedPayload) {
         const header = currentHeader ?? (await this.currentHeader(actor));
-        const held = requestAdmission?.beginSubmission(signal);
+        const held = requestAdmission?.beginSubmission();
         if (held !== undefined)
             await held;
-        (0, abort_1.throwIfAborted)(signal);
         const payloadMessage = acceptedPayload ?? (0, payload_codec_1.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: submission_result_1.ZLinkSubmitStatus.Submitted };
                 }
@@ -140,7 +137,10 @@ class ZLinkBoundActorRelaySender {
             const headerMessage = this.frameMessages.createBinaryMessage((0, protocol_1.encodeStreamHeader)(header));
             const framePayloadMessage = this.frameMessages.createBinaryMessage((0, protocol_1.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();

package/dist/runtime/streams/bound-session-service.js

@@ -47,7 +47,7 @@ class ZLinkBoundSessionService {
             if ((await this.routes.route(actorId))?.bindingToken !== route.bindingToken) {
                 return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
             }
-            return await route.context.stream.submitRaw(frame, signal);
+            return await route.context.stream.submitRaw(frame);
         }
         finally {
             frame.close();

package/dist/runtime/streams/index.d.ts

@@ -45,7 +45,7 @@ export interface ZLinkStreamBindingRuntimeOptions {
     readonly errorSink?: () => {
         reportRuntimeTaskException(taskName: string, error: unknown): void;
     } | undefined;
-    readonly relay?: (actor: ZLinkSessionActor, header: ZLinkStreamFrameHeader, payload: Message, signal?: AbortSignal) => Promise<boolean>;
+    readonly relay?: (actor: ZLinkSessionActor, header: ZLinkStreamFrameHeader, payload: Message) => Promise<boolean>;
     readonly notifyDisconnected?: (actor: ZLinkSessionActor, signal?: AbortSignal) => Promise<void>;
     readonly flowCreationEnabled?: () => boolean;
     readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
@@ -143,7 +143,7 @@ export declare class ZLinkStreamBindingRuntime {
     disconnectNativeBoundSession(node: ZLinkBackendActorSessionNode, actorRef: ActorRef, signal?: AbortSignal): Promise<void>;
     disconnectBoundSession(actorId: string, signal?: AbortSignal): Promise<void>;
     closeSessionBinding(actorId: string, expected: ZLinkSessionBindingIdentity, signal?: AbortSignal): Promise<void>;
-    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, signal?: AbortSignal, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
+    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
     notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void>;
     createTextMessage(payload: string): Message;
     createBinaryMessage(payload: Uint8Array): Message;

package/dist/runtime/streams/index.js

@@ -327,8 +327,8 @@ class ZLinkStreamBindingRuntime {
     async closeSessionBinding(actorId, expected, signal) {
         await this.boundSessions.closeSessionBinding(actorId, expected, signal);
     }
-    async relay(actor, payload, signal, dispatchHeader) {
-        return await this.boundActorRelay.relay(actor, payload, signal, dispatchHeader);
+    async relay(actor, payload, dispatchHeader) {
+        return await this.boundActorRelay.relay(actor, payload, dispatchHeader);
     }
     async notifyDisconnected(actor, signal) {
         await this.boundActorRelay.notifyDisconnected(actor, signal);

package/dist/runtime/streams/managed-stream.d.ts

@@ -37,8 +37,8 @@ export declare class ZLinkManagedStream implements ZLinkStream {
     get remoteAddr(): string | undefined;
     write(payload: ZLinkMessage, flags?: ZLinkBackendSendFlags): boolean;
     writeRaw(payload: Message, flags?: ZLinkBackendSendFlags): boolean;
-    submitRaw(payload: Message, signal?: AbortSignal, timeoutMs?: number): Promise<ZLinkSubmitResult>;
-    submitBoundActor(actorId: string, parts: readonly Message[], signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    submitRaw(payload: Message): Promise<ZLinkSubmitResult>;
+    submitBoundActor(actorId: string, parts: readonly Message[]): Promise<ZLinkSubmitResult>;
     close(signal?: AbortSignal): Promise<void>;
     closeForDrain(signal?: AbortSignal): Promise<void>;
     writeControl(name: string): Promise<void>;

package/dist/runtime/streams/managed-stream.js

@@ -75,10 +75,9 @@ class ZLinkManagedStream {
     writeRaw(payload, flags) {
         return this.socket.send(this.backendRoutingId(), payload, flags ?? 0);
     }
-    async submitRaw(payload, signal, timeoutMs) {
+    async submitRaw(payload) {
         try {
-            (0, abort_1.throwIfAborted)(signal);
-            await this.socket.submit(this.backendRoutingId(), payload, timeoutMs);
+            await this.socket.submit(this.backendRoutingId(), payload);
             return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
         }
         catch (error) {
@@ -88,8 +87,7 @@ class ZLinkManagedStream {
             throw error;
         }
     }
-    async submitBoundActor(actorId, parts, signal) {
-        (0, abort_1.throwIfAborted)(signal);
+    async submitBoundActor(actorId, parts) {
         return (await this.sendBoundActor(actorId, parts, ZLINK_SEND_DONT_WAIT))
             ? { status: submission_result_1.ZLinkSubmitStatus.Submitted }
             : { status: submission_result_1.ZLinkSubmitStatus.Backpressured };

package/dist/runtime/streams/native-fallback-bound-session.js

@@ -9,7 +9,6 @@ const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const bound_session_wire_1 = require("../actors/bound-session-wire");
 const actor_routed_json_request_1 = require("../actors/actor-routed-json-request");
 const protocol_1 = require("./protocol");
-const abort_1 = require("../abort");
 const packet_name_1 = require("../messaging/packet-name");
 const flow_context_1 = require("../diagnostics/flow-context");
 class ZLinkNativeFallbackBoundSession {
@@ -45,8 +44,7 @@ class ZLinkNativeFallbackBoundSession {
                 return;
             }
             await this.options.routedTransport.sendToSpot(target, payload, {
-                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
-                signal
+                packetName: actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET
             });
             return;
         }
@@ -80,28 +78,27 @@ class ZLinkNativeFallbackBoundSessionSendCall {
         this.selectedPacketName = packetName;
         return this;
     }
-    async submit(signal) {
+    async submit() {
         if (this.executed) {
             (0, submission_result_1.throwAlreadySubmitted)('Bound session send call');
         }
         const packetName = (0, packet_name_1.resolveFrameworkPacketName)(this.message, this.selectedPacketName, 'Bound session');
         this.executed = true;
-        (0, abort_1.throwIfAborted)(signal);
-        const result = await this.execute(packetName, signal);
+        const result = await this.execute(packetName);
         (0, submission_result_1.requireOneWayCompletion)(result, 'Bound session send', framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound);
     }
-    execute(packetName, signal) {
+    execute(packetName) {
         // 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 (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.executeScoped(packetName, signal));
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.executeScoped(packetName));
     }
-    async executeScoped(packetName, signal) {
+    async executeScoped(packetName) {
         const localActor = this.options.localActorProvider?.() === true;
         const remoteTarget = this.options.remoteBoundSessionTargetProvider();
         let nativeAttempted = false;
         if (localActor) {
-            const result = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
+            const result = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata);
             if (result.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                 this.traceSubmitted(result, packetName);
                 return result;
@@ -115,7 +112,7 @@ class ZLinkNativeFallbackBoundSessionSendCall {
             const bindingGeneration = currentBindingGeneration(actorRef);
             if (actorRef !== undefined && node !== undefined && bindingGeneration !== undefined) {
                 nativeAttempted = true;
-                const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata, signal);
+                const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata);
                 if (result.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                     this.traceSubmitted(result, packetName);
                     return result;
@@ -150,12 +147,12 @@ class ZLinkNativeFallbackBoundSessionSendCall {
                     targetNodeRid: remoteTarget.targetNodeRid,
                     spotId: remoteTarget.spotId,
                     spotKind: contracts_1.ZLinkSpotKind.Entry
-                }, payload, { packetName: actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, signal })
-                : await submit.call(this.options.routedTransport, remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, payload, signal);
+                }, payload, { packetName: actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET })
+                : await submit.call(this.options.routedTransport, remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, payload);
             this.traceSubmitted(result, packetName);
             return result;
         }
-        const localResult = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
+        const localResult = await this.options.runtime.submitLocalBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata);
         if (localResult.status !== submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
             this.traceSubmitted(localResult, packetName);
             return localResult;
@@ -167,14 +164,14 @@ class ZLinkNativeFallbackBoundSessionSendCall {
             actorRef !== undefined &&
             node !== undefined &&
             bindingGeneration !== undefined) {
-            const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata, signal);
+            const result = await this.options.runtime.sendNativeBoundSession(node, actorRef, this.message, packetName, this.selectedMetadata);
             this.traceSubmitted(result, packetName);
             return result;
         }
         if (localActor) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `No current session binding exists for actor '${this.options.actorId}'.`, true);
         }
-        const result = await this.options.runtime.sendBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata, signal);
+        const result = await this.options.runtime.sendBoundSession(this.options.actorId, this.message, packetName, this.selectedMetadata);
         this.traceSubmitted(result, packetName);
         return result;
     }

package/dist/runtime/streams/session-calls.d.ts

@@ -3,12 +3,12 @@ import type { Message } from '../../contracts/Common/Message';
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import { type ZLinkStreamFrameHeader, ZLinkStreamMessageKind, type ZLinkStreamReplyMessageKind } from './protocol';
 export interface ZLinkBoundSessionSendRuntime {
-    sendBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    sendBoundSession(actorId: string, message: unknown, packetName: string | undefined, 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(kind: ZLinkStreamMessageKind, packetName: string, metadata: ReadonlyMap<string, string>, compressed: boolean, requestSeq: bigint | undefined, payload: unknown, correlationId?: string): Message;
@@ -31,7 +31,7 @@ export declare class DefaultZLinkBoundSessionSendCall implements ZLinkBoundSessi
     constructor(runtime: ZLinkBoundSessionSendRuntime, actorId: string, message: unknown);
     metadata(key: string, value: string): this;
     packetName(packetName: string): this;
-    submit(signal?: AbortSignal): Promise<void>;
+    submit(): Promise<void>;
 }
 export declare class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
     private readonly context;
@@ -39,14 +39,12 @@ export declare class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall
     private selectedPacketName;
     private readonly selectedMetadata;
     private compressionEnabled;
-    private selectedTimeoutMs;
     private executed;
     constructor(context: ZLinkSessionCallContext, message: unknown);
     metadata(key: string, value: string): this;
     packetName(packetName: string): this;
     compress(enabled?: boolean): this;
-    timeout(timeoutMs: number): this;
-    submit(signal?: AbortSignal): Promise<void>;
+    submit(): Promise<void>;
 }
 export declare class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCall {
     private readonly context;
@@ -55,5 +53,5 @@ export declare class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCa
     private executed;
     constructor(context: ZLinkSessionCallContext, message: unknown);
     compress(enabled?: boolean): this;
-    submit(signal?: AbortSignal): Promise<void>;
+    submit(): Promise<void>;
 }

package/dist/runtime/streams/session-calls.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkSessionReplyCall = exports.DefaultZLinkSessionSendCall = exports.DefaultZLinkBoundSessionSendCall = void 0;
-const SendTimeoutValidation_1 = require("../../contracts/Configuration/SendTimeoutValidation");
-const abort_1 = require("../abort");
-const configuration_1 = require("../configuration");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const protocol_1 = require("./protocol");
@@ -27,12 +24,11 @@ class DefaultZLinkBoundSessionSendCall {
         this.selectedPacketName = packetName;
         return this;
     }
-    async submit(signal) {
+    async submit() {
         (0, protocol_1.ensureSingleSubmit)(this.executed);
         const packetName = (0, protocol_1.resolvePacketName)(this.message, this.selectedPacketName);
         this.executed = true;
-        (0, abort_1.throwIfAborted)(signal);
-        const result = await this.runtime.sendBoundSession(this.actorId, this.message, packetName, this.selectedMetadata, signal);
+        const result = await this.runtime.sendBoundSession(this.actorId, this.message, packetName, this.selectedMetadata);
         (0, submission_result_1.requireOneWayCompletion)(result, 'Bound session send', framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound);
     }
 }
@@ -43,7 +39,6 @@ class DefaultZLinkSessionSendCall {
     selectedPacketName;
     selectedMetadata = new Map();
     compressionEnabled = false;
-    selectedTimeoutMs;
     executed = false;
     constructor(context, message) {
         this.context = context;
@@ -61,21 +56,13 @@ class DefaultZLinkSessionSendCall {
         this.compressionEnabled = enabled;
         return this;
     }
-    timeout(timeoutMs) {
-        if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > SendTimeoutValidation_1.ZLINK_MAX_SEND_TIMEOUT_MS) {
-            throw new configuration_1.ZLinkConfigurationException(`STREAM session send timeout must be an integer from 1 through ${SendTimeoutValidation_1.ZLINK_MAX_SEND_TIMEOUT_MS} milliseconds.`);
-        }
-        this.selectedTimeoutMs = timeoutMs;
-        return this;
-    }
-    async submit(signal) {
+    async submit() {
         (0, protocol_1.ensureSingleSubmit)(this.executed);
         const packetName = (0, protocol_1.resolvePacketName)(this.message, this.selectedPacketName);
         this.executed = true;
-        (0, abort_1.throwIfAborted)(signal);
         const message = this.context.createJsonFrameMessage(protocol_1.ZLinkStreamMessageKind.Send, packetName, this.selectedMetadata, this.compressionEnabled, undefined, this.message);
         try {
-            const result = await this.context.stream.submitRaw(message, signal, this.selectedTimeoutMs);
+            const result = await this.context.stream.submitRaw(message);
             (0, submission_result_1.requireOneWayCompletion)(result, 'STREAM session send');
             this.context.traceFrameWritten?.(protocol_1.ZLinkStreamMessageKind.Send, packetName, undefined);
         }
@@ -98,7 +85,7 @@ class DefaultZLinkSessionReplyCall {
         this.compressionEnabled = enabled;
         return this;
     }
-    async submit(signal) {
+    async submit() {
         (0, protocol_1.ensureSingleSubmit)(this.executed);
         this.executed = true;
         const requestHeader = this.context.dispatchHeader;
@@ -106,13 +93,9 @@ class DefaultZLinkSessionReplyCall {
             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.
-        (0, abort_1.throwIfAborted)(signal);
         const message = this.context.createJsonReplyFrameMessage(requestHeader, protocol_1.ZLinkStreamMessageKind.Response, new Map(), this.compressionEnabled, this.message);
         try {
-            const result = await this.context.stream.submitRaw(message, signal);
+            const result = await this.context.stream.submitRaw(message);
             (0, submission_result_1.requireOneWayCompletion)(result, 'STREAM session reply');
             this.context.traceFrameWritten?.(protocol_1.ZLinkStreamMessageKind.Response, requestHeader.name, requestHeader.correlationId);
         }

package/dist/runtime/streams/session-context.d.ts

@@ -9,7 +9,7 @@ import { DefaultZLinkBoundSessionSendCall } from './session-calls';
 import { 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>;
 }
@@ -22,7 +22,7 @@ interface ZLinkSessionContextRuntime {
     decompressPayload(payload: Message): Message;
     bind(context: DefaultZLinkSessionContext, actor: ZLinkActor | ActorRef, signal?: AbortSignal): Promise<DefaultZLinkSessionActor>;
     bindOrGet(context: DefaultZLinkSessionContext, actorRef: ActorRef, signal?: AbortSignal): Promise<DefaultZLinkSessionActor>;
-    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, signal?: AbortSignal, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
+    relay(actor: DefaultZLinkSessionActor, payload: ZLinkMessage, dispatchHeader?: ZLinkStreamFrameHeader): Promise<ZLinkSubmitResult>;
     notifyDisconnected(actor: DefaultZLinkSessionActor, signal?: AbortSignal): Promise<void>;
 }
 export type ZLinkActorBindingReplacementHandler = (actor: ServiceActorRef, retiredSession: ServiceRetiredBoundSessionRouteFence) => void;
@@ -95,8 +95,8 @@ export declare class DefaultZLinkSessionActor implements ZLinkSessionActor {
     constructor(runtime: ZLinkSessionContextRuntime, ref: ActorRef, bindingToken: string);
     get ref(): ActorRef;
     updateRef(ref: ActorRef): void;
-    relay(payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
-    relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
+    relay(payload: ZLinkMessage): Promise<void>;
+    relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage): Promise<void>;
     notifyDisconnected(signal?: AbortSignal): Promise<void>;
 }
 export declare function createSessionDispatchContext(header: ZLinkStreamFrameHeader, actor?: DefaultZLinkSessionActor): ZLinkSessionDispatchContext;