@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/backend/node/node-raw-mesh-backend.d.ts

@@ -30,7 +30,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readonly channels;
     private readonly peerIntents;
     private completionHandler?;
-    private readonly routingId;
+    readonly routingId: string;
     private readonly lifecycleGeneration;
     private bindEndpoint?;
     private advertiseHost?;
@@ -80,7 +80,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
     instanceSpotPlacementTypes(): readonly string[];
     sendToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): MeshOperationId;
     setRoutingId(routingId: unknown): void;
     setBind(endpoint: string): void;
     setAdvertiseHost(host: string): void;
@@ -114,19 +114,25 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly endpoint: string;
     }[]): void;
     isObjectClientNodeDirectTarget(targetRid: unknown): boolean;
+    observePeerRoute(targetRid: unknown): import("../../foundation/durable-service-request").PeerRouteObservation;
+    hasPeerRouteOrConnectionIntent(targetRid: unknown, endpoint: string): boolean;
     isPeerRouteReady(targetRid: unknown, lifecycleGeneration?: bigint): boolean;
-    sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[]): SubmitResultValue | Promise<SubmitResultValue>;
     sendInfrastructureControl(targetRid: unknown, record: Uint8Array | readonly Uint8Array[]): Promise<SubmitResultValue>;
     sendInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[]): Promise<SubmitResultValue>;
     requestInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[], options?: {
         readonly timeoutMs?: number;
+        readonly signal?: AbortSignal;
+        readonly onSubmitted?: (signal: AbortSignal) => Promise<void>;
     }): Promise<readonly Uint8Array[]>;
     requestToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     status(): {
         state: MeshNodeRuntimeState;
@@ -196,7 +202,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
     forgetSpotRoute(spot: ServiceSpotRouteFence['spot'], authorityOwnerGeneration: bigint, storeVersion?: string): void;
     sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): Promise<SubmitResult>;
-    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): MeshOperationId;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean, onAdmitted?: () => void): MeshOperationId;
     actorLookup(actorId: string): {
         actor: ServiceActorRef;
         spotId: string;
@@ -226,17 +232,19 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     actorRequestToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], _flags?: number): Promise<SubmitResultValue>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     createStreamSessionService(stream: unknown): StreamSessionService;
     sendFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
-    requestFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs: number): MeshOperationId;
+    requestFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs: number, onAdmitted?: () => void): MeshOperationId;
     closeSpot(state: ServiceSpotState): boolean;
     publishFromSpot(state: ServiceSpotState, channelName: string, topic: string, parts: MessageLike | readonly MessageLike[]): Promise<void>;
     setSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkNodeRawMeshBackend = void 0;
 exports.requestFailureResult = requestFailureResult;
+const durable_service_request_1 = require("../../foundation/durable-service-request");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const zlink_1 = require("@zlink-systems/zlink");
 const node_crypto_1 = require("node:crypto");
@@ -168,8 +169,8 @@ class ZLinkNodeRawMeshBackend {
         const result = await this.requireStateful().sendToMissingInstanceSpotFrame(target, encodeMultipartApplicationFrame(parts), deadlineUnixMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata));
         return result;
     }
-    requestToMissingInstanceSpot(target, parts, deadlineUnixMs, sourceSpotId, metadata) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToMissingInstanceSpotFrame(target, encodeMultipartApplicationFrame(parts), deadlineUnixMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata)));
+    requestToMissingInstanceSpot(target, parts, deadlineUnixMs, sourceSpotId, metadata, onAdmitted) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToMissingInstanceSpotFrame(target, encodeMultipartApplicationFrame(parts), deadlineUnixMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), onAdmitted));
     }
     setRoutingId(routingId) {
         if (String(routingId) !== this.routingId) {
@@ -221,13 +222,7 @@ class ZLinkNodeRawMeshBackend {
                     }
                 }
             },
-            onPeerDisconnected: (nodeRoutingId, endpoint) => {
-                for (const [intentId, peer] of this.peerIntents) {
-                    if (peer.endpoint === endpoint &&
-                        (peer.nodeRoutingId === undefined || peer.nodeRoutingId === nodeRoutingId)) {
-                        this.peerIntents.delete(intentId);
-                    }
-                }
+            onPeerDisconnected: (_nodeRoutingId, endpoint) => {
                 for (const handler of this.peerDisconnectedHandlers)
                     handler(endpoint);
             }
@@ -379,13 +374,28 @@ class ZLinkNodeRawMeshBackend {
     isObjectClientNodeDirectTarget(targetRid) {
         return this.requireRuntime().isObjectClientNodeDirectTarget(String(targetRid));
     }
+    observePeerRoute(targetRid) {
+        return this.requireRuntime().observePeerRoute(String(targetRid));
+    }
+    hasPeerRouteOrConnectionIntent(targetRid, endpoint) {
+        const rid = String(targetRid);
+        if (this.requireRuntime().hasSelectedPeerRoute(rid))
+            return true;
+        for (const intent of this.peerIntents.values()) {
+            if (intent.nodeRoutingId === rid ||
+                (intent.nodeRoutingId === undefined && intent.endpoint === endpoint))
+                return true;
+        }
+        return false;
+    }
     isPeerRouteReady(targetRid, lifecycleGeneration) {
         return this.requireRuntime().isPeerRouteReady(String(targetRid), lifecycleGeneration);
     }
-    async sendToNode(targetRid, parts) {
-        return (await this.requireRuntime().sendToNode(String(targetRid), encodeMultipartApplicationFrame(parts)))
-            ? zlink_1.SubmitResult.Ok
-            : zlink_1.SubmitResult.NotConnected;
+    sendToNode(targetRid, parts) {
+        const submitted = this.requireRuntime().sendToNode(String(targetRid), encodeMultipartApplicationFrame(parts));
+        return submitted instanceof Promise
+            ? submitted.then(nodeSendResult)
+            : nodeSendResult(submitted);
     }
     async sendInfrastructureControl(targetRid, record) {
         return (await this.requireRuntime().sendService(String(targetRid), (Array.isArray(record) ? record : [record]).map((value) => Buffer.from(value))))
@@ -398,17 +408,17 @@ class ZLinkNodeRawMeshBackend {
             : zlink_1.SubmitResult.NotConnected;
     }
     async requestInfrastructureControlFrames(targetRid, frames, options) {
-        return await this.requireRuntime().requestService(String(targetRid), frames.map((frame) => Buffer.from(frame)), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
+        return (0, durable_service_request_1.requestDurableService)(this.requireRuntime(), String(targetRid), frames, performance.now() + (options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS), 'relocation control', options?.signal, options?.onSubmitted);
     }
     requestToNode(targetRid, parts, options) {
-        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
+        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted);
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.NodeRequest, pending.promise);
     }
     async sendToChannel(channelName, parts) {
         return this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts));
     }
     requestToChannel(channelName, parts, options) {
-        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
+        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted);
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.ChannelRequest, pending.promise);
     }
     status() {
@@ -666,8 +676,8 @@ class ZLinkNodeRawMeshBackend {
         const result = await this.requireStateful().sendToInstanceSpot(route, encodeMultipart(parts), sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), instanceIntent);
         return result;
     }
-    requestInstanceSpot(route, parts, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, sourceSpotId, metadata, instanceIntent = false) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToInstanceSpot(route, encodeMultipart(parts), timeoutMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), instanceIntent));
+    requestInstanceSpot(route, parts, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, sourceSpotId, metadata, instanceIntent = false, onAdmitted) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, this.requireStateful().requestToInstanceSpot(route, encodeMultipart(parts), timeoutMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), instanceIntent, onAdmitted));
     }
     actorLookup(actorId) {
         const actor = this.requireStateful().actor(actorId);
@@ -707,13 +717,13 @@ class ZLinkNodeRawMeshBackend {
         return this.requireStateful().sendToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts));
     }
     requestToActor(actor, parts, options) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS));
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(actor, this.peerGeneration(String(actor.nodeRid)), actor.generation, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, undefined, undefined, options?.onAdmitted));
     }
     async actorSendToActor(source, target, parts) {
         return (await this.requireStateful().sendToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), source));
     }
     actorRequestToActor(source, target, parts, options) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, source));
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, source, undefined, options?.onAdmitted));
     }
     async sendActorBoundSession(actor, expectedBindingGeneration, parts, _flags) {
         return (await this.requireStateful().sendBoundSession(actor, expectedBindingGeneration, encodeMultipart(parts)));
@@ -734,8 +744,8 @@ class ZLinkNodeRawMeshBackend {
     async sendFromSpot(source, target, parts) {
         return (await this.requireStateful().sendToSpot(source.ref.spotId, target, encodeMultipart(parts)));
     }
-    requestFromSpot(source, target, parts, timeoutMs) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.SpotRequest, this.requireStateful().requestToSpot(source.ref.spotId, target, encodeMultipart(parts), timeoutMs));
+    requestFromSpot(source, target, parts, timeoutMs, onAdmitted) {
+        return this.observeStateful(service_runtime_contracts_1.OperationKind.SpotRequest, this.requireStateful().requestToSpot(source.ref.spotId, target, encodeMultipart(parts), timeoutMs, onAdmitted));
     }
     closeSpot(state) {
         return this.requireStateful().registry.closeSpot(state.ref);
@@ -744,6 +754,8 @@ class ZLinkNodeRawMeshBackend {
         await this.requireStateful().publishLogicalMulticast(channelName, topic, encodeMultipart(parts), state.ref.spotId);
     }
     setSpotSubscription(state, channelName, topicFilter) {
+        if (!this.channels.has(channelName))
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.InvalidOperation, `Spot does not participate in subscription channel '${channelName}'.`);
         this.requireStateful().setSubscription(state, channelName, topicFilter);
     }
     unsetSpotSubscription(state, channelName, topicFilter) {
@@ -953,7 +965,7 @@ class RawServiceSpot {
         const routeFence = requireDirectSpotRouteFence(options?.routeFence, String(targetNodeRid), String(targetSpotId), targetSpotGeneration, options?.entrySpot === true
             ? this.backend.entrySpotRouteFence(String(targetNodeRid), String(targetSpotId))
             : undefined);
-        return this.backend.requestFromSpot(this.state, routeFence, parts, options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
+        return this.backend.requestFromSpot(this.state, routeFence, parts, options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted);
     }
     async publish(channelName, topic, parts, options) {
         this.requireOpen();
@@ -992,6 +1004,9 @@ class RawServiceSpot {
             throw new Error(`Spot '${this.routingId}' is closed.`);
     }
 }
+function nodeSendResult(submitted) {
+    return submitted ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+}
 function requireDirectSpotRouteFence(route, targetNodeRid, targetSpotId, targetSpotGeneration, entryRoute) {
     if (route === undefined && entryRoute !== undefined) {
         return entryRoute;
@@ -1073,7 +1088,7 @@ class RawStreamSessionService {
         if (target === undefined)
             return false;
         const operation = this.stream.send(target);
-        const parts = decodeMultipartBuffers((0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload).payload);
+        const parts = decodeMultipartParts((0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload).payload, borrowMultipartPart);
         if (parts.length === 0)
             return false;
         const actorSlot = await (0, service_session_binding_ingress_port_1.serviceSessionBindingIngressPortIfRegistered)(this)?.actorSlot(actorId, sessionRid);
@@ -1637,22 +1652,15 @@ function decodeApplicationEnvelope(frame) {
     return { packetName, contentType, payload: bytes.subarray(offset) };
 }
 function decodeMultipart(payload) {
-    const buffers = decodeMultipartBuffers(payload);
-    const parts = new Array(buffers.length);
-    let materialized = 0;
-    try {
-        for (; materialized < buffers.length; materialized += 1) {
-            parts[materialized] = runtime_message_1.ZLinkBufferMessage.fromOwned(buffers[materialized]);
-        }
-        return parts;
-    }
-    catch (error) {
-        for (let index = 0; index < materialized; index += 1)
-            parts[index].close();
-        throw error;
-    }
+    return decodeMultipartParts(payload, runtime_message_1.ZLinkBufferMessage.fromOwned, closeMultipartMessage);
+}
+function closeMultipartMessage(part) {
+    part.close();
 }
-function decodeMultipartBuffers(payload) {
+function borrowMultipartPart(part) {
+    return part;
+}
+function decodeMultipartParts(payload, materialize, release) {
     const bytes = Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);
     if (bytes.length < 4)
         throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart payload.');
@@ -1662,22 +1670,32 @@ function decodeMultipartBuffers(payload) {
     }
     const result = new Array(count);
     let offset = 4;
-    for (let index = 0; index < count; index++) {
-        if (bytes.length - offset < 4) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart part length.');
+    let index = 0;
+    try {
+        for (; index < count; index++) {
+            if (bytes.length - offset < 4) {
+                throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart part length.');
+            }
+            const length = bytes.readUInt32BE(offset);
+            offset += 4;
+            if (bytes.length - offset < length) {
+                throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart part.');
+            }
+            result[index] = materialize(bytes.subarray(offset, offset + length));
+            offset += length;
         }
-        const length = bytes.readUInt32BE(offset);
-        offset += 4;
-        if (bytes.length - offset < length) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Truncated multipart part.');
+        if (offset !== bytes.length) {
+            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Multipart payload has trailing bytes.');
         }
-        result[index] = bytes.subarray(offset, offset + length);
-        offset += length;
+        return result;
     }
-    if (offset !== bytes.length) {
-        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Multipart payload has trailing bytes.');
+    catch (error) {
+        if (release !== undefined) {
+            for (let retained = 0; retained < index; retained++)
+                release(result[retained]);
+        }
+        throw error;
     }
-    return result;
 }
 function messageBytesView(value) {
     if (typeof value === 'object' && 'data' in value) {

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

@@ -144,12 +144,12 @@ function wrapSocket(nativeInstance, pollCompletion) {
         },
         request(...args) {
             if (hasRoutedPeer) {
-                const [routingId, payload, timeoutMs] = args;
-                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.request((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload, timeoutMs);
+                const [routingId, payload, timeoutMs, onAdmitted] = args;
+                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.request((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload, timeoutMs, undefined, onAdmitted);
             }
             if (hasRequest) {
-                const [payload, timeoutMs] = args;
-                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.request(), payload, timeoutMs, adapter.receiveAdmission?.recordReceived);
+                const [payload, timeoutMs, onAdmitted] = args;
+                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.request(), payload, timeoutMs, adapter.receiveAdmission?.recordReceived, onAdmitted);
             }
             throw new TypeError('Backend request requires a DEALER or ROUTER socket.');
         },
@@ -201,8 +201,8 @@ function wrapSocket(nativeInstance, pollCompletion) {
             const operation = nativeInstance.sendToSpot((0, node_backend_adapter_support_1.toNativeRoutingId)(targetRid), (0, node_backend_adapter_support_1.toNativeRoutingId)(targetSpot));
             await (0, node_backend_adapter_support_1.submitBindingAsyncSend)(operation, payload);
         },
-        requestToSpot(targetRid, targetSpot, payload, timeoutMs) {
-            return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.requestToSpot((0, node_backend_adapter_support_1.toNativeRoutingId)(targetRid), (0, node_backend_adapter_support_1.toNativeRoutingId)(targetSpot)), payload, timeoutMs);
+        requestToSpot(targetRid, targetSpot, payload, timeoutMs, onAdmitted) {
+            return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.requestToSpot((0, node_backend_adapter_support_1.toNativeRoutingId)(targetRid), (0, node_backend_adapter_support_1.toNativeRoutingId)(targetSpot)), payload, timeoutMs, undefined, onAdmitted);
         },
         disconnectPeer(routingId) {
             disconnectStreamPeer(nativeInstance, routingId);

package/dist/runtime/backend/raw-binding-port.d.ts

@@ -56,7 +56,7 @@ export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
     setRoutingId(routingId: string): void;
     connectToRoutingId(routingId: string, endpoint: string): void;
     send(targetRid: string, parts: readonly Uint8Array[]): Promise<void>;
-    request(targetRid: string, parts: readonly Uint8Array[], timeoutMs: number, recordReceived?: () => void): Promise<readonly Buffer[]>;
+    request(targetRid: string, parts: readonly Uint8Array[], timeoutMs: number, recordReceived?: () => void, onAdmitted?: () => void): Promise<readonly Buffer[]>;
     receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
     /** The selected route of every RID. The socket's one route observer calls it. */
     routesSnapshot(): readonly ZLinkRawRouterRoute[];
@@ -64,7 +64,7 @@ export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
 export interface ZLinkRawDealerPort extends ZLinkRawSocketPort {
     setRoutingId(routingId: string): void;
     send(parts: readonly Uint8Array[]): Promise<void>;
-    request(parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
+    request(parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
     receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
 }
 export interface ZLinkRawHostPort {

package/dist/runtime/backend/runtime-message.d.ts

@@ -4,6 +4,7 @@ export declare class ZLinkBufferMessage implements Message {
     private constructor();
     static from(value: Message | Buffer | Uint8Array | string): ZLinkBufferMessage;
     static fromOwned(bytes: Buffer): ZLinkBufferMessage;
+    static retainPayload(message: Message): Buffer;
     data(): Buffer;
     toBytes(): Uint8Array;
     copy(): Message;

package/dist/runtime/backend/runtime-message.js

@@ -16,6 +16,11 @@ class ZLinkBufferMessage {
     static fromOwned(bytes) {
         return new ZLinkBufferMessage(bytes);
     }
+    static retainPayload(message) {
+        // Binding data() Buffers retain their storage after the message handle closes.
+        // Preserve that ownership at runtime boundaries without copying the payload.
+        return message.data();
+    }
     data() {
         return this.bytes;
     }

package/dist/runtime/backend/runtime-values.d.ts

@@ -36,6 +36,7 @@ export type SubmitResult = (typeof SubmitResult)[keyof typeof SubmitResult];
 export type ZLinkBackendSendFlags = number;
 export type ZLinkBackendRecvFlags = number;
 export declare const ZLINK_BACKEND_SEND_NONE: ZLinkBackendSendFlags;
+export declare const ZLINK_BACKEND_SEND_DONT_WAIT: ZLinkBackendSendFlags;
 export declare const ZLINK_BACKEND_RECV_DONT_WAIT: ZLinkBackendRecvFlags;
 export declare class ZLinkBackendResultError extends Error {
     readonly operation: 'request' | 'submit';

package/dist/runtime/backend/runtime-values.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkBackendResultError = exports.ZLINK_BACKEND_RECV_DONT_WAIT = exports.ZLINK_BACKEND_SEND_NONE = exports.SubmitResult = exports.RequestResult = void 0;
+exports.ZLinkBackendResultError = exports.ZLINK_BACKEND_RECV_DONT_WAIT = exports.ZLINK_BACKEND_SEND_DONT_WAIT = exports.ZLINK_BACKEND_SEND_NONE = exports.SubmitResult = exports.RequestResult = void 0;
 exports.isZLinkBackendResultError = isZLinkBackendResultError;
 exports.isBackendNotConnectedError = isBackendNotConnectedError;
 exports.isBackendRequestTimeoutError = isBackendRequestTimeoutError;
@@ -37,6 +37,7 @@ exports.SubmitResult = Object.freeze({
     NotAdmitted: 13
 });
 exports.ZLINK_BACKEND_SEND_NONE = 0;
+exports.ZLINK_BACKEND_SEND_DONT_WAIT = 1;
 exports.ZLINK_BACKEND_RECV_DONT_WAIT = 1;
 class ZLinkBackendResultError extends Error {
     operation;

package/dist/runtime/channels/channel-clients.d.ts

@@ -35,6 +35,7 @@ export declare class DefaultZLinkRouteClient implements ZLinkRouteClient {
     private readonly transport?;
     private readonly spotRouterChannelIdForMesh;
     private readonly channelTransport?;
+    private readonly nodeSends;
     constructor(registration: ZLinkFrameworkRegistration, transport?: ZLinkRouteClientTransport | undefined, spotRouterChannelIdForMesh?: (meshName: string) => string, channelTransport?: ZLinkChannelClientTransportSource | undefined);
     sendToNode(meshName: string, targetNodeRid: string, message: unknown): ZLinkSendCall;
     requestToNode(meshName: string, targetNodeRid: string, request: unknown): ZLinkRequestCall;

package/dist/runtime/channels/channel-clients.js

@@ -4,6 +4,7 @@ exports.DefaultZLinkSpotPublisherClient = exports.DefaultZLinkRouteClient = expo
 exports.resolveChannelRoute = resolveChannelRoute;
 exports.requireUniqueRouteMeshChannel = requireUniqueRouteMeshChannel;
 const Registration_1 = require("../../contracts/Configuration/Registration");
+const request_result_1 = require("../messaging/request-result");
 const configuration_1 = require("../configuration");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
@@ -79,6 +80,7 @@ class DefaultZLinkRouteClient {
     transport;
     spotRouterChannelIdForMesh;
     channelTransport;
+    nodeSends = new Map();
     constructor(registration, transport, spotRouterChannelIdForMesh = (meshName) => meshName, channelTransport) {
         this.registration = registration;
         this.transport = transport;
@@ -86,10 +88,23 @@ class DefaultZLinkRouteClient {
         this.channelTransport = channelTransport;
     }
     sendToNode(meshName, targetNodeRid, message) {
-        return new DefaultZLinkSendCall(() => this.requireMesh(meshName), async (packetName, metadata) => normalizeSubmitResult(await this.requireTransport().submit(meshName, targetNodeRid, packetName, message, metadata)));
+        let targets = this.nodeSends.get(meshName);
+        if (targets === undefined)
+            this.nodeSends.set(meshName, (targets = new Map()));
+        let prepared = targets.get(targetNodeRid);
+        if (prepared === undefined) {
+            prepared = {
+                validate: () => {
+                    this.requireMesh(meshName);
+                },
+                submit: (packetName, metadata, payload) => normalizeSubmitResult(this.requireTransport().submit(meshName, targetNodeRid, packetName, payload, metadata))
+            };
+            targets.set(targetNodeRid, prepared);
+        }
+        return new DefaultZLinkSendCall(prepared.validate, prepared.submit, message);
     }
     requestToNode(meshName, targetNodeRid, request) {
-        return new DefaultZLinkRequestCall(() => this.requireMesh(meshName), (packetName, timeoutMs, metadata, signal) => this.requireTransport().request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata), this.defaultRequestTimeout(meshName));
+        return new DefaultZLinkRequestCall(() => this.requireMesh(meshName), (packetName, timeoutMs, metadata, signal, onAdmitted) => this.requireTransport().request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted), this.defaultRequestTimeout(meshName));
     }
     sendToChannel(channelName, message) {
         return new DefaultZLinkSendCall(() => this.requireChannelRoute(channelName), async (packetName, metadata) => {
@@ -101,12 +116,12 @@ class DefaultZLinkRouteClient {
         });
     }
     requestToChannel(channelName, request) {
-        return new DefaultZLinkRequestCall(() => this.requireChannelRoute(channelName), (packetName, timeoutMs, metadata, signal) => {
+        return new DefaultZLinkRequestCall(() => this.requireChannelRoute(channelName), (packetName, timeoutMs, metadata, signal, onAdmitted) => {
             const route = this.requireChannelRoute(channelName);
             if (route.kind === 'route-mesh') {
-                return this.requireTransport().requestToChannel(route.meshName, channelName, packetName, request, timeoutMs, signal, metadata);
+                return this.requireTransport().requestToChannel(route.meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted);
             }
-            return this.requireChannelTransport().request(channelName, packetName, request, timeoutMs, signal, metadata);
+            return this.requireChannelTransport().request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted);
         }, this.defaultRequestTimeoutForChannel(channelName));
     }
     sendToSpot(spot, message) {
@@ -123,10 +138,11 @@ class DefaultZLinkRouteClient {
     requestToSpot(spot, request) {
         return new DefaultZLinkRequestCall(() => {
             this.requireSpotTransport();
-        }, (_packetName, timeoutMs, metadata, signal) => (0, spot_outbound_1.requestToSpotHandle)(this.requireSpotTransport(), spot, request, {
+        }, (_packetName, timeoutMs, metadata, signal, onAdmitted) => (0, spot_outbound_1.requestToSpotHandle)(this.requireSpotTransport(), spot, request, {
             timeoutMs,
             signal,
             metadata,
+            onAdmitted,
             spotRouterChannelIdForMesh: this.spotRouterChannelIdForMesh
         }), this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
     }
@@ -217,14 +233,17 @@ exports.DefaultZLinkSpotPublisherClient = DefaultZLinkSpotPublisherClient;
 class DefaultZLinkSendCall {
     validate;
     submitter;
-    selectedMetadata = new Map();
+    message;
+    selectedMetadata;
     executed = false;
-    constructor(validate, submitter) {
+    constructor(validate, submitter, message) {
         this.validate = validate;
         this.submitter = submitter;
+        this.message = message;
     }
     metadata(keyOrMetadata, value) {
         ensureNotExecuted(this.executed);
+        this.selectedMetadata ??= new Map();
         if (typeof keyOrMetadata === 'string') {
             this.selectedMetadata.set(keyOrMetadata, value);
         }
@@ -235,12 +254,20 @@ class DefaultZLinkSendCall {
         }
         return this;
     }
-    async submit() {
-        ensureNotExecuted(this.executed);
-        this.validate();
-        this.executed = true;
-        const result = await this.submitter(undefined, new Map(this.selectedMetadata));
-        (0, submission_result_1.requireOneWayCompletion)(result, 'One-way send');
+    submit() {
+        try {
+            ensureNotExecuted(this.executed);
+            this.validate();
+            this.executed = true;
+            const result = this.submitter(undefined, this.selectedMetadata ?? EMPTY_CALL_METADATA, this.message);
+            if (result instanceof Promise)
+                return result.then(completeOneWaySend);
+            completeOneWaySend(result);
+            return completedOneWaySend;
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
 }
 function ensureNotExecuted(executed) {
@@ -248,15 +275,22 @@ function ensureNotExecuted(executed) {
         (0, submission_result_1.throwAlreadySubmitted)('ZLink call');
     }
 }
+const EMPTY_CALL_METADATA = new Map();
+const completedOneWaySend = Promise.resolve();
+function completeOneWaySend(result) {
+    (0, submission_result_1.requireOneWayCompletion)(result, 'One-way send');
+}
 function normalizeSubmitResult(result) {
-    return result ?? { status: submission_result_1.ZLinkSubmitStatus.Submitted };
+    return result instanceof Promise
+        ? result.then((value) => value ?? submission_result_1.submittedResult)
+        : (result ?? submission_result_1.submittedResult);
 }
 class DefaultZLinkRequestCall {
     validate;
     submitter;
     defaultRequestTimeoutMs;
     timeoutMs;
-    selectedMetadata = new Map();
+    selectedMetadata;
     turn = (0, execution_1.captureZLinkSpotSerialTurn)();
     constructor(validate, submitter, defaultRequestTimeoutMs) {
         this.validate = validate;
@@ -264,6 +298,7 @@ class DefaultZLinkRequestCall {
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
     }
     metadata(keyOrMetadata, value) {
+        this.selectedMetadata ??= new Map();
         if (typeof keyOrMetadata === 'string') {
             this.selectedMetadata.set(keyOrMetadata, value);
         }
@@ -278,16 +313,18 @@ class DefaultZLinkRequestCall {
         this.timeoutMs = timeoutMs;
         return this;
     }
-    async submit(signal) {
-        (0, abort_1.throwIfAborted)(signal);
-        this.validate();
-        return this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, new Map(this.selectedMetadata), signal);
+    submit(signal) {
+        return (0, request_result_1.createZLinkRequest)((onAdmitted) => {
+            (0, abort_1.throwIfAborted)(signal);
+            this.validate();
+            return this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata === undefined ? EMPTY_CALL_METADATA : new Map(this.selectedMetadata), signal, onAdmitted);
+        });
     }
     async yield(signal) {
         const turn = (0, execution_1.requireZLinkYieldTurn)(this.turn);
         (0, abort_1.throwIfAborted)(signal);
         this.validate();
-        const pending = this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, new Map(this.selectedMetadata), signal);
+        const pending = this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata === undefined ? EMPTY_CALL_METADATA : new Map(this.selectedMetadata), signal);
         return turn.yieldPromise(pending);
     }
 }

package/dist/runtime/channels/channel-dispatch-pipeline.d.ts

@@ -39,8 +39,8 @@ interface ZLinkRequestDispatch<TContext extends ZLinkMessageContext> {
     readonly context: TContext;
     readonly signal?: AbortSignal;
     readonly missingHandlerMessage: string;
-    readonly writeReply: (reply: unknown) => Promise<void>;
-    readonly writeError: (error: unknown) => Promise<void>;
+    readonly writeReply: (reply: unknown) => void | Promise<void>;
+    readonly writeError: (error: unknown) => void | Promise<void>;
 }
 export declare class ZLinkChannelDispatchPipeline {
     private readonly options;
@@ -66,6 +66,7 @@ export declare class ZLinkChannelDispatchPipeline {
         readonly writeProtocolError?: (error: ZLinkFrameworkException) => Promise<void>;
     }): Promise<void>;
     private invoke;
+    private invokeFiltered;
     private createFilterContext;
     private dispatchKind;
     private report;