@zlink-systems/framework 0.27.0 → 0.29.0

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

@@ -30,6 +30,9 @@ export interface ZLinkStreamSessionContextFactory {
     createSessionContext(stream: ZLinkManagedStream, close?: (signal?: AbortSignal) => Promise<void>, providerResolver?: ZLinkProviderResolver): DefaultZLinkSessionContext;
 }
 export interface ZLinkStreamSessionRuntimeOptions {
+    readonly heartbeatIntervalMs?: number;
+    readonly heartbeatTimeoutMs?: number;
+    readonly idleTimeoutMs?: number;
     readonly socket: ZLinkBackendStreamSocket;
     readonly nativeSessionService?: StreamSessionService;
     readonly meshCompletions?: ZLinkMeshCompletionTable;
@@ -66,8 +69,10 @@ export declare class ZLinkStreamSessionRuntime {
     private closeReason;
     private metricsClosed;
     private readonly livenessClock;
+    private readonly liveness;
     private lastApplicationActivityAt;
     private lastInboundFrameAt;
+    private lastHeartbeatPingAt;
     private livenessTimer;
     constructor(options: ZLinkStreamSessionRuntimeOptions & ZLinkStreamLivenessOptions, routingId: unknown, removeSession?: (sessionId: string, session: ZLinkStreamSessionRuntime) => void);
     get session(): Promise<ZLinkSession>;
@@ -79,8 +84,7 @@ export declare class ZLinkStreamSessionRuntime {
     enqueuePacket(payload: Message, decodedHeader: ZLinkStreamFrameHeader, terminalOwner?: ZLinkRetainedStreamOwner, applicationJobPermit?: ApplicationJobPermitPort): void;
     enqueueDisconnected(error?: unknown): void;
     /**
-     * Starts the callback on the session lane and observes its terminal result
-     * without retaining that lane while application code awaits unrelated work.
+     * Retains the session turn through the callback's terminal result.
      */
     enqueueActorBindingReplaced(actor: ServiceActorRef, retiredSession: ServiceRetiredBoundSessionRouteFence): void;
     close(signal?: AbortSignal): Promise<void>;
@@ -105,7 +109,6 @@ export declare class ZLinkStreamSessionRuntime {
     private queueDisconnect;
     private cleanup;
     private enqueueControl;
-    private enqueueInfrastructure;
     private enqueueApplication;
     /**
      * Spec 26 §2.1/§3.1: a frame discarded because the session serial lane is

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

@@ -19,19 +19,18 @@ const protocol_1 = require("./protocol");
 const session_context_1 = require("./session-context");
 const session_serial_executor_1 = require("./session-serial-executor");
 const stream_message_utils_1 = require("./stream-message-utils");
+const RegistrationNormalizers_1 = require("../../contracts/Configuration/RegistrationNormalizers");
 const ZLINK_SEND_DONT_WAIT = 1;
 const ZLINK_RECV_DONT_WAIT = 1;
-const ZLINK_STREAM_HEARTBEAT_INTERVAL_MS = 1_000;
-const ZLINK_STREAM_HEARTBEAT_TIMEOUT_MS = 5_000;
-const ZLINK_STREAM_APPLICATION_IDLE_TIMEOUT_MS = 30_000;
 const ZLINK_STREAM_RECEIVE_FRAME_BATCH_LIMIT = 64;
 const ZLINK_STREAM_ACTOR_BINDING_REPLACEMENT_CLOSE_DELAY_MS = 100;
 const ZLINK_STREAM_MONITOR_IDLE_MIN_DELAY_MS = 1;
 const ZLINK_STREAM_MONITOR_IDLE_MAX_DELAY_MS = 20;
 const ZLINK_STREAM_MONITOR_IDLE_MAX_STEPS = 7;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const systemLivenessClock = {
     now: () => performance.now(),
-    setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+    setTimer: (callback, delayMs) => setTimeout(callback, Math.min(delayMs, MAX_TIMER_DELAY_MS)),
     clearTimer: (timer) => clearTimeout(timer)
 };
 class ZLinkStreamReceiveWake {
@@ -69,12 +68,15 @@ class ZLinkStreamSessionRuntime {
     closeReason = 'client_close';
     metricsClosed = false;
     livenessClock;
+    liveness;
     lastApplicationActivityAt = 0;
     lastInboundFrameAt = 0;
+    lastHeartbeatPingAt = 0;
     livenessTimer;
     constructor(options, routingId, removeSession = () => { }) {
         this.options = options;
         this.removeSession = removeSession;
+        this.liveness = (0, RegistrationNormalizers_1.normalizeStreamLiveness)(options);
         this.livenessClock = options.livenessClock ?? systemLivenessClock;
         this.stream = new managed_stream_1.ZLinkManagedStream(options.socket, routingId, options.messageSerializers, options.nativeSessionService, options.meshCompletions, undefined, options.nativeSessionRouteForMesh);
         this.context = options.bindingRuntime.createSessionContext(this.stream, (signal) => this.close(signal), options.providerResolver);
@@ -112,7 +114,7 @@ class ZLinkStreamSessionRuntime {
         return this.sessionReady;
     }
     enqueueConnected(localAddr, remoteAddr) {
-        this.serial.executeInfrastructure(async () => this.markConnected(localAddr, remoteAddr));
+        this.serial.executeControl(async () => this.markConnected(localAddr, remoteAddr));
     }
     enqueuePacket(payload, decodedHeader, terminalOwner, applicationJobPermit) {
         this.lastInboundFrameAt = Math.max(this.lastInboundFrameAt, this.livenessClock.now());
@@ -124,41 +126,20 @@ class ZLinkStreamSessionRuntime {
             terminalOwner?.close();
         };
         if (decodedHeader.kind === protocol_1.ZLinkStreamMessageKind.Control) {
-            if ((0, protocol_1.messageToBytes)(payload).length === 0 &&
-                (decodedHeader.name === protocol_1.ZLINK_STREAM_HEARTBEAT_PONG ||
-                    decodedHeader.name === protocol_1.ZLINK_STREAM_HEARTBEAT_PING)) {
-                void this.handleControl(decodedHeader, payload)
-                    .catch((error) => {
-                    this.options.onError?.(error);
-                })
-                    .finally(() => {
-                    applicationJobPermit?.releaseAfterInternalProcessing();
-                    payload.close();
-                    releaseTerminal();
-                });
-                return;
-            }
-            this.enqueueControl(async () => {
-                try {
-                    const dispatch = () => this.dispatchPacket(payload, decodedHeader);
-                    if (applicationJobPermit === undefined)
-                        await dispatch();
-                    else
-                        await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, dispatch);
-                }
-                finally {
-                    releaseTerminal();
-                }
-            }, () => {
+            void this.handleControl(decodedHeader, payload)
+                .catch((error) => {
+                this.options.onError?.(error);
+            })
+                .finally(() => {
                 applicationJobPermit?.releaseAfterInternalProcessing();
                 payload.close();
                 releaseTerminal();
-            }, () => this.traceShutdownDrop(decodedHeader));
+            });
             return;
         }
         if (decodedHeader.kind === protocol_1.ZLinkStreamMessageKind.Response ||
             decodedHeader.kind === protocol_1.ZLinkStreamMessageKind.Error) {
-            this.enqueueInfrastructure(async () => {
+            this.enqueueControl(async () => {
                 try {
                     await this.dispatchPacket(payload, decodedHeader);
                 }
@@ -198,8 +179,7 @@ class ZLinkStreamSessionRuntime {
         this.queueDisconnect(error);
     }
     /**
-     * Starts the callback on the session lane and observes its terminal result
-     * without retaining that lane while application code awaits unrelated work.
+     * Retains the session turn through the callback's terminal result.
      */
     enqueueActorBindingReplaced(actor, retiredSession) {
         this.serial.executeControl(async () => {
@@ -209,7 +189,6 @@ class ZLinkStreamSessionRuntime {
                 return;
             const session = await this.requireSession();
             let callbackDeadlineTimer;
-            let callbackTerminal = false;
             let forcedClose = false;
             const scheduleClose = () => {
                 if (forcedClose)
@@ -223,25 +202,6 @@ class ZLinkStreamSessionRuntime {
                     void this.close().catch((error) => this.options.onError?.(error));
                 }, ZLINK_STREAM_ACTOR_BINDING_REPLACEMENT_CLOSE_DELAY_MS);
             };
-            const completeCallback = () => {
-                if (callbackTerminal)
-                    return;
-                callbackTerminal = true;
-                if (callbackDeadlineTimer !== undefined) {
-                    this.livenessClock.clearTimer(callbackDeadlineTimer);
-                    callbackDeadlineTimer = undefined;
-                }
-                scheduleClose();
-            };
-            const reportCallbackFailure = (error) => {
-                try {
-                    this.options.onError?.(error);
-                }
-                catch {
-                    // Diagnostics must not prevent the lifecycle terminal transition.
-                }
-                completeCallback();
-            };
             callbackDeadlineTimer = this.livenessClock.setTimer(() => {
                 if (this.disposed ||
                     this.disconnected ||
@@ -251,19 +211,17 @@ class ZLinkStreamSessionRuntime {
                 forcedClose = true;
                 void this.close().catch((error) => this.options.onError?.(error));
             }, this.options.replacementCallbackTimeoutMs ?? Registration_1.DEFAULT_SESSION_REPLACEMENT_CALLBACK_TIMEOUT_MS);
-            const callback = session.onActorBindingReplaced;
-            if (callback === undefined) {
-                completeCallback();
-                return;
-            }
             try {
-                // Start the callback on this lifecycle turn, but do not retain the
-                // serial lane while application code awaits an unrelated operation.
-                const result = callback.call(session, this.context, actor.actorId);
-                void Promise.resolve(result).then(() => completeCallback(), reportCallbackFailure);
+                await session.onActorBindingReplaced?.(this.context, actor.actorId);
             }
             catch (error) {
-                reportCallbackFailure(error);
+                this.options.onError?.(error);
+            }
+            finally {
+                if (callbackDeadlineTimer !== undefined) {
+                    this.livenessClock.clearTimer(callbackDeadlineTimer);
+                }
+                scheduleClose();
             }
         });
     }
@@ -313,6 +271,7 @@ class ZLinkStreamSessionRuntime {
         this.connected = true;
         const connectedAt = this.livenessClock.now();
         this.lastApplicationActivityAt = connectedAt;
+        this.lastHeartbeatPingAt = connectedAt;
         this.lastInboundFrameAt = Math.max(this.lastInboundFrameAt, connectedAt);
         this.scheduleLivenessCheck();
         this.options.metrics?.change(runtime_metrics_1.METRIC_NAMES.StreamConnectionsActive, 1, { transport: 'tcp' });
@@ -324,15 +283,8 @@ class ZLinkStreamSessionRuntime {
         let dispatchPayload = payload;
         let enteredDispatch = false;
         try {
-            if (decodedHeader.kind === protocol_1.ZLinkStreamMessageKind.Control) {
-                await this.handleControl(decodedHeader, payload);
-                return;
-            }
             this.lastApplicationActivityAt = this.livenessClock.now();
             dispatchPayload = this.context.payloadForHeader(decodedHeader, payload);
-            if (this.context.tryCompleteResponse(decodedHeader, dispatchPayload)) {
-                return;
-            }
             const dispatchActor = this.context.actorForSlot(decodedHeader.actorSlot);
             if (decodedHeader.actorSlot !== undefined && dispatchActor === undefined) {
                 const staleFlowEnabled = this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true;
@@ -466,25 +418,33 @@ class ZLinkStreamSessionRuntime {
         if (this.disposed || this.disconnected || this.livenessTimer !== undefined) {
             return;
         }
+        const now = this.livenessClock.now();
+        const due = Math.min(this.lastHeartbeatPingAt + this.liveness.heartbeatIntervalMs, this.lastInboundFrameAt + this.liveness.heartbeatTimeoutMs, this.liveness.idleTimeoutMs > 0
+            ? this.lastApplicationActivityAt + this.liveness.idleTimeoutMs
+            : Infinity);
         this.livenessTimer = this.livenessClock.setTimer(() => {
             this.livenessTimer = undefined;
-            this.serial.executeInfrastructure(async () => this.runLivenessCheck(), {}, (error) => this.options.onError?.(error));
-        }, ZLINK_STREAM_HEARTBEAT_INTERVAL_MS);
+            void this.runLivenessCheck().catch((error) => this.options.onError?.(error));
+        }, Math.max(0, due - now));
     }
     async runLivenessCheck() {
         if (this.disposed || this.disconnected || !this.connected) {
             return;
         }
         const now = this.livenessClock.now();
-        if (now - this.lastApplicationActivityAt >= ZLINK_STREAM_APPLICATION_IDLE_TIMEOUT_MS) {
+        if (this.liveness.idleTimeoutMs > 0 &&
+            now - this.lastApplicationActivityAt >= this.liveness.idleTimeoutMs) {
             await this.closeForLiveness(protocol_1.ZLinkStreamCloseReasonCode.IdleTimeout, 'idle_timeout', 'Application idle timeout.');
             return;
         }
-        if (now - this.lastInboundFrameAt >= ZLINK_STREAM_HEARTBEAT_TIMEOUT_MS) {
+        if (now - this.lastInboundFrameAt >= this.liveness.heartbeatTimeoutMs) {
             await this.closeForLiveness(protocol_1.ZLinkStreamCloseReasonCode.HeartbeatTimeout, 'heartbeat_timeout', 'Heartbeat timeout.');
             return;
         }
-        await this.stream.writeControl(protocol_1.ZLINK_STREAM_HEARTBEAT_PING);
+        if (now - this.lastHeartbeatPingAt >= this.liveness.heartbeatIntervalMs) {
+            this.lastHeartbeatPingAt = now;
+            await this.stream.writeControl(protocol_1.ZLINK_STREAM_HEARTBEAT_PING);
+        }
         this.scheduleLivenessCheck();
     }
     async closeForLiveness(reason, closeReason, diagnostic) {
@@ -496,7 +456,9 @@ class ZLinkStreamSessionRuntime {
         this.closeReason = closeReason;
         this.stopLivenessChecks();
         await this.stream.closeForReason(reason, diagnostic);
-        await this.complete(undefined, true);
+        void this.serial
+            .executeFinal(async () => this.complete(undefined, true))
+            .catch((error) => this.options.onError?.(error));
     }
     stopLivenessChecks() {
         if (this.livenessTimer !== undefined) {
@@ -609,13 +571,6 @@ class ZLinkStreamSessionRuntime {
             onRejected?.();
         }
     }
-    enqueueInfrastructure(work, onRejected, onShutdownRejected) {
-        if (!this.serial.executeInfrastructure(work, {}, onRejected)) {
-            // The serial lane only refuses new work after dispose() closed it.
-            onShutdownRejected?.();
-            onRejected?.();
-        }
-    }
     enqueueApplication(work, onRejected, onShutdownRejected) {
         let claim;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.27.0",
-    "@zlink-systems/zlink": "1.14.0"
+    "@zlink-systems/stream-wire": "0.29.0",
+    "@zlink-systems/zlink": "1.17.0"
   }
 }

package/src/contracts/Actors/ZLinkActorClient.ts

@@ -7,7 +7,7 @@ export interface ZLinkActorClient {
 
 export interface ZLinkActorSendCall {
   metadata(key: string, value: string): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }
 
 export interface ZLinkActorRequestCall {

package/src/contracts/Channels/Calls.ts

@@ -3,7 +3,7 @@ import type { ZLinkMessageMetadata } from '../Common';
 export interface ZLinkSendCall {
   metadata(key: string, value: string): this;
   metadata(metadata: ZLinkMessageMetadata): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }
 
 export interface ZLinkRequestCall {

package/src/contracts/Configuration/Builders.ts

@@ -100,7 +100,6 @@ export interface ZLinkMeshNodeSocketConfig {
   sendHighWaterMark: number;
   receiveHighWaterMark: number;
   receiveTimeoutMs?: number;
-  sendTimeoutMs?: number;
 }
 
 export interface ZLinkStreamSocketConfig {
@@ -188,6 +187,8 @@ export interface ZLinkFanoutChannelBuilder {
 }
 
 export interface ZLinkStreamNodeBuilder {
+  setHeartbeat(intervalMs: number, timeoutMs: number): this;
+  setIdleTimeout(timeoutMs: number): this;
   bind(endpointOrPort?: string | number): this;
   setBindHost(bindHost: string): this;
   setAdvertiseHost(advertiseHost: string): this;

package/src/contracts/Configuration/Configs.ts

@@ -8,7 +8,6 @@ export interface ZLinkSocketConfig {
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
   receiveTimeoutMs?: number;
-  sendTimeoutMs?: number;
 }
 
 export interface ZLinkRouteConfig {

package/src/contracts/Configuration/InternalDefaults.ts

@@ -22,3 +22,7 @@ export const ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = 4096;
 export const AUTHORITY_ENVELOPE_MAX_BYTES = 1024 * 1024;
 export const CREATION_INTENT_MAX_BYTES = 1024 * 1024;
 export const CREATION_TERMINAL_ENVELOPE_MAX_BYTES = 1024 * 1024;
+
+export const DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS = 1_000;
+export const DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS = 5_000;
+export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 0;

package/src/contracts/Configuration/RegistrationBuilders.ts

@@ -689,6 +689,16 @@ class DefaultClientServerChannelServerBuilder implements ZLinkClientServerChanne
 }
 
 class DefaultStreamNodeBuilder implements ZLinkStreamNodeBuilder {
+  setHeartbeat(intervalMs: number, timeoutMs: number): this {
+    this.streamNode.heartbeatIntervalMs = intervalMs;
+    this.streamNode.heartbeatTimeoutMs = timeoutMs;
+    return this;
+  }
+  setIdleTimeout(timeoutMs: number): this {
+    this.streamNode.idleTimeoutMs = timeoutMs;
+    return this;
+  }
+
   constructor(private readonly streamNode: MutableStreamNodeOptions) {}
 
   bind(endpointOrPort: string | number = 0): this {
@@ -1586,7 +1596,6 @@ interface MutableServerCapabilityOptions {
   weight?: number;
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
-  sendTimeoutMs?: number;
   maxMessageSize?: number;
 }
 
@@ -1594,7 +1603,6 @@ interface MutableClientCapabilityOptions {
   manualConnections?: string[];
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
-  sendTimeoutMs?: number;
   maxMessageSize?: number;
 }
 
@@ -1607,6 +1615,9 @@ interface MutablePublisherCapabilityOptions {
 }
 
 interface MutableStreamNodeOptions {
+  heartbeatIntervalMs?: number;
+  heartbeatTimeoutMs?: number;
+  idleTimeoutMs?: number;
   bind?: string;
   bindHost?: string;
   advertiseHost?: string;
@@ -1690,7 +1701,6 @@ interface MutableSpotRouterCapabilityOptions {
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
   receiveTimeoutMs?: number;
-  sendTimeoutMs?: number;
 }
 
 interface MutableSpotPubSubCapabilityOptions {

package/src/contracts/Configuration/RegistrationNormalizers.ts

@@ -21,6 +21,9 @@ import { normalizeEndpoint, parseEndpointHostPort } from './EndpointNotation';
 import {
   defaultWorkerMaxThreads,
   DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE,
+  DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS,
+  DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS,
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   DEFAULT_WORKER_IDLE_TIMEOUT_MS,
   DEFAULT_WORKER_MIN_THREADS
 } from './InternalDefaults';
@@ -77,6 +80,27 @@ export function toChannelMap(
   );
 }
 
+export function normalizeStreamLiveness(
+  options: ZLinkStreamNodeOptions
+): Required<
+  Pick<ZLinkStreamNodeOptions, 'heartbeatIntervalMs' | 'heartbeatTimeoutMs' | 'idleTimeoutMs'>
+> {
+  const heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS;
+  const heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS;
+  const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+  if (!Number.isFinite(heartbeatIntervalMs) || heartbeatIntervalMs <= 0)
+    throw new ZLinkConfigurationException('STREAM heartbeat interval must be positive.');
+  if (!Number.isFinite(heartbeatTimeoutMs) || heartbeatTimeoutMs <= 0)
+    throw new ZLinkConfigurationException('STREAM heartbeat timeout must be positive.');
+  if (heartbeatTimeoutMs <= heartbeatIntervalMs)
+    throw new ZLinkConfigurationException(
+      'STREAM heartbeat timeout must be greater than interval.'
+    );
+  if (!Number.isFinite(idleTimeoutMs) || idleTimeoutMs < 0)
+    throw new ZLinkConfigurationException('STREAM idle timeout must not be negative.');
+  return { heartbeatIntervalMs, heartbeatTimeoutMs, idleTimeoutMs };
+}
+
 export function toStreamNodeMap(
   streamNodes: ZLinkFrameworkRegistrationOptions['streamNodes'],
   network: ZLinkNetworkOptions
@@ -88,6 +112,7 @@ export function toStreamNodeMap(
         name,
         {
           ...normalized,
+          ...normalizeStreamLiveness(streamNode),
           maxMessageSize: streamNode.maxMessageSize ?? DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE
         }
       ];

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -183,7 +183,6 @@ export interface ZLinkChannelOptions {
     readonly weight?: number;
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
     readonly maxMessageSize?: number;
   };
   readonly subscriber?: ZLinkClientCapabilityOptions;
@@ -193,7 +192,6 @@ export interface ZLinkClientCapabilityOptions {
   readonly manualConnections?: readonly string[];
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly sendTimeoutMs?: number;
   readonly maxMessageSize?: number;
 }
 
@@ -214,7 +212,6 @@ export interface ZLinkRouteMeshChannelOptions {
   readonly weight?: number;
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly sendTimeoutMs?: number;
   readonly sendHandlers?: readonly ZLinkRouteChannelSendHandlerRegistration[];
   readonly requestHandlers?: readonly ZLinkRouteChannelRequestHandlerRegistration[];
   readonly handlers?: readonly ZLinkRouteChannelHandlerOptions[];
@@ -230,13 +227,15 @@ export interface ZLinkRouteChannelOptions {
   readonly weight?: number;
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly sendTimeoutMs?: number;
   readonly sendHandlers?: readonly ZLinkRouteChannelSendHandlerRegistration[];
   readonly requestHandlers?: readonly ZLinkRouteChannelRequestHandlerRegistration[];
   readonly handlers?: readonly ZLinkRouteChannelHandlerOptions[];
 }
 
 export interface ZLinkStreamNodeOptions {
+  readonly heartbeatIntervalMs?: number;
+  readonly heartbeatTimeoutMs?: number;
+  readonly idleTimeoutMs?: number;
   readonly bind?: string;
   readonly bindHost?: string;
   readonly advertiseHost?: string;
@@ -430,7 +429,6 @@ export interface ZLinkSpotRouterCapabilityOptions {
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
   readonly receiveTimeoutMs?: number;
-  readonly sendTimeoutMs?: number;
 }
 
 export interface ZLinkSpotRouterPeerConnectionOptions {

package/src/contracts/Configuration/RegistrationValidators.ts

@@ -730,14 +730,12 @@ function requireSocketOptions(
   options: {
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
     readonly maxMessageSize?: number;
   }
 ): void {
   requireNonNegativeInteger(`${label} sendHighWaterMark`, options.sendHighWaterMark);
   requireNonNegativeInteger(`${label} receiveHighWaterMark`, options.receiveHighWaterMark);
   requireNonNegativeInteger(`${label} maxMessageSize`, options.maxMessageSize);
-  requireValidSendTimeoutMs(`${label} sendTimeoutMs`, options.sendTimeoutMs);
 }
 
 function requireRouteMeshSocketOptions(
@@ -745,10 +743,8 @@ function requireRouteMeshSocketOptions(
   options: {
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
   }
 ): void {
   requireNonNegativeInteger(`${label} sendHighWaterMark`, options.sendHighWaterMark);
   requireNonNegativeInteger(`${label} receiveHighWaterMark`, options.receiveHighWaterMark);
-  requireValidSendTimeoutMs(`${label} sendTimeoutMs`, options.sendTimeoutMs);
 }

package/src/contracts/Spots/Contracts.ts

@@ -96,7 +96,7 @@ export interface ZLinkSpotSendCall {
   instanceSpot(): this;
   instanceSpot(instanceSpotType: string): this;
   inMesh(meshName: string): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }
 
 export interface ZLinkSpotRequestCall {

package/src/contracts/Streams/BoundSessionContracts.ts

@@ -5,5 +5,5 @@ export interface ZLinkBoundSession {
 
 export interface ZLinkBoundSessionSendCall {
   metadata(key: string, value: string): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }

package/src/contracts/Streams/IZLinkSession.ts

@@ -42,11 +42,10 @@ export interface ZLinkSessionClient {
 export interface ZLinkSessionSendCall {
   metadata(key: string, value: string): this;
   compress(enabled?: boolean): this;
-  timeout(timeoutMs: number): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }
 
 export interface ZLinkSessionReplyCall {
   compress(enabled?: boolean): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }

package/src/contracts/Streams/IZLinkSessionActor.ts

@@ -11,11 +11,7 @@ export interface ZLinkSessionActors {
 export interface ZLinkSessionActor {
   readonly actorId: string;
   readonly ref: ActorRef;
-  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>;
 }

package/src/runtime/actors/actor-client.ts

@@ -13,7 +13,7 @@ import {
 
 import { ZLINK_MAX_ACTOR_ID_BYTES } from '../../contracts/Common/CoreTypes';
 import type { Message } from '../../contracts/Common/Message';
-import { awaitWithAbort, throwIfAborted } from '../abort';
+import { throwIfAborted } from '../abort';
 import {
   type ZLinkBackendActorRef,
   type ZLinkBackendMeshNode,
@@ -110,7 +110,7 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
   sendToActor(actorId: string, message: unknown): ZLinkActorSendCall {
     requireActorId(actorId);
     return new DefaultZLinkActorSendCall(
-      (packetName, metadata, signal) => this.send(actorId, packetName, message, metadata, signal),
+      (packetName, metadata) => this.send(actorId, packetName, message, metadata),
       message
     );
   }
@@ -132,11 +132,9 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
     actorId: string,
     explicitPacketName: string | undefined,
     message: unknown,
-    metadata: ReadonlyMap<string, string>,
-    signal?: AbortSignal
+    metadata: ReadonlyMap<string, string>
   ): Promise<ZLinkSubmitResult> {
-    throwIfAborted(signal);
-    const route = await this.resolveActorRoute(actorId, signal);
+    const route = await this.resolveActorRoute(actorId);
     const { meshName, actorRef: actor } = route;
     this.throwIfKnownStale(meshName, actor);
     const parts = this.createPacketParts(
@@ -150,9 +148,7 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
     const routedActor = attachActorMessageFollowContext(actor, messageFollow);
     try {
       const submissionCopies =
-        (await this.options
-          .transportDeliveryGate?.()
-          ?.waitBeforeSubmit(actorId, 'oneWay', signal)) ?? 1;
+        (await this.options.transportDeliveryGate?.()?.waitBeforeSubmit(actorId, 'oneWay')) ?? 1;
       const handoff = this.options.handoffCapture?.(
         meshName,
         actor.actorId,
@@ -172,7 +168,7 @@ export class DefaultZLinkActorClient implements ZLinkActorClient {
           );
           if (duplicate !== undefined) submissions.push(duplicate);
         }
-        await awaitWithAbort(Promise.all(submissions), signal);
+        await Promise.all(submissions);
         return { status: ZLinkSubmitStatus.Submitted };
       }
       const node = this.requireNode(meshName);
@@ -662,8 +658,7 @@ class DefaultZLinkActorSendCall implements ZLinkActorSendCall {
   constructor(
     private readonly submitter: (
       packetName: string | undefined,
-      metadata: ReadonlyMap<string, string>,
-      signal?: AbortSignal
+      metadata: ReadonlyMap<string, string>
     ) => Promise<ZLinkSubmitResult>,
     private readonly message: unknown
   ) {}
@@ -678,13 +673,12 @@ class DefaultZLinkActorSendCall implements ZLinkActorSendCall {
     return this;
   }
 
-  async submit(signal?: AbortSignal): Promise<void> {
+  async submit(): Promise<void> {
     ensureSingleSubmit(this.executed);
     this.executed = true;
     const result = await this.submitter(
       this.packet ?? resolveFrameworkPacketName(this.message, undefined, 'Actor'),
-      this.selectedMetadata,
-      signal
+      this.selectedMetadata
     );
     requireOneWayCompletion(
       result,