@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkDealerChannelClientTransport = void 0;
+const request_runtime_1 = require("../../foundation/request-runtime");
+const request_result_1 = require("../../messaging/request-result");
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const configuration_1 = require("../../configuration");
 const submission_result_1 = require("../../messaging/submission-result");
@@ -13,9 +15,11 @@ const EMPTY_METADATA = new Map();
 class ZLinkDealerChannelClientTransport {
     dealer;
     publisher;
-    constructor(dealer, publisher) {
+    requests;
+    constructor(dealer, publisher, requests = new request_runtime_1.RequestRuntime()) {
         this.dealer = dealer;
         this.publisher = publisher;
+        this.requests = requests;
     }
     async send(channelName, packetName, message, metadata = EMPTY_METADATA) {
         // Call-scoped flow (spec 27 §4): the envelope flow pair does not outlive
@@ -23,20 +27,69 @@ class ZLinkDealerChannelClientTransport {
         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);
         return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
     }
-    async request(channelName, packetName, request, timeoutMs, signal, metadata = EMPTY_METADATA, onAdmitted) {
-        (0, abort_1.throwIfAborted)(signal);
-        const operation = (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.request(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs, undefined, undefined, undefined, true, metadata)));
-        if (timeoutMs !== undefined)
-            operation.timeout(timeoutMs);
-        const reply = await (0, channel_multipart_1.submitRequestOperation)({
-            submit: () => (0, node_backend_adapter_support_1.bindingRequestReply)(operation.submit(), timeoutMs === undefined ? undefined : performance.now() + timeoutMs, undefined, onAdmitted)
-        }, 'channel request');
+    request(channelName, packetName, request, timeoutMs, signal, metadata = EMPTY_METADATA, onAdmitted) {
         try {
-            return (0, channel_envelope_1.decodeChannelReply)(reply);
+            (0, abort_1.throwIfAborted)(signal);
+        }
+        catch (error) {
+            return (0, request_result_1.rejectZLinkRequestReply)(error);
         }
-        finally {
-            for (const part of reply)
-                part.close();
+        const requestOperation = this.requests.begin(timeoutMs, signal);
+        try {
+            (0, abort_1.throwIfAborted)(signal);
+            const operation = (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.request(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs, undefined, undefined, undefined, true, metadata)));
+            if (timeoutMs !== undefined)
+                operation.timeout(timeoutMs);
+            const decode = (raw) => {
+                const reply = raw;
+                try {
+                    return (0, channel_envelope_1.decodeChannelReply)(reply);
+                }
+                finally {
+                    closeReply(reply);
+                }
+            };
+            requestOperation.mapCaller(decode, request_result_1.identityRequestReply);
+            if (requestOperation.isPending()) {
+                const receiver = {
+                    operationCompleted: (_id, raw) => {
+                        if (requestOperation.complete(raw))
+                            return;
+                        try {
+                            requestOperation.resolveCaller(decode(raw));
+                        }
+                        catch (error) {
+                            requestOperation.rejectCaller(error);
+                        }
+                    },
+                    operationFailed: (_id, error) => {
+                        let failure = error;
+                        try {
+                            failure = (0, channel_multipart_1.mapRequestFailure)(error, 'channel request');
+                        }
+                        catch (mapped) {
+                            failure = mapped;
+                        }
+                        requestOperation.fail(failure);
+                    }
+                };
+                try {
+                    (0, node_backend_adapter_support_1.bindingRequestReply)(operation.submit(), receiver, requestOperation, undefined, onAdmitted);
+                }
+                catch (error) {
+                    receiver.operationFailed(requestOperation.id, error);
+                }
+            }
+            return {
+                pending: requestOperation.promise,
+                decode: (request_result_1.identityRequestReply),
+                mapFailure: request_result_1.identityRequestReply,
+                operation: requestOperation
+            };
+        }
+        catch (error) {
+            requestOperation.fail(error);
+            return (0, request_result_1.prepareZLinkRequestReply)(requestOperation.promise, request_result_1.identityRequestReply);
         }
     }
     tryPublish(channelName, topic, packetName, event, metadata = EMPTY_METADATA) {
@@ -52,3 +105,7 @@ class ZLinkDealerChannelClientTransport {
     }
 }
 exports.ZLinkDealerChannelClientTransport = ZLinkDealerChannelClientTransport;
+function closeReply(parts) {
+    for (const part of parts)
+        part.close();
+}

package/dist/runtime/backend/node/node-event-loop-poller.d.ts

@@ -9,8 +9,8 @@ export declare class ZLinkNodeEventLoopPoller {
     private readonly events;
     private readableHandler;
     private disposed;
-    constructor(socket: Socket, pollCompletion: boolean, readableHandler: (receiveReady: boolean, routeReady: boolean) => void, pollRoute?: boolean);
-    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void;
+    constructor(socket: Socket, pollCompletion: boolean, readableHandler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void, pollRoute?: boolean);
+    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void): void;
     dispose(): void;
     private readonly onReady;
 }

package/dist/runtime/backend/node/node-event-loop-poller.js

@@ -21,7 +21,7 @@ class ZLinkNodeEventLoopPoller {
             // A ROUTER selected-route change (Core ROUTER §10.1) wakes the same
             // handler, whose owner is the socket's one route observer.
             if (pollRoute)
-                pollEvents.push(node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute);
+                pollEvents.push(node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute, node_backend_adapter_support_1.zlink.PollEventFlag.PollConnect);
             this.poller.add(socket, pollEvents, 0);
             socket.setReadableHandler(this.onReady);
         }
@@ -47,8 +47,9 @@ class ZLinkNodeEventLoopPoller {
         const ready = this.poller.wait(this.events, 0);
         const receiveReady = ready === 0 || this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn);
         const routeReady = ready > 0 && this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute);
-        if (receiveReady || routeReady)
-            this.readableHandler(receiveReady, routeReady);
+        const connectReady = ready > 0 && this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollConnect);
+        if (receiveReady || routeReady || connectReady)
+            this.readableHandler(receiveReady, routeReady, connectReady);
     };
 }
 exports.ZLinkNodeEventLoopPoller = ZLinkNodeEventLoopPoller;

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

@@ -12,7 +12,11 @@ class ZLinkNodeMeshBackendAdapter {
         if (!isBindingContext(bindingContext)) {
             throw new TypeError('Node MeshNode creation requires the Node binding Context owned by the host.');
         }
-        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed, options.infrastructureTaskRunner);
+        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, {
+            sendHighWaterMark: options.sendHighWaterMark,
+            receiveHighWaterMark: options.receiveHighWaterMark,
+            receiveTimeoutMs: options.receiveTimeoutMs
+        }), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed, options.infrastructureTaskRunner);
     }
 }
 exports.ZLinkNodeMeshBackendAdapter = ZLinkNodeMeshBackendAdapter;

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

@@ -1,9 +1,14 @@
 import { type Context } from '@zlink-systems/zlink';
 import type { ZLinkRawBindingPort, ZLinkRawHostPort } from '../raw-binding-port';
+interface ZLinkNodeRawRouterSocketOptions {
+    readonly sendHighWaterMark?: number;
+    readonly receiveHighWaterMark?: number;
+    readonly receiveTimeoutMs?: number;
+}
 export type { ZLinkRawBindingPort, ZLinkRawDealerPort, ZLinkRawHostPort, ZLinkRawMonitorPort, ZLinkRawMonitorRecord, ZLinkRawReceivedRecord, ZLinkRawRouterPort, ZLinkRawRouterRoute, ZLinkRawSocketPort } from '../raw-binding-port';
 export declare class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
     private readonly sharedContext?;
-    private readonly routerReceiveTimeoutMs?;
-    constructor(sharedContext?: Context | undefined, routerReceiveTimeoutMs?: number | undefined);
+    private readonly routerSocketOptions?;
+    constructor(sharedContext?: Context | undefined, routerSocketOptions?: ZLinkNodeRawRouterSocketOptions | undefined);
     createHost(): ZLinkRawHostPort;
 }

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkNodeRawBindingPort = void 0;
+const request_runtime_1 = require("../../foundation/request-runtime");
+const request_deadline_1 = require("../../messaging/request-deadline");
 const zlink_1 = require("@zlink-systems/zlink");
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
@@ -9,30 +11,30 @@ const node_event_loop_poller_1 = require("./node-event-loop-poller");
 const runtime_message_1 = require("../runtime-message");
 class ZLinkNodeRawBindingPort {
     sharedContext;
-    routerReceiveTimeoutMs;
-    constructor(sharedContext, routerReceiveTimeoutMs) {
+    routerSocketOptions;
+    constructor(sharedContext, routerSocketOptions) {
         this.sharedContext = sharedContext;
-        this.routerReceiveTimeoutMs = routerReceiveTimeoutMs;
+        this.routerSocketOptions = routerSocketOptions;
     }
     createHost() {
-        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined, this.routerReceiveTimeoutMs);
+        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined, this.routerSocketOptions);
     }
 }
 exports.ZLinkNodeRawBindingPort = ZLinkNodeRawBindingPort;
 class NodeRawHostPort {
     context;
     ownsContext;
-    routerReceiveTimeoutMs;
+    routerSocketOptions;
     resources = [];
     state = 'open';
-    constructor(context, ownsContext, routerReceiveTimeoutMs) {
+    constructor(context, ownsContext, routerSocketOptions) {
         this.context = context;
         this.ownsContext = ownsContext;
-        this.routerReceiveTimeoutMs = routerReceiveTimeoutMs;
+        this.routerSocketOptions = routerSocketOptions;
     }
     createRouter() {
         this.requireOpen();
-        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context), this.routerReceiveTimeoutMs));
+        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context), this.routerSocketOptions));
     }
     createDealer() {
         this.requireOpen();
@@ -84,6 +86,8 @@ class NodeRawHostPort {
 }
 class NodeRawSocketPort {
     socket;
+    requests = new request_runtime_1.RequestRuntime();
+    received = new zlink_1.Received();
     endpoints = new Set();
     monitors = new Set();
     eventLoopPoller;
@@ -124,6 +128,7 @@ class NodeRawSocketPort {
         return port;
     }
     close() {
+        this.requests.close();
         if (this.closed)
             return;
         const failures = [];
@@ -162,6 +167,7 @@ class NodeRawSocketPort {
         }
         this.endpoints.clear();
         try {
+            this.received.close();
             this.socket.close();
         }
         catch (error) {
@@ -212,13 +218,19 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         this.requireOpen();
         (0, node_socket_backend_adapter_1.disconnectSocketPeer)(this.socket, this.preparedRoutingId(routingId));
     }
-    constructor(socket, receiveTimeoutMs) {
+    constructor(socket, options) {
         super(socket, true);
         socket.options.handover = true;
         socket.options.mandatory = true;
         socket.options.probe = true;
-        if (receiveTimeoutMs !== undefined) {
-            socket.options.recvTimeout = receiveTimeoutMs;
+        if (options?.sendHighWaterMark !== undefined) {
+            socket.options.sendHwm = BigInt(options.sendHighWaterMark);
+        }
+        if (options?.receiveHighWaterMark !== undefined) {
+            socket.options.recvHwm = BigInt(options.receiveHighWaterMark);
+        }
+        if (options?.receiveTimeoutMs !== undefined) {
+            socket.options.recvTimeout = options.receiveTimeoutMs;
         }
     }
     localEndpoint() {
@@ -244,19 +256,25 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         requireParts(parts);
         return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
     }
-    request(targetRid, parts, timeoutMs, recordReceived, onAdmitted) {
-        let submission;
-        const deadlineMs = performance.now() + timeoutMs;
-        try {
+    request(targetRid, parts, timeoutMs, onReply, onFailed, recordReceived, onAdmitted, existing) {
+        if (existing !== undefined) {
             this.requireOpen();
-            submission = appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts)
-                .timeout(timeoutMs)
-                .submit();
-        }
-        catch (error) {
-            return Promise.reject((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit'));
+            const submission = submitRawRequest(appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts).timeout((0, request_deadline_1.remainingRequestTimeout)('Request', existing.deadlineMs) ?? timeoutMs));
+            return requestReply(submission, 0, onReply, onFailed, recordReceived, onAdmitted);
         }
-        return requestReply(submission, deadlineMs, recordReceived, onAdmitted);
+        return this.requests.observe(timeoutMs, (entry, receiver) => {
+            this.requireOpen();
+            const submission = submitRawRequest(appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts).timeout((0, request_deadline_1.remainingRequestTimeout)('Request', entry.deadlineMs) ?? timeoutMs));
+            void requestReply(submission, 0, (value) => {
+                receiver.operationCompleted(entry.id, value, undefined);
+            }, (error) => {
+                receiver.operationFailed(entry.id, error, undefined);
+            }, recordReceived, onAdmitted);
+        }, onReply, onFailed);
+    }
+    connectionAttemptsSnapshot() {
+        this.requireOpen();
+        return this.socket.connectionAttemptsSnapshot();
     }
     routesSnapshot() {
         this.requireOpen();
@@ -267,7 +285,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     receive(dontWait = false) {
         this.requireOpen();
-        return receiveRecord(this.socket, dontWait, this.nextRequestSequence, this.replyParts);
+        return receiveRecord(this.socket, this.received, dontWait, this.nextRequestSequence, this.replyParts);
     }
 }
 class NodeRawDealerPort extends NodeRawSocketPort {
@@ -284,20 +302,19 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(), parts);
     }
     request(parts, timeoutMs, onAdmitted) {
-        let submission;
-        const deadlineMs = performance.now() + timeoutMs;
-        try {
+        return this.requests.observe(timeoutMs, (entry, receiver) => {
             this.requireOpen();
-            submission = appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
-        }
-        catch (error) {
-            return Promise.reject((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit'));
-        }
-        return requestReply(submission, deadlineMs, undefined, onAdmitted);
+            const submission = submitRawRequest(appendRequestParts(this.socket.request(), parts).timeout((0, request_deadline_1.remainingRequestTimeout)('Request', entry.deadlineMs) ?? timeoutMs));
+            void requestReply(submission, 0, (value) => {
+                receiver.operationCompleted(entry.id, value, undefined);
+            }, (error) => {
+                receiver.operationFailed(entry.id, error, undefined);
+            }, undefined, onAdmitted);
+        }, (value) => value, rethrowCompletion);
     }
     receive(dontWait = false) {
         this.requireOpen();
-        return receiveRecord(this.socket, dontWait);
+        return receiveRecord(this.socket, this.received, dontWait);
     }
 }
 class NodeRawMonitorPort {
@@ -357,20 +374,17 @@ function requireParts(parts) {
 const EMPTY_SOURCE_ROUTE = Buffer.alloc(0);
 /**
  * One received binding record. The payload Buffers are the binding's own
- * `data()` storage, retained under the runtime payload policy instead of a
- * second Framework copy; closing the record releases the binding handles.
+ * `data()` storage, retained under the runtime payload policy. The socket owns
+ * the reusable binding envelope; snapshots survive its next receive or close.
  */
 class NodeRawReceivedRecord {
-    received;
     sourceRid;
     sourceRoute;
     routeGeneration;
     requestSeq;
     reply;
     parts;
-    closed = false;
     constructor(received, nextRequestSequence, reply) {
-        this.received = received;
         const routingId = received.routingId;
         this.sourceRid = routingId?.toString() ?? '';
         this.sourceRoute = routingId?.toBytes() ?? EMPTY_SOURCE_ROUTE;
@@ -394,16 +408,13 @@ class NodeRawReceivedRecord {
         this.parts = retained;
     }
     close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.received.close();
+        // Reading each binding payload above retained JS-owned storage and released
+        // its native frame. The socket clears its reusable envelope; these record
+        // snapshots need no native cleanup.
     }
 }
-function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
-    const received = new zlink_1.Received();
+function receiveRecord(socket, received, dontWait, nextRequestSequence, reply) {
     if (!socket.recv(received, dontWait ? zlink_1.RecvFlags.DontWait : zlink_1.RecvFlags.None)) {
-        received.close();
         return undefined;
     }
     try {
@@ -419,36 +430,53 @@ function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
  * confirmed in this turn; a backpressured submission keeps the admission
  * wait that bounds it by the request deadline.
  */
-function requestReply(submission, deadlineMs, recordReceived, onAdmitted) {
+function requestReply(submission, _deadlineMs, onReply, onFailed, recordReceived, onAdmitted) {
+    const result = observeRequestReply(submission.reply, onReply, onFailed, recordReceived);
     if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
-        return (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, recordReceived, onAdmitted).then(retainAndClose, rejectCompletion);
-    }
-    try {
-        onAdmitted?.();
+        void submission.admitted.then(() => {
+            try {
+                onAdmitted?.();
+            }
+            catch (error) {
+                onFailed((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion'));
+            }
+        }, (error) => onFailed((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion')));
     }
-    catch (error) {
-        return Promise.reject((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion'));
+    else {
+        try {
+            onAdmitted?.();
+        }
+        catch (error) {
+            onFailed((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion'));
+        }
     }
-    return submission.reply.then((replies) => {
+    return result;
+}
+/** Consumes the binding reply and notifies its terminal in this continuation. */
+function observeRequestReply(reply, onReply, onFailed, recordReceived) {
+    return reply.then((replies) => {
         try {
-            recordReceived?.();
-            return retainAndClose(replies);
+            return onReply(retainAndClose(replies, recordReceived));
         }
         catch (error) {
-            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
+            return onFailed((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion'));
         }
-    }, rejectCompletion);
+    }, (error) => onFailed((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion')));
 }
-function rejectCompletion(error) {
-    throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
+function rethrowCompletion(error) {
+    throw error;
 }
-function retainAndClose(messages) {
+function retainAndClose(messages, recordReceived) {
     try {
-        return messages.map((message) => runtime_message_1.ZLinkBufferMessage.retainPayload(message));
+        recordReceived?.();
+        const retained = new Array(messages.length);
+        for (let index = 0; index < messages.length; index++)
+            retained[index] = runtime_message_1.ZLinkBufferMessage.retainPayload(messages[index]);
+        return retained;
     }
     finally {
-        for (const message of messages)
-            message.close();
+        for (let index = 0; index < messages.length; index++)
+            messages[index].close();
     }
 }
 function bindingRoutingId(routingId) {
@@ -472,3 +500,11 @@ function copyMonitorEvent(event) {
         flags: event.flags
     };
 }
+function submitRawRequest(operation) {
+    try {
+        return operation.submit();
+    }
+    catch (error) {
+        throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
+    }
+}

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

@@ -1,13 +1,15 @@
+import type { RequestRuntime } from '../../foundation/request-runtime';
+import type { PendingOperation } from '../../foundation/operation-registry';
 import { SubmitResult, type RequestResult as RequestResultValue, type SubmitResult as SubmitResultValue } from '@zlink-systems/zlink';
 import type { ZLinkMeshCompletionHandler } from '../mesh-completion-table';
 import { type RoutingId } from '../../../contracts';
 import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
 import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-reporter';
-import { type RawServiceRequestResult } from '../../foundation/raw-service-mesh-runtime';
+import { RawServiceMeshRuntime, type RawServiceRequestResult } from '../../foundation/raw-service-mesh-runtime';
 import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
 import { type MeshOperationId, type MeshPeerEntry, type MeshPublisher, type ReadyBatch, type ReadyRecord, type ReceiveBatch, type ServiceSpot, type StreamSessionService, MeshNodeRuntimeState } from '../../foundation/service-runtime-contracts';
 import type { ServiceActorRef, ServiceSpotState } from '../../foundation/service-stateful-registry';
-import { type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSessionOwnerDescriptors, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
+import { ServiceStatefulRuntime, type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSessionOwnerDescriptors, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
 import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceActivationTarget, ServiceInstanceColdActivationTarget, ServiceInstanceRouteFence, ServiceSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
 import type { ServiceNodeDescriptor } from '../../foundation/service-topology-registry';
 import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
@@ -34,7 +36,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readonly lifecycleGeneration;
     private bindEndpoint?;
     private advertiseHost?;
-    private runtime?;
+    runtime?: RawServiceMeshRuntime;
     private stateful?;
     private readyHandler?;
     private maintenanceTimer?;
@@ -56,10 +58,13 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private protocolError?;
     private messageFollowHandler?;
     private dispatchErrors?;
-    private sessionOwnerDescriptors?;
     private requestSourceAcceptance?;
+    private sessionOwnerDescriptors?;
     private readonly peerDisconnectedHandlers;
-    constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined, infrastructureTaskRunner?: import("../../spots/spot-actor-join-dispatch").ZLinkDetachedTaskRunner | undefined);
+    constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined, infrastructureTaskRunner?: import("../../spots/spot-actor-join-dispatch").ZLinkDetachedTaskRunner | undefined, runtimeDependencies?: {
+        readonly raw?: RawServiceMeshRuntime;
+        readonly stateful?: ServiceStatefulRuntime;
+    });
     configureObjectPlacement(options: {
         readonly role: ServiceNodeDescriptor['objectRole'];
         readonly placementWeight: number;
@@ -84,10 +89,12 @@ 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>, onAdmitted?: () => void): MeshOperationId;
+    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): MeshOperationId;
     setRoutingId(routingId: unknown): void;
     setBind(endpoint: string): void;
     setAdvertiseHost(host: string): void;
+    private requests?;
+    setRequestRuntime(requests: RequestRuntime): void;
     start(): void;
     setMessageFollowHandler(handler: (record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord) => void): void;
     sendMessageFollowNotification(targetNodeRid: string, record: Omit<import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord, 'kind'>): Promise<boolean>;
@@ -129,18 +136,21 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     sendInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[]): Promise<SubmitResultValue>;
     requestInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[], options?: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onSubmitted?: (signal: AbortSignal) => Promise<void>;
     }): Promise<readonly Uint8Array[]>;
     requestToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly onAdmitted?: () => void;
-    }): MeshOperationId;
+    }, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly onAdmitted?: () => void;
-    }): MeshOperationId;
+    }, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     status(): {
         state: MeshNodeRuntimeState;
         routingId: RoutingId;
@@ -209,7 +219,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence | null, 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, onAdmitted?: () => void): MeshOperationId;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     actorLookup(actorId: string): {
         actor: ServiceActorRef;
         spotId: string;
@@ -242,9 +252,10 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     }): Promise<SubmitResultValue>;
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly onAdmitted?: () => void;
         readonly routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
-    }): MeshOperationId;
+    }, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     acceptRelocatedActorTerminal(operation: {
         readonly high: bigint;
         readonly low: bigint;
@@ -252,6 +263,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     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 requestOperation?: PendingOperation<unknown>;
         readonly onAdmitted?: () => void;
     }): MeshOperationId;
     sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], _flags?: number): Promise<SubmitResultValue>;
@@ -259,31 +271,37 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     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, onAdmitted?: () => void): MeshOperationId;
+    requestFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs: number, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): 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;
     unsetSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;
     clearSpotSubscriptions(state: ServiceSpotState): void;
-    private createDescriptor;
+    createDescriptor(): ServiceNodeDescriptor;
     private resolveAdvertisedEndpoint;
     /**
      * Arms the one maintenance timer for the nearest management deadline
      * (spec 08 §4.2): request expiry, liveness, or a pending peer handshake.
-     * An earlier deadline re-arms it; a later one keeps the armed time.
+     * The timer follows changes to the index visit or the other management deadlines.
      */
     private scheduleMaintenance;
     private pump;
     private runPump;
+    private resumePump;
+    private pumpReceiveBatch;
+    private hasPumpReadiness;
+    private finishPump;
     private notifyReady;
     /**
-     * The raw registry takes a remote request's terminal and hands it here,
-     * where the Framework completion owner receives it in the same turn.
+     * Publishes native results after submission returns and the completion slot has its id.
+     * A caller-owned entry is completed after the result is mapped.
      */
     private readonly requestObserver;
+    private requestObserverFor;
     private observedOperation;
-    private observeCompletion;
+    private observeStatefulRequest;
     private observeStateful;
+    private requestSubmission;
     private deliverCompletion;
     private drainMailbox;
     private requireRuntime;