@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -36,10 +36,6 @@ const UNSTARTED_DIAGNOSTIC_ENDPOINT = 'inproc://not-started';
 const MULTIPART_PACKET_NAME = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME;
 const MULTIPART_CONTENT_TYPE = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
 const MAX_DRAIN_RECORDS = 64;
-// The maintenance timer runs at the nearest management deadline and never
-// sooner than this. Only the binding readable handler admits receive work;
-// this timer never probes the socket.
-const MESH_BACKEND_MAINTENANCE_INTERVAL_MS = 1;
 /** The longest single timer delay Node accepts. */
 const MESH_BACKEND_MAINTENANCE_MAX_DELAY_MS = 2 ** 31 - 1;
 // Spec 08 §4.2 bounds the combined turn. Raw gets one equal share; stateful
@@ -78,11 +74,13 @@ class ZLinkNodeRawMeshBackend {
     maintenanceDueMs = Number.POSITIVE_INFINITY;
     pumpTask;
     readable = 0;
-    onReadable = (receiveReady, routeReady) => {
+    onReadable = (receiveReady, routeReady, connectReady) => {
         if (receiveReady)
             this.readable |= 1;
         if (routeReady)
             this.readable |= 2;
+        if (connectReady)
+            this.readable |= 4;
         this.pump();
     };
     onMaintenance = () => {
@@ -110,10 +108,10 @@ class ZLinkNodeRawMeshBackend {
     protocolError;
     messageFollowHandler;
     dispatchErrors;
-    sessionOwnerDescriptors;
     requestSourceAcceptance;
+    sessionOwnerDescriptors;
     peerDisconnectedHandlers = new Set();
-    constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed, infrastructureTaskRunner) {
+    constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed, infrastructureTaskRunner, runtimeDependencies) {
         this.meshName = meshName;
         this.bindingPort = bindingPort;
         this.applicationJobQueue = applicationJobQueue;
@@ -127,6 +125,8 @@ class ZLinkNodeRawMeshBackend {
         }
         this.routingId = routingId;
         this.lifecycleGeneration = createLifecycleGeneration();
+        this.runtime = runtimeDependencies?.raw;
+        this.stateful = runtimeDependencies?.stateful;
     }
     configureObjectPlacement(options) {
         this.requireNotStarted();
@@ -180,8 +180,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, 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));
+    requestToMissingInstanceSpot(target, parts, deadlineUnixMs, sourceSpotId, metadata, onAdmitted, requestOperation) {
+        return this.observeStatefulRequest(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, requestOperation, () => this.requireStateful().requestToMissingInstanceSpotFrame(target, encodeMultipartApplicationFrame(parts), deadlineUnixMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), onAdmitted, requestOperation));
     }
     setRoutingId(routingId) {
         if (!(0, routing_id_1.routingIdsEqual)((0, routing_id_2.toBackendRoutingId)(routingId), this.routingId)) {
@@ -200,6 +200,11 @@ class ZLinkNodeRawMeshBackend {
             throw new TypeError('MeshNode advertise host must be non-empty.');
         this.advertiseHost = host;
     }
+    requests;
+    setRequestRuntime(requests) {
+        this.requireNotStarted();
+        this.requests = requests;
+    }
     start() {
         if (this.runtime !== undefined)
             return;
@@ -209,12 +214,13 @@ class ZLinkNodeRawMeshBackend {
             throw new Error('MeshNode bind endpoint is not configured.');
         const descriptor = this.createDescriptor();
         const runtime = new raw_service_mesh_runtime_1.RawServiceMeshRuntime({
+            requests: this.requests,
             onPendingOperationsChanged: this.onPendingOperationsChanged,
             descriptor,
             resolveAdvertisedEndpoint: (boundEndpoint) => this.resolveAdvertisedEndpoint(boundEndpoint),
             bindingPort: this.bindingPort,
             applicationJobQueue: this.requireApplicationJobQueue(),
-            onReceiveReady: () => this.onReadable(true, false),
+            onReceiveReady: () => this.onReadable(true, false, false),
             infrastructureTaskRunner: this.infrastructureTaskRunner,
             peerAdmissionSealed: this.peerAdmissionSealed,
             onReceiveFlowConfigFailure: this.applicationJobReceiveFlowFailureSink,
@@ -239,7 +245,7 @@ class ZLinkNodeRawMeshBackend {
             }
         });
         runtime.start();
-        this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration, this.onPendingOperationsChanged);
+        this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration, this.onPendingOperationsChanged, this.requests);
         if (this.dispatchErrors !== undefined) {
             this.stateful.setDispatchErrorReporter(this.dispatchErrors, this.meshName);
         }
@@ -326,15 +332,28 @@ class ZLinkNodeRawMeshBackend {
     async connectPeer(options) {
         const runtime = this.requireRuntime();
         const nodeRoutingId = options.expectedRid === undefined ? undefined : String(options.expectedRid);
+        const securityIdentity = options.expectedSecurityIdentity ?? runtime.topology.localDescriptor().securityIdentity;
+        for (const [id, existing] of this.peerIntents) {
+            if (existing.endpoint !== options.endpoint)
+                continue;
+            if (existing.nodeRoutingId === nodeRoutingId &&
+                existing.securityIdentity === securityIdentity &&
+                existing.lifecycleGeneration === options.expectedLifecycleGeneration) {
+                return id;
+            }
+            runtime.disconnectPeerEndpoint(existing.endpoint);
+            this.peerIntents.delete(id);
+        }
         if (nodeRoutingId === undefined) {
             runtime.connectPeerEndpoint(options.endpoint);
         }
         else {
-            runtime.connectPeerByRoutingId(options.endpoint, nodeRoutingId, options.expectedSecurityIdentity ?? runtime.topology.localDescriptor().securityIdentity, options.expectedLifecycleGeneration);
+            runtime.connectPeerByRoutingId(options.endpoint, nodeRoutingId, securityIdentity, options.expectedLifecycleGeneration);
         }
         const intent = this.nextPeerIntent++;
         this.peerIntents.set(intent, {
             endpoint: options.endpoint,
+            securityIdentity,
             ...(nodeRoutingId === undefined
                 ? {}
                 : {
@@ -350,6 +369,7 @@ class ZLinkNodeRawMeshBackend {
     }
     expectPeer(peer) {
         this.requireRuntime().expectPeerByRoutingId(peer.endpoint, peer.nodeRoutingId, peer.securityIdentity, peer.lifecycleGeneration);
+        this.scheduleMaintenance();
     }
     removePeerConnection(intentId) {
         const intent = this.peerIntents.get(intentId);
@@ -436,22 +456,40 @@ class ZLinkNodeRawMeshBackend {
             : zlink_1.SubmitResult.NotConnected;
     }
     async requestInfrastructureControlFrames(targetRid, frames, options) {
-        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);
+        const runtime = this.requireRuntime();
+        const timeoutMs = options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS;
+        const pending = options?.requestOperation ?? runtime.beginInfrastructureRequest(timeoutMs, options?.signal);
+        if (options?.requestOperation !== undefined) {
+            return (0, durable_service_request_1.requestDurableService)(runtime, String(targetRid), frames, pending, 'relocation control', options.signal, options.onSubmitted);
+        }
+        const completed = (reply) => {
+            pending.complete(reply);
+        };
+        const failed = (error) => {
+            pending.fail(error);
+        };
+        void (0, durable_service_request_1.requestDurableService)(runtime, String(targetRid), frames, pending, 'relocation control', options?.signal, options?.onSubmitted).then(completed, failed);
+        return pending.promise;
     }
-    requestToNode(targetRid, parts, options) {
-        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted, this.requestObserver, service_runtime_contracts_1.OperationKind.NodeRequest);
+    requestToNode(targetRid, parts, options, completion) {
+        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted, this.requestObserverFor(completion), service_runtime_contracts_1.OperationKind.NodeRequest, options?.requestOperation);
         return this.observedOperation(pending, service_runtime_contracts_1.OperationKind.NodeRequest);
     }
-    async sendToChannel(channelName, parts) {
-        return this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts));
+    sendToChannel(channelName, parts) {
+        try {
+            return Promise.resolve(this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts)));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
-    requestToChannel(channelName, parts, options) {
-        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted, this.requestObserver, service_runtime_contracts_1.OperationKind.ChannelRequest);
+    requestToChannel(channelName, parts, options, completion) {
+        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted, this.requestObserverFor(completion), service_runtime_contracts_1.OperationKind.ChannelRequest, options?.requestOperation);
         return this.observedOperation(pending, service_runtime_contracts_1.OperationKind.ChannelRequest);
     }
     status() {
         const descriptor = this.runtime?.topology.localDescriptor() ?? this.createDescriptor();
-        const peers = this.runtime?.topology.peers() ?? [];
+        const peers = (this.runtime?.topology.peers() ?? []).filter((peer) => this.runtime?.isPeerRouteReady(peer.descriptor.nodeRoutingId) === true);
         return {
             state: stateCode(descriptor.state),
             routingId: descriptor.nodeRoutingId,
@@ -705,8 +743,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, 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));
+    requestInstanceSpot(route, parts, timeoutMs = Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, sourceSpotId, metadata, instanceIntent = false, onAdmitted, requestOperation, completion) {
+        return this.observeStatefulRequest(service_runtime_contracts_1.OperationKind.InstanceSpotRequest, requestOperation, (receiver) => this.requireStateful().requestToInstanceSpot(route, encodeMultipart(parts), timeoutMs, sourceSpotId, metadata === undefined ? undefined : (0, service_metadata_codec_1.encodeServiceMetadataFrame)(metadata), instanceIntent, onAdmitted, requestOperation, receiver), completion);
     }
     actorLookup(actorId) {
         const actor = this.requireStateful().actor(actorId);
@@ -745,8 +783,8 @@ class ZLinkNodeRawMeshBackend {
     async sendToActor(actor, parts, options) {
         return this.requireStateful().sendToActor(actor, encodeMultipart(parts), undefined, undefined, options?.routeFence);
     }
-    requestToActor(actor, parts, options) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(actor, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, undefined, undefined, options?.onAdmitted, options?.routeFence));
+    requestToActor(actor, parts, options, completion) {
+        return this.observeStatefulRequest(service_runtime_contracts_1.OperationKind.ActorRequest, options?.requestOperation, (receiver) => this.requireStateful().requestToActor(actor, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, undefined, undefined, options?.onAdmitted, options?.routeFence, options?.requestOperation, receiver), completion);
     }
     acceptRelocatedActorTerminal(operation, replyRouteId, result) {
         return this.requireStateful().acceptRelocatedActorTerminal(operation, replyRouteId, result);
@@ -755,7 +793,7 @@ class ZLinkNodeRawMeshBackend {
         return (await this.requireStateful().sendToActor(target, encodeMultipart(parts), source));
     }
     actorRequestToActor(source, target, parts, options) {
-        return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, source, undefined, options?.onAdmitted));
+        return this.observeStatefulRequest(service_runtime_contracts_1.OperationKind.ActorRequest, options?.requestOperation, () => this.requireStateful().requestToActor(target, encodeMultipart(parts), options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, source, undefined, options?.onAdmitted, undefined, options?.requestOperation));
     }
     async sendActorBoundSession(actor, expectedBindingGeneration, parts, _flags) {
         return (await this.requireStateful().sendBoundSession(actor, expectedBindingGeneration, encodeMultipart(parts)));
@@ -772,8 +810,8 @@ class ZLinkNodeRawMeshBackend {
     async sendFromSpot(source, target, parts) {
         return (await this.requireStateful().sendToSpot(source.ref.spotId, target, encodeMultipart(parts)));
     }
-    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));
+    requestFromSpot(source, target, parts, timeoutMs, onAdmitted, requestOperation, completion) {
+        return this.observeStatefulRequest(service_runtime_contracts_1.OperationKind.SpotRequest, requestOperation, (receiver) => this.requireStateful().requestToSpot(source.ref.spotId, target, encodeMultipart(parts), timeoutMs, onAdmitted, requestOperation, receiver), completion);
     }
     closeSpot(state) {
         return this.requireStateful().registry.closeSpot(state.ref);
@@ -827,18 +865,15 @@ class ZLinkNodeRawMeshBackend {
     /**
      * 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.
      */
     scheduleMaintenance() {
         if (this.closed)
             return;
         const nowMs = performance.now();
-        const dueMs = Math.max(nowMs + MESH_BACKEND_MAINTENANCE_INTERVAL_MS, Math.min(this.runtime?.nextMaintenanceDeadlineMs(nowMs) ?? Number.POSITIVE_INFINITY, this.stateful?.nextMaintenanceDeadlineMs() ?? Number.POSITIVE_INFINITY));
+        const dueMs = Math.min(this.runtime?.nextMaintenanceDeadlineMs(nowMs) ?? Number.POSITIVE_INFINITY, this.stateful?.nextMaintenanceDeadlineMs() ?? Number.POSITIVE_INFINITY);
         if (dueMs === Number.POSITIVE_INFINITY) {
-            if (this.maintenanceTimer !== undefined)
-                clearTimeout(this.maintenanceTimer);
-            this.maintenanceTimer = undefined;
-            this.maintenanceDueMs = dueMs;
+            this.maintenanceTimer?.unref();
             return;
         }
         if (this.maintenanceTimer === undefined || dueMs < this.maintenanceDueMs) {
@@ -860,30 +895,79 @@ class ZLinkNodeRawMeshBackend {
     pump() {
         if (this.closed || this.pumpTask !== undefined)
             return;
-        this.pumpTask = this.runPump(this.requireRuntime());
+        const runtime = this.requireRuntime();
+        let complete;
+        let fail;
+        // Publish the join owner before receive can signal readiness or start close.
+        // The receive turn itself needs no startup Promise continuation.
+        this.pumpTask = new Promise((resolve, reject) => {
+            complete = resolve;
+            fail = reject;
+        });
+        this.runPump(runtime, complete, fail);
     }
-    async runPump(runtime) {
-        // Publish pumpTask before any callback can signal readiness or begin close.
-        await Promise.resolve();
+    runPump(runtime, complete, fail) {
         try {
             do {
-                const ready = this.readable;
-                this.readable = 0;
-                const more = await runtime.pumpBatch((ready & 1) !== 0, (ready & 2) !== 0);
+                const batch = this.pumpReceiveBatch(runtime);
+                if (batch !== false) {
+                    // Only suspended work needs an async continuation. A completed receive
+                    // rotation uses the published join without allocating another Promise.
+                    void this.resumePump(runtime, batch, complete, fail);
+                    return;
+                }
+            } while (this.hasPumpReadiness());
+        }
+        catch (error) {
+            this.finishPump(complete, fail, runtime, error);
+            return;
+        }
+        this.finishPump(complete, fail);
+    }
+    async resumePump(runtime, batch, complete, fail) {
+        try {
+            for (;;) {
+                const more = batch instanceof Promise ? await batch : batch;
                 if (more) {
                     // Yield only after actual progress, retaining readiness across the
                     // existing batch limits until receive reports no data.
                     this.readable |= 1;
                     await (0, promises_1.setImmediate)();
                 }
-            } while (!this.closed && this.readable !== 0);
+                if (!this.hasPumpReadiness())
+                    break;
+                batch = this.pumpReceiveBatch(runtime);
+            }
         }
         catch (error) {
-            runtime.reportInfrastructureFailure(error);
+            this.finishPump(complete, fail, runtime, error);
+            return;
+        }
+        this.finishPump(complete, fail);
+    }
+    pumpReceiveBatch(runtime) {
+        const ready = this.readable;
+        this.readable = 0;
+        return runtime.pumpBatch((ready & 1) !== 0, (ready & 2) !== 0, (ready & 4) !== 0);
+    }
+    hasPumpReadiness() {
+        return !this.closed && this.readable !== 0;
+    }
+    finishPump(complete, fail, failedRuntime, error) {
+        try {
+            try {
+                if (failedRuntime !== undefined)
+                    failedRuntime.reportInfrastructureFailure(error);
+            }
+            finally {
+                this.pumpTask = undefined;
+                this.scheduleMaintenance();
+            }
+            complete();
         }
-        finally {
-            this.pumpTask = undefined;
-            this.scheduleMaintenance();
+        catch (error) {
+            // Forward reporting and maintenance failures to the published join owner.
+            fail(error);
         }
     }
     notifyReady() {
@@ -899,31 +983,59 @@ class ZLinkNodeRawMeshBackend {
             this.readyHandler?.(domains);
     }
     /**
-     * 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.
      */
     requestObserver = {
-        operationCompleted: (id, result, operationKind) => this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, result),
-        operationFailed: (id, error, operationKind) => this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, requestFailureResult(error))
+        operationCompleted: (id, result, operationKind) => queueMicrotask(() => this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, result)),
+        operationFailed: (id, error, operationKind) => queueMicrotask(() => this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, requestFailureResult(error)))
     };
-    observedOperation(pending, operationKind) {
-        return pending.promise === undefined
-            ? { high: 1n, low: pending.id }
-            : this.observeCompletion(pending.id, operationKind, pending.promise);
+    requestObserverFor(completion) {
+        if (completion === undefined)
+            return this.requestObserver;
+        return {
+            operationCompleted: (id, result, operationKind) => queueMicrotask(() => this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, result, completion)),
+            operationFailed: (id, error, operationKind) => queueMicrotask(() => this.deliverCompletion({ high: 1n, low: id }, operationKind ?? 0, requestFailureResult(error), completion))
+        };
     }
-    observeCompletion(low, operationKind, promise) {
-        const id = { high: 1n, low };
-        void promise.then((result) => this.deliverCompletion(id, operationKind, result), (error) => this.deliverCompletion(id, operationKind, requestFailureResult(error)));
-        return id;
+    observedOperation(pending, operationKind) {
+        const id = { high: 1n, low: pending.id };
+        if (pending.promise !== undefined && !pending.hasObserver()) {
+            void pending.promise.then((result) => this.deliverCompletion(id, operationKind, result), (error) => this.deliverCompletion(id, operationKind, requestFailureResult(error)));
+        }
+        return this.requestSubmission(id, pending);
+    }
+    observeStatefulRequest(kind, entry, submit, completion) {
+        if (entry === undefined)
+            return this.observeStateful(kind, submit(), completion);
+        const id = { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: entry.id };
+        const receiver = {
+            operationCompleted: (_operationId, value) => queueMicrotask(() => this.deliverCompletion(id, kind, value, completion)),
+            operationFailed: (_operationId, error) => queueMicrotask(() => this.deliverCompletion(id, kind, requestFailureResult(error), completion))
+        };
+        if (completion === undefined) {
+            entry.setObserver(receiver);
+            submit();
+        }
+        else
+            submit(receiver);
+        return this.requestSubmission(id, entry);
     }
-    observeStateful(operationKind, pending) {
+    observeStateful(operationKind, pending, completion) {
         const id = { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id };
-        void pending.promise.then((result) => this.deliverCompletion(id, operationKind, result), (error) => this.deliverCompletion(id, operationKind, requestFailureResult(error)));
-        return id;
+        void pending.promise.then((result) => this.deliverCompletion(id, operationKind, result, completion), (error) => this.deliverCompletion(id, operationKind, requestFailureResult(error), completion));
+        return this.requestSubmission(id, pending);
     }
-    deliverCompletion(operationId, operationKind, result) {
-        if (this.completionHandler !== undefined) {
-            this.completionHandler({ operationId, terminalResult: result.terminalResult }, () => completionRecord(operationId, operationKind, result));
+    requestSubmission(id, requestOperation) {
+        return Object.defineProperty({ ...id }, 'requestOperation', {
+            value: requestOperation,
+            configurable: true
+        });
+    }
+    deliverCompletion(operationId, operationKind, result, completion = this
+        .completionHandler) {
+        if (completion !== undefined) {
+            completion({ operationId, terminalResult: result.terminalResult }, () => completionRecord(operationId, operationKind, result));
             return;
         }
         // The raw pull contract uses the existing infrastructure mailbox. A
@@ -1004,10 +1116,15 @@ class RawServiceSpot {
             lifecycleGeneration: this.lifecycleGeneration
         };
     }
-    async sendToChannel(channelName, parts, options) {
-        this.requireOpen();
-        void options;
-        return this.backend.sendToChannel(channelName, parts);
+    sendToChannel(channelName, parts, options) {
+        try {
+            this.requireOpen();
+            void options;
+            return this.backend.sendToChannel(channelName, parts);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
     requestToChannel(channelName, parts, options) {
         this.requireOpen();
@@ -1020,12 +1137,12 @@ class RawServiceSpot {
             : undefined);
         return this.backend.sendFromSpot(this.state, routeFence, parts);
     }
-    requestToSpot(targetNodeRid, targetSpotId, targetSpotGeneration, parts, options) {
+    requestToSpot(targetNodeRid, targetSpotId, targetSpotGeneration, parts, options, completion) {
         this.requireOpen();
         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, options?.onAdmitted);
+        return this.backend.requestFromSpot(this.state, routeFence, parts, options?.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options?.onAdmitted, options?.requestOperation, completion);
     }
     async publish(channelName, topic, parts, options) {
         this.requireOpen();
@@ -1331,13 +1448,16 @@ function completionRecord(operationId, operationKind, result) {
         kindData: 'kindData' in result ? (result.kindData ?? null) : null,
         terminalResult: result.terminalResult,
         failureErrno: result.failureCode,
+        ...('failureMessage' in result && result.failureMessage !== undefined
+            ? { failureMessage: result.failureMessage }
+            : {}),
         parts: payload === undefined
             ? []
             : payload.contentType === MULTIPART_CONTENT_TYPE
                 ? decodeMultipart(payload.payload)
                 : [runtime_message_1.ZLinkBufferMessage.from(payload.payload)],
-        reply: () => zlink_1.SubmitResult.InvalidState,
-        replyActorJoin: () => zlink_1.SubmitResult.NotSupported
+        reply: replyInvalidState,
+        replyActorJoin: replyActorJoinNotSupported
     };
 }
 function decodeMultipartRecord(runtime, record) {
@@ -1386,15 +1506,10 @@ function decodeMultipartRecord(runtime, record) {
                 const values = Array.isArray(parts) ? parts : [parts];
                 if (values.length === 0)
                     return zlink_1.SubmitResult.InvalidState;
-                runtime.replyService({
-                    sourceRoutingId: record.sourceRoutingId,
-                    ...(record.sourceRoute === undefined ? {} : { sourceRoute: record.sourceRoute }),
-                    requestSequence: record.requestSequence,
-                    ...(record.reply === undefined ? {} : { reply: record.reply })
-                }, values.map((value) => Buffer.from(messageBytesView(value))));
+                runtime.replyService(record, values.map(messagePayloadView));
                 return zlink_1.SubmitResult.Ok;
             },
-            replyActorJoin: () => zlink_1.SubmitResult.NotSupported
+            replyActorJoin: replyActorJoinNotSupported
         };
     }
     const header = record.parts[0];
@@ -1453,6 +1568,9 @@ function decodeMultipartRecord(runtime, record) {
 function releaseRecordApplicationJob() {
     this.applicationJobPermit?.close();
 }
+function replyInvalidState() {
+    return zlink_1.SubmitResult.InvalidState;
+}
 function replyActorJoinNotSupported() {
     return zlink_1.SubmitResult.NotSupported;
 }
@@ -1553,10 +1671,10 @@ function decodeStatefulRecord(record, stateful) {
             });
             return accepted ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.InvalidState;
         },
-        replyFailure(terminalResult, failureCode) {
+        replyFailure(terminalResult, failureCode, tail) {
             if (stateful.reply === undefined)
                 return zlink_1.SubmitResult.InvalidState;
-            return stateful.reply(terminalResult, failureCode)
+            return stateful.reply(terminalResult, failureCode, undefined, tail)
                 ? zlink_1.SubmitResult.Ok
                 : zlink_1.SubmitResult.InvalidState;
         }
@@ -1564,12 +1682,15 @@ function decodeStatefulRecord(record, stateful) {
 }
 function receiveIngressLifecycle(record) {
     const applicationJob = record.applicationJob;
-    return applicationJob === undefined
-        ? {}
-        : {
-            applicationJobPermit: applicationJob,
-            releaseRetainedIngress: () => applicationJob.close()
-        };
+    return {
+        ...(record.receivedAt === undefined ? {} : { receivedAt: record.receivedAt }),
+        ...(applicationJob === undefined
+            ? {}
+            : {
+                applicationJobPermit: applicationJob,
+                releaseRetainedIngress: () => applicationJob.close()
+            })
+    };
 }
 function prepareStatefulMailboxDispatch(signal) {
     const mailboxRecord = this.statefulMailboxRecord;
@@ -1660,32 +1781,17 @@ function encodeMultipart(parts) {
     const values = Array.isArray(parts) ? parts : [parts];
     if (values.length === 0)
         throw new TypeError('Multipart payload must contain at least one part.');
-    //  messageBytesView aliases the caller's buffer; the parts are consumed
-    //  synchronously by the copy loop below and never retained.
-    const bytes = values.map(messageBytesView);
-    let size = 4;
-    for (const part of bytes)
-        size += 4 + part.byteLength;
-    const payload = Buffer.alloc(size);
-    payload.writeUInt32BE(bytes.length, 0);
-    let offset = 4;
-    for (const part of bytes) {
-        payload.writeUInt32BE(part.byteLength, offset);
-        offset += 4;
-        payload.set(part, offset);
-        offset += part.byteLength;
-    }
     return {
         packetName: MULTIPART_PACKET_NAME,
         contentType: MULTIPART_CONTENT_TYPE,
-        payload
+        payload: (0, service_wire_m6a_codec_1.encodeMultipartPayload)(values.map(messagePayloadView))
     };
 }
 function encodeMultipartApplicationFrame(parts) {
     const values = Array.isArray(parts) ? parts : [parts];
     if (values.length === 0)
         throw new TypeError('Multipart payload must contain at least one part.');
-    return (0, service_wire_m6a_codec_1.encodeMultipartApplicationPayload)(values.map(messageBytesView), MULTIPART_PACKET_NAME, MULTIPART_CONTENT_TYPE);
+    return (0, service_wire_m6a_codec_1.encodeMultipartApplicationPayload)(values.map(messagePayloadView), MULTIPART_PACKET_NAME, MULTIPART_CONTENT_TYPE);
 }
 function decodeMultipart(payload) {
     return (0, service_wire_m6a_codec_1.decodeMultipartParts)(payload, runtime_message_1.ZLinkBufferMessage.fromOwned, closeMultipartMessage);
@@ -1696,12 +1802,10 @@ function closeMultipartMessage(part) {
 function borrowMultipartPart(part) {
     return part;
 }
-function messageBytesView(value) {
+function messagePayloadView(value) {
     if (typeof value === 'object' && 'data' in value) {
         return value.data();
     }
-    if (typeof value === 'string')
-        return Buffer.from(value);
     return value;
 }
 function requireRawReadyBatch(batch) {

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

@@ -4,6 +4,7 @@ exports.wrapSocket = wrapSocket;
 exports.nodeEventLoopPollerOf = nodeEventLoopPollerOf;
 exports.disconnectSocketPeer = disconnectSocketPeer;
 exports.isEndpointCloseIgnorableError = isEndpointCloseIgnorableError;
+const request_runtime_1 = require("../../foundation/request-runtime");
 const RegistrationBuilderPolicy_1 = require("../../../contracts/Configuration/RegistrationBuilderPolicy");
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const node_event_loop_poller_1 = require("./node-event-loop-poller");
@@ -18,10 +19,23 @@ function wrapSocket(nativeInstance, pollCompletion) {
     const eventLoopPoller = pollCompletion === undefined
         ? undefined
         : new node_event_loop_poller_1.ZLinkNodeEventLoopPoller(nativeInstance, pollCompletion, () => { });
+    const requests = new request_runtime_1.RequestRuntime();
+    const submitSocketRequest = (operation, payload, timeoutMs, recordReceived, onAdmitted, requestOperation, receiver) => {
+        const pending = requests.begin(timeoutMs, undefined, requestOperation);
+        (0, node_backend_adapter_support_1.submitBindingRequest)(operation, payload, timeoutMs, recordReceived, onAdmitted, pending, receiver ?? {
+            operationCompleted: (_id, parts) => {
+                if (!pending.reply(parts))
+                    (0, node_backend_adapter_support_1.closeBindingReply)(parts);
+            },
+            operationFailed: (_id, error) => pending.replyFailure(error)
+        });
+        return pending.promise;
+    };
     const adapter = {
         nativeInstance,
         receiveAdmission: undefined,
         async dispose() {
+            requests.close();
             eventLoopPoller?.dispose();
             (0, node_backend_adapter_support_1.closeBindingHandle)(nativeInstance);
         },
@@ -144,12 +158,12 @@ function wrapSocket(nativeInstance, pollCompletion) {
         },
         request(...args) {
             if (hasRoutedPeer) {
-                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);
+                const [routingId, payload, timeoutMs, onAdmitted, requestOperation, receiver] = args;
+                return submitSocketRequest(nativeInstance.request((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload, timeoutMs, undefined, onAdmitted, requestOperation, receiver);
             }
             if (hasRequest) {
-                const [payload, timeoutMs, onAdmitted] = args;
-                return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance.request(), payload, timeoutMs, adapter.receiveAdmission?.recordReceived, onAdmitted);
+                const [payload, timeoutMs, onAdmitted, requestOperation, receiver] = args;
+                return submitSocketRequest(nativeInstance.request(), payload, timeoutMs, adapter.receiveAdmission?.recordReceived, onAdmitted, requestOperation, receiver);
             }
             throw new TypeError('Backend request requires a DEALER or ROUTER socket.');
         },
@@ -201,8 +215,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, 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);
+        requestToSpot(targetRid, targetSpot, payload, timeoutMs, onAdmitted, requestOperation, receiver) {
+            return submitSocketRequest(nativeInstance.requestToSpot((0, node_backend_adapter_support_1.toNativeRoutingId)(targetRid), (0, node_backend_adapter_support_1.toNativeRoutingId)(targetSpot)), payload, timeoutMs, undefined, onAdmitted, requestOperation, receiver);
         },
         disconnectPeer(routingId) {
             disconnectSocketPeer(nativeInstance, (0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));