@zlink-systems/framework 0.27.0 → 0.29.0

package/dist/contracts/Actors/ZLinkActorClient.d.ts

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

package/dist/contracts/Channels/Calls.d.ts

@@ -2,7 +2,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 {
     metadata(key: string, value: string): this;

package/dist/contracts/Configuration/Builders.d.ts

@@ -78,7 +78,6 @@ export interface ZLinkMeshNodeSocketConfig {
     sendHighWaterMark: number;
     receiveHighWaterMark: number;
     receiveTimeoutMs?: number;
-    sendTimeoutMs?: number;
 }
 export interface ZLinkStreamSocketConfig {
     maxMessageSize: number;
@@ -143,6 +142,8 @@ export interface ZLinkFanoutChannelBuilder {
     subscriberConnections(): ZLinkEndpointConnections;
 }
 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/dist/contracts/Configuration/Configs.d.ts

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

package/dist/contracts/Configuration/InternalDefaults.d.ts

@@ -12,3 +12,6 @@ export declare const ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = 4096;
 export declare const AUTHORITY_ENVELOPE_MAX_BYTES: number;
 export declare const CREATION_INTENT_MAX_BYTES: number;
 export declare const CREATION_TERMINAL_ENVELOPE_MAX_BYTES: number;
+export declare const DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS = 1000;
+export declare const DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS = 5000;
+export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 0;

package/dist/contracts/Configuration/InternalDefaults.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CREATION_TERMINAL_ENVELOPE_MAX_BYTES = exports.CREATION_INTENT_MAX_BYTES = exports.AUTHORITY_ENVELOPE_MAX_BYTES = exports.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = exports.DEFAULT_WORKER_IDLE_TIMEOUT_MS = exports.DEFAULT_WORKER_MIN_THREADS = exports.DEFAULT_ACTIVATION_CONCURRENCY_LIMIT = exports.RELOCATION_STATE_CHUNK_DATA_MAX_BYTES = exports.DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE = void 0;
+exports.DEFAULT_STREAM_IDLE_TIMEOUT_MS = exports.DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS = exports.DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS = exports.CREATION_TERMINAL_ENVELOPE_MAX_BYTES = exports.CREATION_INTENT_MAX_BYTES = exports.AUTHORITY_ENVELOPE_MAX_BYTES = exports.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = exports.DEFAULT_WORKER_IDLE_TIMEOUT_MS = exports.DEFAULT_WORKER_MIN_THREADS = exports.DEFAULT_ACTIVATION_CONCURRENCY_LIMIT = exports.RELOCATION_STATE_CHUNK_DATA_MAX_BYTES = exports.DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE = void 0;
 exports.defaultWorkerMaxThreads = defaultWorkerMaxThreads;
 const os = __importStar(require("node:os"));
 /** Default complete header plus payload size accepted by a StreamNode. */
@@ -52,3 +52,6 @@ exports.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = 4096;
 exports.AUTHORITY_ENVELOPE_MAX_BYTES = 1024 * 1024;
 exports.CREATION_INTENT_MAX_BYTES = 1024 * 1024;
 exports.CREATION_TERMINAL_ENVELOPE_MAX_BYTES = 1024 * 1024;
+exports.DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS = 1_000;
+exports.DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS = 5_000;
+exports.DEFAULT_STREAM_IDLE_TIMEOUT_MS = 0;

package/dist/contracts/Configuration/RegistrationBuilders.js

@@ -522,6 +522,15 @@ class DefaultClientServerChannelServerBuilder {
 }
 class DefaultStreamNodeBuilder {
     streamNode;
+    setHeartbeat(intervalMs, timeoutMs) {
+        this.streamNode.heartbeatIntervalMs = intervalMs;
+        this.streamNode.heartbeatTimeoutMs = timeoutMs;
+        return this;
+    }
+    setIdleTimeout(timeoutMs) {
+        this.streamNode.idleTimeoutMs = timeoutMs;
+        return this;
+    }
     constructor(streamNode) {
         this.streamNode = streamNode;
     }

package/dist/contracts/Configuration/RegistrationNormalizers.d.ts

@@ -4,6 +4,7 @@ import type { ZLinkNetworkOptions } from './Builders';
 export declare function normalizeWorkerOptions(value: ZLinkFrameworkRegistrationOptions['worker']): ZLinkWorkerOptions | undefined;
 export declare function normalizeNetworkOptions(value: ZLinkFrameworkRegistrationOptions['network']): ZLinkNetworkOptions;
 export declare function toChannelMap(channels: ZLinkFrameworkRegistrationOptions['channels'], network: ZLinkNetworkOptions): Map<string, ZLinkChannelOptions>;
+export declare function normalizeStreamLiveness(options: ZLinkStreamNodeOptions): Required<Pick<ZLinkStreamNodeOptions, 'heartbeatIntervalMs' | 'heartbeatTimeoutMs' | 'idleTimeoutMs'>>;
 export declare function toStreamNodeMap(streamNodes: ZLinkFrameworkRegistrationOptions['streamNodes'], network: ZLinkNetworkOptions): Map<string, ZLinkStreamNodeOptions>;
 export declare function toRouteChannelOptions(options: ZLinkFrameworkRegistrationOptions): Map<string, ZLinkRouteChannelOptions>;
 export declare function requirePositiveInteger(label: string, value: number | undefined): void;

package/dist/contracts/Configuration/RegistrationNormalizers.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeWorkerOptions = normalizeWorkerOptions;
 exports.normalizeNetworkOptions = normalizeNetworkOptions;
 exports.toChannelMap = toChannelMap;
+exports.normalizeStreamLiveness = normalizeStreamLiveness;
 exports.toStreamNodeMap = toStreamNodeMap;
 exports.toRouteChannelOptions = toRouteChannelOptions;
 exports.requirePositiveInteger = requirePositiveInteger;
@@ -60,6 +61,20 @@ function toChannelMap(channels, network) {
         ];
     }));
 }
+function normalizeStreamLiveness(options) {
+    const heartbeatIntervalMs = options.heartbeatIntervalMs ?? InternalDefaults_1.DEFAULT_STREAM_HEARTBEAT_INTERVAL_MS;
+    const heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? InternalDefaults_1.DEFAULT_STREAM_HEARTBEAT_TIMEOUT_MS;
+    const idleTimeoutMs = options.idleTimeoutMs ?? InternalDefaults_1.DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+    if (!Number.isFinite(heartbeatIntervalMs) || heartbeatIntervalMs <= 0)
+        throw new ConfigurationException_1.ZLinkConfigurationException('STREAM heartbeat interval must be positive.');
+    if (!Number.isFinite(heartbeatTimeoutMs) || heartbeatTimeoutMs <= 0)
+        throw new ConfigurationException_1.ZLinkConfigurationException('STREAM heartbeat timeout must be positive.');
+    if (heartbeatTimeoutMs <= heartbeatIntervalMs)
+        throw new ConfigurationException_1.ZLinkConfigurationException('STREAM heartbeat timeout must be greater than interval.');
+    if (!Number.isFinite(idleTimeoutMs) || idleTimeoutMs < 0)
+        throw new ConfigurationException_1.ZLinkConfigurationException('STREAM idle timeout must not be negative.');
+    return { heartbeatIntervalMs, heartbeatTimeoutMs, idleTimeoutMs };
+}
 function toStreamNodeMap(streamNodes, network) {
     return new Map(Object.entries(streamNodes ?? {}).map(([name, streamNode]) => {
         const normalized = normalizeListener(streamNode, network);
@@ -67,6 +82,7 @@ function toStreamNodeMap(streamNodes, network) {
             name,
             {
                 ...normalized,
+                ...normalizeStreamLiveness(streamNode),
                 maxMessageSize: streamNode.maxMessageSize ?? InternalDefaults_1.DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE
             }
         ];

package/dist/contracts/Configuration/RegistrationTypes.d.ts

@@ -156,7 +156,6 @@ export interface ZLinkChannelOptions {
         readonly weight?: number;
         readonly sendHighWaterMark?: number;
         readonly receiveHighWaterMark?: number;
-        readonly sendTimeoutMs?: number;
         readonly maxMessageSize?: number;
     };
     readonly subscriber?: ZLinkClientCapabilityOptions;
@@ -165,7 +164,6 @@ export interface ZLinkClientCapabilityOptions {
     readonly manualConnections?: readonly string[];
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
     readonly maxMessageSize?: number;
 }
 export interface ZLinkPublisherCapabilityOptions {
@@ -184,7 +182,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[];
@@ -199,12 +196,14 @@ 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;
@@ -359,7 +358,6 @@ export interface ZLinkSpotRouterCapabilityOptions {
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
     readonly receiveTimeoutMs?: number;
-    readonly sendTimeoutMs?: number;
 }
 export interface ZLinkSpotRouterPeerConnectionOptions {
     readonly peerRid: RoutingId;

package/dist/contracts/Configuration/RegistrationValidators.js

@@ -457,10 +457,8 @@ function requireSocketOptions(label, options) {
     requireNonNegativeInteger(`${label} sendHighWaterMark`, options.sendHighWaterMark);
     requireNonNegativeInteger(`${label} receiveHighWaterMark`, options.receiveHighWaterMark);
     requireNonNegativeInteger(`${label} maxMessageSize`, options.maxMessageSize);
-    (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)(`${label} sendTimeoutMs`, options.sendTimeoutMs);
 }
 function requireRouteMeshSocketOptions(label, options) {
     requireNonNegativeInteger(`${label} sendHighWaterMark`, options.sendHighWaterMark);
     requireNonNegativeInteger(`${label} receiveHighWaterMark`, options.receiveHighWaterMark);
-    (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)(`${label} sendTimeoutMs`, options.sendTimeoutMs);
 }

package/dist/contracts/Spots/Contracts.d.ts

@@ -68,7 +68,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 {
     metadata(key: string, value: string): this;

package/dist/contracts/Streams/BoundSessionContracts.d.ts

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

package/dist/contracts/Streams/IZLinkSession.d.ts

@@ -36,10 +36,9 @@ 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/dist/contracts/Streams/IZLinkSessionActor.d.ts

@@ -9,7 +9,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/dist/runtime/actors/actor-client.js

@@ -28,24 +28,21 @@ class DefaultZLinkActorClient {
     }
     sendToActor(actorId, message) {
         requireActorId(actorId);
-        return new DefaultZLinkActorSendCall((packetName, metadata, signal) => this.send(actorId, packetName, message, metadata, signal), message);
+        return new DefaultZLinkActorSendCall((packetName, metadata) => this.send(actorId, packetName, message, metadata), message);
     }
     requestToActor(actorId, request) {
         requireActorId(actorId);
         return new DefaultZLinkActorRequestCall((packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'async'), (packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'yield'), actorId, request, this.options.defaultRequestTimeoutMs);
     }
-    async send(actorId, explicitPacketName, message, metadata, signal) {
-        (0, abort_1.throwIfAborted)(signal);
-        const route = await this.resolveActorRoute(actorId, signal);
+    async send(actorId, explicitPacketName, message, metadata) {
+        const route = await this.resolveActorRoute(actorId);
         const { meshName, actorRef: actor } = route;
         this.throwIfKnownStale(meshName, actor);
         const parts = this.createPacketParts(protocol_1.ZLinkStreamMessageKind.Send, undefined, explicitPacketName, message, metadata);
         const messageFollow = createActorMessageFollowContext(route, parts, false);
         const routedActor = (0, actor_message_follow_context_1.attachActorMessageFollowContext)(actor, messageFollow);
         try {
-            const submissionCopies = (await this.options
-                .transportDeliveryGate?.()
-                ?.waitBeforeSubmit(actorId, 'oneWay', signal)) ?? 1;
+            const submissionCopies = (await this.options.transportDeliveryGate?.()?.waitBeforeSubmit(actorId, 'oneWay')) ?? 1;
             const handoff = this.options.handoffCapture?.(meshName, actor.actorId, parts, false, routedActor);
             if (handoff !== undefined) {
                 const submissions = [handoff];
@@ -54,7 +51,7 @@ class DefaultZLinkActorClient {
                     if (duplicate !== undefined)
                         submissions.push(duplicate);
                 }
-                await (0, abort_1.awaitWithAbort)(Promise.all(submissions), signal);
+                await Promise.all(submissions);
                 return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
             }
             const node = this.requireNode(meshName);
@@ -370,10 +367,10 @@ class DefaultZLinkActorSendCall {
         this.selectedMetadata.set(key, value);
         return this;
     }
-    async submit(signal) {
+    async submit() {
         ensureSingleSubmit(this.executed);
         this.executed = true;
-        const result = await this.submitter(this.packet ?? (0, packet_name_1.resolveFrameworkPacketName)(this.message, undefined, 'Actor'), this.selectedMetadata, signal);
+        const result = await this.submitter(this.packet ?? (0, packet_name_1.resolveFrameworkPacketName)(this.message, undefined, 'Actor'), this.selectedMetadata);
         (0, submission_result_1.requireOneWayCompletion)(result, 'Actor send', framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound);
     }
 }

package/dist/runtime/actors/actor-mailbox.d.ts

@@ -1,9 +1,9 @@
-import { type ZLinkSerialSchedulerOptions, type ZLinkSerialWorkOptions } from '../execution/serial-execution-queue';
+import { ZLinkSerialExecutionQueue, type ZLinkSerialSchedulerOptions, type ZLinkSerialWorkOptions } from '../execution/serial-execution-queue';
 export declare class ZLinkActorSerialExecutor {
     private readonly actorId;
     private readonly sourceSpotId;
     private readonly scheduler;
-    constructor(actorId: string, sourceSpotId: unknown, options?: ZLinkSerialSchedulerOptions);
+    constructor(actorId: string, sourceSpotId: unknown, options?: ZLinkSerialSchedulerOptions, sharedOwner?: ZLinkSerialExecutionQueue);
     execute<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
     close(): Promise<void>;
     private runRecord;

package/dist/runtime/actors/actor-mailbox.js

@@ -8,10 +8,10 @@ class ZLinkActorSerialExecutor {
     actorId;
     sourceSpotId;
     scheduler;
-    constructor(actorId, sourceSpotId, options) {
+    constructor(actorId, sourceSpotId, options, sharedOwner) {
         this.actorId = actorId;
         this.sourceSpotId = sourceSpotId;
-        this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runRecord(record), options);
+        this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runRecord(record), options, sharedOwner);
     }
     execute(operation, workOptions) {
         const boundOperation = (0, application_job_queue_scope_1.bindApplicationJobPermit)(() => (0, actor_execution_context_1.runZLinkActorExecution)(this.actorId, this.sourceSpotId, operation));

package/dist/runtime/actors/actor-request-deadline.d.ts

@@ -1,3 +1 @@
-export declare function remainingActorRequestTimeout(actorId: string, deadlineMs: number | undefined): number | undefined;
-/** Only actual Store, delivery-gate, and handoff waits acquire a deadline handle. */
-export declare function waitActorReply<T>(reply: Promise<T>, actorId: string, deadlineMs: number | undefined, signal?: AbortSignal): Promise<T>;
+export { remainingRequestTimeout as remainingActorRequestTimeout, waitRequestReply as waitActorReply } from '../messaging/request-deadline';

package/dist/runtime/actors/actor-request-deadline.js

@@ -1,31 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remainingActorRequestTimeout = remainingActorRequestTimeout;
-exports.waitActorReply = waitActorReply;
-const abort_1 = require("../abort");
-const framework_errors_internal_1 = require("../framework-errors-internal");
-function remainingActorRequestTimeout(actorId, deadlineMs) {
-    if (deadlineMs === undefined)
-        return undefined;
-    const remaining = deadlineMs - performance.now();
-    if (remaining <= 0) {
-        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Actor request '${actorId}' exceeded its deadline.`);
-    }
-    return Math.max(1, Math.ceil(remaining));
-}
-/** Only actual Store, delivery-gate, and handoff waits acquire a deadline handle. */
-async function waitActorReply(reply, actorId, deadlineMs, signal) {
-    if (deadlineMs === undefined)
-        return await (0, abort_1.awaitWithAbort)(reply, signal);
-    let timer;
-    const timeout = new Promise((_resolve, reject) => {
-        const remaining = remainingActorRequestTimeout(actorId, deadlineMs);
-        timer = setTimeout(() => reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Actor request '${actorId}' exceeded its deadline.`)), remaining);
-    });
-    try {
-        return await (0, abort_1.awaitWithAbort)(Promise.race([reply, timeout]), signal);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
+exports.waitActorReply = exports.remainingActorRequestTimeout = void 0;
+var request_deadline_1 = require("../messaging/request-deadline");
+Object.defineProperty(exports, "remainingActorRequestTimeout", { enumerable: true, get: function () { return request_deadline_1.remainingRequestTimeout; } });
+Object.defineProperty(exports, "waitActorReply", { enumerable: true, get: function () { return request_deadline_1.waitRequestReply; } });

package/dist/runtime/actors/actor-routed-join-transport.d.ts

@@ -6,11 +6,10 @@ export interface ZLinkActorRoutedJoinTransport {
     canRouteChannel?(routerChannelId: string): boolean;
     canRoutePacketChannel?(routerChannelId: string): boolean;
     request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
-    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): Promise<ZLinkSubmitResult>;
+    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): Promise<ZLinkSubmitResult>;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
-        readonly signal?: AbortSignal;
     }): Promise<ZLinkSubmitResult>;
     requestRawToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;

package/dist/runtime/backend/contracts/index.d.ts

@@ -292,7 +292,6 @@ export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket
     sendHighWaterMark: number;
     receiveHighWaterMark: number;
     receiveTimeoutMs: number;
-    sendTimeoutMs: number;
     maxMessageSize: number;
     send(message: Message | readonly Message[]): Promise<void>;
     request(message: Message | readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
@@ -319,7 +318,6 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     sendHighWaterMark: number;
     receiveHighWaterMark: number;
     receiveTimeoutMs: number;
-    sendTimeoutMs: number;
     maxMessageSize: number;
     setRoutingId(routingId: RoutingId): void;
     recv(flags?: ZLinkBackendRecvFlags): Received | undefined;
@@ -354,14 +352,13 @@ export interface ZLinkBackendStreamPacket {
     close(): void;
 }
 export interface ZLinkBackendStreamSocket extends ZLinkBackendSocket {
-    readonly sendTimeoutMs: number;
     readonly sendHighWaterMark: number;
     /** Framework stream ingress uses this bound for packet payload validation. */
     maxMessageSize: number;
     setTlsServer(cert: string, key: string, requireClientCert?: boolean): void;
     recvPacket(packet: ZLinkBackendStreamPacket, flags?: ZLinkBackendRecvFlags): boolean;
     send(routingId: RoutingId, payload: Message | readonly Message[], flags: ZLinkBackendSendFlags): boolean;
-    submit(routingId: RoutingId, payload: Message | readonly Message[], timeoutMs?: number): Promise<void>;
+    submit(routingId: RoutingId, payload: Message | readonly Message[]): Promise<void>;
     disconnectPeer(routingId: RoutingId): void;
     bindActor(sessionRid: RoutingId, actor: ZLinkBackendActorRef, timeoutMs: number, signal?: AbortSignal): Promise<void>;
     unbindActor(sessionRid: RoutingId, actorId: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;

package/dist/runtime/backend/node/node-backend-adapter-support.d.ts

@@ -40,6 +40,8 @@ export declare function submitBindingReply(operation: ZLinkBindingReplyOperation
 export declare function submitBindingAsyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): Promise<void>;
 export declare function submitBindingSyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): void;
 export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined): Promise<readonly unknown[]>;
+export declare function bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, deadlineMs: number | undefined): Promise<import('@zlink-systems/zlink').Message[]>;
+export declare function closeBindingReply(replies: readonly import('@zlink-systems/zlink').Message[]): void;
 /**
  * Closes a binding handle once. An already closed or terminated handle counts as
  * closed. A busy close propagates to the caller.

package/dist/runtime/backend/node/node-backend-adapter-support.js

@@ -8,6 +8,8 @@ exports.submitBindingReply = submitBindingReply;
 exports.submitBindingAsyncSend = submitBindingAsyncSend;
 exports.submitBindingSyncSend = submitBindingSyncSend;
 exports.submitBindingRequest = submitBindingRequest;
+exports.bindingRequestReply = bindingRequestReply;
+exports.closeBindingReply = closeBindingReply;
 exports.closeBindingHandle = closeBindingHandle;
 exports.isContextTerminatedError = isContextTerminatedError;
 exports.disableSocketLinger = disableSocketLinger;
@@ -15,6 +17,7 @@ exports.toNativeRoutingId = toNativeRoutingId;
 exports.translateBindingResultError = translateBindingResultError;
 exports.toNativeActorRef = toNativeActorRef;
 const node_os_1 = require("node:os");
+const request_deadline_1 = require("../../messaging/request-deadline");
 const submission_result_1 = require("../../messaging/submission-result");
 const node_backend_adapter_1 = require("../node-backend-adapter");
 const runtime_values_1 = require("../runtime-values");
@@ -53,7 +56,7 @@ function submitBindingPublish(operation, payload) {
             translated.operation === 'submit' &&
             (translated.result === runtime_values_1.SubmitResult.Backpressured ||
                 translated.result === runtime_values_1.SubmitResult.NotAdmitted)) {
-            (0, submission_result_1.requireOneWayCompletion)({ status: submission_result_1.ZLinkSubmitStatus.Backpressured }, 'Classic fanout publish');
+            (0, submission_result_1.requireClassicFanoutCompletion)({ status: submission_result_1.ZLinkSubmitStatus.Backpressured }, 'Classic fanout publish');
         }
         throw translated;
     }
@@ -73,6 +76,7 @@ function submitBindingReply(operation, payload) {
     }
 }
 async function submitBindingAsyncSend(operation, payload) {
+    let submission;
     try {
         let current;
         const parts = Array.isArray(payload) ? payload : [payload];
@@ -81,10 +85,18 @@ async function submitBindingAsyncSend(operation, payload) {
             current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
         }
         current ??= operation.message(Buffer.alloc(0));
-        await current.submit().admitted;
+        submission = current.submit();
     }
     catch (error) {
-        throw translateBindingResultError(error);
+        throw translateBindingResultError(error, 'submit');
+    }
+    if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
+        try {
+            await submission.admitted;
+        }
+        catch (error) {
+            throw translateBindingResultError(error, 'completion');
+        }
     }
 }
 function submitBindingSyncSend(operation, payload) {
@@ -103,6 +115,7 @@ function submitBindingSyncSend(operation, payload) {
     }
 }
 async function submitBindingRequest(operation, payload, timeoutMs) {
+    const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     try {
         let current;
         if (Array.isArray(payload)) {
@@ -119,12 +132,30 @@ async function submitBindingRequest(operation, payload, timeoutMs) {
         if (timeoutMs !== undefined) {
             current = current.timeout(timeoutMs);
         }
-        return await current.submit().reply;
+        return await bindingRequestReply(current.submit(), deadlineMs);
     }
     catch (error) {
         throw translateBindingResultError(error);
     }
 }
+async function bindingRequestReply(submission, deadlineMs) {
+    const reply = submission.reply;
+    if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
+        try {
+            const [, replies] = await (0, request_deadline_1.waitRequestReply)(Promise.all([submission.admitted, reply]), 'Request', deadlineMs);
+            return replies;
+        }
+        catch (error) {
+            void reply.then(closeBindingReply, () => undefined);
+            throw error;
+        }
+    }
+    return reply;
+}
+function closeBindingReply(replies) {
+    for (const reply of replies)
+        reply.close();
+}
 /**
  * Closes a binding handle once. An already closed or terminated handle counts as
  * closed. A busy close propagates to the caller.

package/dist/runtime/backend/node/node-dealer-channel-client-transport.d.ts

@@ -6,7 +6,7 @@ export declare class ZLinkDealerChannelClientTransport implements ZLinkChannelCl
     private readonly dealer;
     private readonly publisher?;
     constructor(dealer: DealerSocket, publisher?: PubSocket | undefined);
-    send(channelName: string, packetName: string | undefined, message: Message, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    send(channelName: string, packetName: string | undefined, message: Message, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     request<TReply>(channelName: string, packetName: string | undefined, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: Message, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: Message, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;

package/dist/runtime/backend/node/node-dealer-channel-client-transport.js

@@ -16,8 +16,7 @@ class ZLinkDealerChannelClientTransport {
         this.dealer = dealer;
         this.publisher = publisher;
     }
-    async send(channelName, packetName, message, signal, metadata = EMPTY_METADATA) {
-        (0, abort_1.throwIfAborted)(signal);
+    async send(channelName, packetName, message, metadata = EMPTY_METADATA) {
         // Call-scoped flow (spec 27 §4): the envelope flow pair does not outlive
         // this outbound call.
         await (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.send(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, undefined, undefined, undefined, true, metadata)).submit().admitted);

package/dist/runtime/backend/node/node-raw-binding-port.js

@@ -204,15 +204,14 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         this.socket.options.setConnectRoutingId(bindingRoutingId(routingId));
         this.connect(endpoint);
     }
-    async send(targetRid, parts) {
+    send(targetRid, parts) {
         this.requireOpen();
-        const submission = appendSendParts(this.socket.send(bindingRoutingId(targetRid)), parts).submit();
-        if (submission.result === zlink_1.SubmitResult.Backpressured) {
-            await submission.admitted;
-        }
+        requireParts(parts);
+        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
     }
     async request(targetRid, parts, timeoutMs) {
         this.requireOpen();
+        const deadlineMs = performance.now() + timeoutMs;
         let submission;
         try {
             submission = appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
@@ -223,7 +222,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
         }
         try {
-            const replies = await requestReply(submission);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs);
             return copyAndClose(replies);
         }
         catch (error) {
@@ -257,15 +256,14 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         this.requireOpen();
         this.socket.setRoutingId(bindingRoutingId(routingId));
     }
-    async send(parts) {
+    send(parts) {
         this.requireOpen();
-        const submission = appendSendParts(this.socket.send(), parts).submit();
-        if (submission.result === zlink_1.SubmitResult.Backpressured) {
-            await submission.admitted;
-        }
+        requireParts(parts);
+        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(), parts);
     }
     async request(parts, timeoutMs) {
         this.requireOpen();
+        const deadlineMs = performance.now() + timeoutMs;
         let submission;
         try {
             submission = appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
@@ -274,7 +272,7 @@ class NodeRawDealerPort extends NodeRawSocketPort {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
         }
         try {
-            const replies = await requestReply(submission);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs);
             return copyAndClose(replies);
         }
         catch (error) {
@@ -286,13 +284,6 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         return receiveRecord(this.socket, dontWait);
     }
 }
-async function requestReply(submission) {
-    if (submission.result === zlink_1.SubmitResult.Backpressured) {
-        const [, replies] = await Promise.all([submission.admitted, submission.reply]);
-        return replies;
-    }
-    return submission.reply;
-}
 class NodeRawMonitorPort {
     monitor;
     release;
@@ -326,14 +317,6 @@ class NodeRawMonitorPort {
         this.release();
     }
 }
-function appendSendParts(operation, parts) {
-    requireParts(parts);
-    let next = operation.message(parts[0]);
-    for (let index = 1; index < parts.length; index += 1) {
-        next = next.message(parts[index]);
-    }
-    return next;
-}
 function appendRequestParts(operation, parts) {
     requireParts(parts);
     let next = operation.message(parts[0]);

package/dist/runtime/backend/node/node-raw-mesh-backend.js

@@ -147,12 +147,10 @@ class ZLinkNodeRawMeshBackend {
     selectObjectPlacement(stableType) {
         const runtime = this.requireRuntime();
         const localNodeRid = runtime.topology.localDescriptor().nodeRoutingId;
-        const status = runtime.topology.objectPlacementStatus(stableType, (candidate) => candidate.nodeRoutingId === localNodeRid ||
+        const { status, descriptor } = runtime.topology.selectObjectPlacementWithStatus(stableType, (candidate) => candidate.nodeRoutingId === localNodeRid ||
             runtime.isPeerRouteReady(candidate.nodeRoutingId));
         if (status !== 'available')
             return { kind: status };
-        const descriptor = runtime.topology.selectObjectPlacement(stableType, (candidate) => candidate.nodeRoutingId === localNodeRid ||
-            runtime.isPeerRouteReady(candidate.nodeRoutingId));
         return descriptor === undefined
             ? { kind: 'unavailable' }
             : {