@zlink-systems/framework 0.11.0 → 0.12.0

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

@@ -20,7 +20,7 @@ class ZLinkDealerChannelClientTransport {
         (0, abort_1.throwIfAborted)(signal);
         // Call-scoped flow (spec 27 §4): the envelope flow pair does not outlive
         // this outbound call.
-        await (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.send(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, undefined, undefined, undefined, true, metadata)).submit());
+        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) {
@@ -28,7 +28,7 @@ class ZLinkDealerChannelClientTransport {
         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)(operation, 'channel request');
+        const reply = await (0, channel_multipart_1.submitRequestOperation)({ submit: () => operation.submit().reply }, 'channel request');
         try {
             return (0, channel_envelope_1.decodeChannelReply)(reply);
         }

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

@@ -0,0 +1,16 @@
+import type { Socket } from '@zlink-systems/zlink';
+/**
+ * Owns one binding public Poller and drives it from the socket's libuv
+ * readiness callback. PollCompletion is drained only by Poller.wait; the
+ * socket callback itself is only the event-loop wakeup.
+ */
+export declare class ZLinkNodeEventLoopPoller {
+    private readonly poller;
+    private readonly events;
+    private readableHandler;
+    private disposed;
+    constructor(socket: Socket, pollCompletion: boolean, readableHandler: () => void);
+    setReadableHandler(handler: () => void): void;
+    dispose(): void;
+    private readonly onReady;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkNodeEventLoopPoller = void 0;
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
+/**
+ * Owns one binding public Poller and drives it from the socket's libuv
+ * readiness callback. PollCompletion is drained only by Poller.wait; the
+ * socket callback itself is only the event-loop wakeup.
+ */
+class ZLinkNodeEventLoopPoller {
+    poller = node_backend_adapter_support_1.zlink.createPoller();
+    events = node_backend_adapter_support_1.zlink.createPollEvents(1);
+    readableHandler;
+    disposed = false;
+    constructor(socket, pollCompletion, readableHandler) {
+        this.readableHandler = readableHandler;
+        try {
+            const pollEvents = [node_backend_adapter_support_1.zlink.PollEventFlag.PollIn];
+            if (pollCompletion)
+                pollEvents.push(node_backend_adapter_support_1.zlink.PollEventFlag.PollCompletion);
+            this.poller.add(socket, pollEvents, 0);
+            socket.setReadableHandler(this.onReady);
+        }
+        catch (error) {
+            this.events.close();
+            this.poller.close();
+            throw error;
+        }
+    }
+    setReadableHandler(handler) {
+        this.readableHandler = handler;
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.events.close();
+        this.poller.close();
+    }
+    onReady = () => {
+        if (this.disposed)
+            return;
+        const ready = this.poller.wait(this.events, 0);
+        if (ready === 0 || this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn)) {
+            this.readableHandler();
+        }
+    };
+}
+exports.ZLinkNodeEventLoopPoller = ZLinkNodeEventLoopPoller;

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

@@ -4,6 +4,7 @@ exports.ZLinkNodeRawBindingPort = void 0;
 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");
+const node_event_loop_poller_1 = require("./node-event-loop-poller");
 class ZLinkNodeRawBindingPort {
     sharedContext;
     constructor(sharedContext) {
@@ -78,12 +79,15 @@ class NodeRawSocketPort {
     socket;
     endpoints = new Set();
     monitors = new Set();
-    readablePoller = (0, zlink_1.createPoller)();
-    readableEvents = (0, zlink_1.createPollEvents)(1);
+    eventLoopPoller;
     closed = false;
     constructor(socket) {
         this.socket = socket;
-        this.readablePoller.add(socket, [zlink_1.PollEventFlag.PollIn], 0);
+        this.eventLoopPoller = new node_event_loop_poller_1.ZLinkNodeEventLoopPoller(socket, true, () => { });
+    }
+    setReadableHandler(handler) {
+        this.requireOpen();
+        this.eventLoopPoller.setReadableHandler(handler);
     }
     bind(endpoint) {
         this.requireOpen();
@@ -120,6 +124,12 @@ class NodeRawSocketPort {
         if (this.closed)
             return;
         const failures = [];
+        try {
+            this.eventLoopPoller.dispose();
+        }
+        catch (error) {
+            failures.push(error);
+        }
         for (const monitor of [...this.monitors].reverse()) {
             try {
                 monitor.close();
@@ -145,24 +155,6 @@ class NodeRawSocketPort {
             }
         }
         this.endpoints.clear();
-        try {
-            this.readablePoller.remove(this.socket);
-        }
-        catch (error) {
-            failures.push(error);
-        }
-        try {
-            this.readableEvents.close();
-        }
-        catch (error) {
-            failures.push(error);
-        }
-        try {
-            this.readablePoller.close();
-        }
-        catch (error) {
-            failures.push(error);
-        }
         try {
             this.socket.close();
         }
@@ -179,21 +171,6 @@ class NodeRawSocketPort {
         if (this.closed)
             throw new Error('Raw socket is closed.');
     }
-    receiveRecord(dontWait) {
-        const timeoutMs = dontWait ? 0 : -1;
-        try {
-            if (this.readablePoller.wait(this.readableEvents, timeoutMs) <= 0
-                || !this.readableEvents.hasEvent(0, zlink_1.PollEventFlag.PollIn)) {
-                return undefined;
-            }
-        }
-        catch (error) {
-            if ((0, node_backend_adapter_support_1.isPollerInterruptedError)(error))
-                return undefined;
-            throw error;
-        }
-        return receiveRecord(this.socket, true);
-    }
 }
 class NodeRawRouterPort extends NodeRawSocketPort {
     nextIncomingRequestSequence = 1n;
@@ -222,14 +199,17 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     async send(targetRid, parts) {
         this.requireOpen();
-        await appendSendParts(this.socket.send(bindingRoutingId(targetRid)), parts).submit();
+        const submission = appendSendParts(this.socket.send(bindingRoutingId(targetRid)), parts).submit();
+        if (submission.result === zlink_1.SubmitResult.Backpressured) {
+            await submission.admitted;
+        }
     }
     async request(targetRid, parts, timeoutMs) {
         this.requireOpen();
         try {
             const replies = await appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
                 .timeout(timeoutMs)
-                .submit();
+                .submit().reply;
             return copyAndClose(replies);
         }
         catch (error) {
@@ -259,16 +239,19 @@ class NodeRawDealerPort extends NodeRawSocketPort {
     }
     async send(parts) {
         this.requireOpen();
-        await appendSendParts(this.socket.send(), parts).submit();
+        const submission = appendSendParts(this.socket.send(), parts).submit();
+        if (submission.result === zlink_1.SubmitResult.Backpressured) {
+            await submission.admitted;
+        }
     }
     async request(parts, timeoutMs) {
         this.requireOpen();
-        const replies = await appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
+        const replies = await appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit().reply;
         return copyAndClose(replies);
     }
     receive(dontWait = false) {
         this.requireOpen();
-        return this.receiveRecord(dontWait);
+        return receiveRecord(this.socket, dontWait);
     }
 }
 class NodeRawMonitorPort {

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

@@ -36,7 +36,11 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private runtime?;
     private stateful?;
     private readyHandler?;
-    private pollTimer?;
+    private maintenanceTimer?;
+    private pumping;
+    private readable;
+    private readonly onReadable;
+    private readonly onMaintenance;
     private nextPeerIntent;
     private closed;
     private objectRole;
@@ -49,11 +53,6 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private protocolError?;
     private messageFollowHandler?;
     private readonly peerDisconnectedHandlers;
-    private readonly receiveBatchBudget;
-    private observedPumpSourceRoutingId?;
-    private observedPumpByteCount;
-    private readonly observePump;
-    private takePumpObservation;
     constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined);
     configureObjectPlacement(options: {
         readonly role: ServiceNodeDescriptor['objectRole'];
@@ -239,8 +238,9 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     clearSpotSubscriptions(state: ServiceSpotState): void;
     private createDescriptor;
     private resolveAdvertisedEndpoint;
-    private schedulePoll;
-    private poll;
+    private scheduleMaintenance;
+    private pump;
+    private isClosed;
     private notifyReady;
     private observeCompletion;
     private observeStateful;

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

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkNodeRawMeshBackend = void 0;
 exports.genericOperationFailure = genericOperationFailure;
 const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:timers/promises");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const contracts_1 = require("../../../contracts");
 const framework_errors_internal_1 = require("../../framework-errors-internal");
 const zlink_1 = require("@zlink-systems/zlink");
 const runtime_values_1 = require("../runtime-values");
+const runtime_message_1 = require("../runtime-message");
 const service_runtime_contracts_1 = require("../../foundation/service-runtime-contracts");
 const operation_registry_1 = require("../../foundation/operation-registry");
 const raw_service_mesh_runtime_1 = require("../../foundation/raw-service-mesh-runtime");
@@ -22,37 +24,15 @@ const MULTIPART_PACKET_NAME = service_wire_constants_generated_1.SERVICE_FRAMEWO
 const MULTIPART_CONTENT_TYPE = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 const MAX_DRAIN_RECORDS = 64;
-// A timer is only a no-data backoff.  Once the binding has reported readable
-// work, continue from the next event-loop turn so a full socket does not wait
-// for an arbitrary timer cadence between batches.
-const MESH_BACKEND_IDLE_POLL_INTERVAL_MS = 1;
-const MESH_RECEIVE_BATCH_BYTE_LIMIT = 4 * 1024 * 1024;
-const MESH_RECEIVE_BATCH_TIME_LIMIT_MS = 2;
+// Preserve the existing monitor/admission/liveness cadence. Only the binding
+// readable handler admits receive work; this timer never probes the socket.
+const MESH_BACKEND_MAINTENANCE_INTERVAL_MS = 1;
 /**
  * Conservative Actor Join admission cap for relocation state chunks (spec 15
  * §4.2): a stable lower bound safe on any deployment, never lowered on
  * recompute. Matches the source's own conservative chunk floor.
  */
 const ACTOR_JOIN_ADVERTISED_RECEIVE_CHUNK_LIMIT_BYTES = 32 * 1024;
-class ZLinkMeshReceiveBatchBudget {
-    peerMessages = new Map();
-    peerBytes = new Map();
-    startedAtMs = 0;
-    reset(nowMs) {
-        this.peerMessages.clear();
-        this.peerBytes.clear();
-        this.startedAtMs = nowMs;
-    }
-    record(peer, byteCount, nowMs) {
-        const messages = (this.peerMessages.get(peer) ?? 0) + 1;
-        const bytes = (this.peerBytes.get(peer) ?? 0) + byteCount;
-        this.peerMessages.set(peer, messages);
-        this.peerBytes.set(peer, bytes);
-        return messages >= MAX_DRAIN_RECORDS
-            || bytes >= MESH_RECEIVE_BATCH_BYTE_LIMIT
-            || nowMs - this.startedAtMs >= MESH_RECEIVE_BATCH_TIME_LIMIT_MS;
-    }
-}
 /**
  * M6A MeshNode backend. Stateful Spot/Actor entry points stay explicit until
  * their owning M6B runtime is connected; topology and node/channel dispatch do
@@ -77,7 +57,18 @@ class ZLinkNodeRawMeshBackend {
     runtime;
     stateful;
     readyHandler;
-    pollTimer;
+    maintenanceTimer;
+    pumping = false;
+    readable = false;
+    onReadable = () => {
+        this.readable = true;
+        if (!this.closed && !this.pumping)
+            void this.pump();
+    };
+    onMaintenance = () => {
+        this.maintenanceTimer = undefined;
+        void this.pump();
+    };
     nextPeerIntent = 1n;
     closed = false;
     objectRole = 'none';
@@ -90,19 +81,6 @@ class ZLinkNodeRawMeshBackend {
     protocolError;
     messageFollowHandler;
     peerDisconnectedHandlers = new Set();
-    receiveBatchBudget = new ZLinkMeshReceiveBatchBudget();
-    observedPumpSourceRoutingId;
-    observedPumpByteCount = 0;
-    observePump = (sourceRoutingId, byteCount) => {
-        this.observedPumpSourceRoutingId = sourceRoutingId;
-        this.observedPumpByteCount = byteCount;
-    };
-    takePumpObservation() {
-        const sourceRoutingId = this.observedPumpSourceRoutingId;
-        if (sourceRoutingId === undefined)
-            return undefined;
-        return { sourceRoutingId, byteCount: this.observedPumpByteCount };
-    }
     constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed) {
         this.meshName = meshName;
         this.bindingPort = bindingPort;
@@ -232,7 +210,14 @@ class ZLinkNodeRawMeshBackend {
         }
         this.stateful.setMessageFollowHandler((record) => this.messageFollowHandler?.(record));
         this.runtime = runtime;
-        this.schedulePoll();
+        try {
+            runtime.setReadableHandler(this.onReadable);
+        }
+        catch (error) {
+            this.close();
+            throw error;
+        }
+        this.scheduleMaintenance();
     }
     setMessageFollowHandler(handler) {
         this.messageFollowHandler = handler;
@@ -253,9 +238,9 @@ class ZLinkNodeRawMeshBackend {
         if (this.closed)
             return;
         this.closed = true;
-        if (this.pollTimer !== undefined)
-            clearTimeout(this.pollTimer);
-        this.pollTimer = undefined;
+        if (this.maintenanceTimer !== undefined)
+            clearTimeout(this.maintenanceTimer);
+        this.maintenanceTimer = undefined;
         this.stateful?.close();
         this.stateful = undefined;
         this.runtime?.close();
@@ -372,7 +357,7 @@ class ZLinkNodeRawMeshBackend {
         return this.requireRuntime().isPeerRouteReady(String(targetRid), lifecycleGeneration);
     }
     async sendToNode(targetRid, parts) {
-        return await this.requireRuntime().sendToNode(String(targetRid), encodeMultipart(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+        return await this.requireRuntime().sendToNode(String(targetRid), encodeMultipartApplicationFrame(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
     }
     async sendInfrastructureControl(targetRid, record) {
         return await this.requireRuntime().sendService(String(targetRid), (Array.isArray(record) ? record : [record]).map(value => Buffer.from(value))) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
@@ -384,14 +369,14 @@ class ZLinkNodeRawMeshBackend {
         return await this.requireRuntime().requestService(String(targetRid), frames.map(frame => Buffer.from(frame)), options?.timeoutMs ?? 30_000);
     }
     requestToNode(targetRid, parts, options) {
-        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipart(parts), options?.timeoutMs ?? 30_000);
+        const pending = this.requireRuntime().requestToNode(String(targetRid), encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? 30_000);
         return this.observeCompletion(pending.id, service_runtime_contracts_1.OperationKind.NodeRequest, pending.promise);
     }
     async sendToChannel(channelName, parts) {
-        return await this.requireRuntime().sendToChannel(channelName, encodeMultipart(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
+        return await this.requireRuntime().sendToChannel(channelName, encodeMultipartApplicationFrame(parts)) ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.NotConnected;
     }
     requestToChannel(channelName, parts, options) {
-        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipart(parts), options?.timeoutMs ?? 30_000);
+        const pending = this.requireRuntime().requestToChannel(channelName, encodeMultipartApplicationFrame(parts), options?.timeoutMs ?? 30_000);
         if (pending === undefined) {
             return this.enqueueImmediateFailure(service_runtime_contracts_1.OperationKind.ChannelRequest, zlink_1.RequestResult.NotFound);
         }
@@ -768,49 +753,38 @@ class ZLinkNodeRawMeshBackend {
         }
         return result;
     }
-    schedulePoll(delayMs = MESH_BACKEND_IDLE_POLL_INTERVAL_MS) {
-        if (this.closed || this.pollTimer !== undefined)
+    scheduleMaintenance() {
+        if (this.closed || this.maintenanceTimer !== undefined)
             return;
-        this.pollTimer = setTimeout(async () => {
-            this.pollTimer = undefined;
-            try {
-                const received = await this.poll();
-                // A zero-delay timer yields to I/O and other ready work first without
-                // inserting the idle polling interval between readable batches.
-                delayMs = received ? 0 : MESH_BACKEND_IDLE_POLL_INTERVAL_MS;
-            }
-            finally {
-                if (!this.closed)
-                    this.schedulePoll(delayMs);
-            }
-        }, delayMs);
+        this.maintenanceTimer = setTimeout(this.onMaintenance, MESH_BACKEND_MAINTENANCE_INTERVAL_MS);
     }
-    async poll() {
-        const runtime = this.runtime;
-        if (runtime === undefined)
-            return false;
-        let received = false;
-        await runtime.drainMonitorEvents();
-        this.receiveBatchBudget.reset(performance.now());
-        for (;;) {
-            this.observedPumpSourceRoutingId = undefined;
-            const result = await runtime.pumpOne(performance.now(), this.observePump);
-            if (result === 'noData')
-                break;
-            received = true;
-            if (result === 'application')
-                this.readyHandler?.(service_runtime_contracts_1.ReadyDomain.Application);
-            const observation = this.takePumpObservation();
-            // Core ROUTER advances its fair-queue cursor after each complete
-            // multipart message, so the next poll resumes from the following pipe.
-            if (observation !== undefined
-                && this.receiveBatchBudget.record(observation.sourceRoutingId, observation.byteCount, performance.now()))
-                break;
+    async pump() {
+        if (this.isClosed() || this.pumping)
+            return;
+        this.pumping = true;
+        if (this.maintenanceTimer !== undefined)
+            clearTimeout(this.maintenanceTimer);
+        this.maintenanceTimer = undefined;
+        try {
+            do {
+                const receiveReady = this.readable;
+                this.readable = false;
+                const more = await this.requireRuntime().pumpBatch(receiveReady);
+                if (more) {
+                    // Yield only after actual progress, retaining readiness across the
+                    // existing batch limits until receive reports no data.
+                    this.readable = true;
+                    await (0, promises_1.setImmediate)();
+                }
+            } while (!this.closed && this.readable);
         }
-        await runtime.announceExpectedPeers();
-        await runtime.tickLiveness();
-        this.notifyReady();
-        return received;
+        finally {
+            this.pumping = false;
+            this.scheduleMaintenance();
+        }
+    }
+    isClosed() {
+        return this.closed;
     }
     notifyReady() {
         const runtime = this.runtime;
@@ -892,14 +866,7 @@ class ZLinkNodeRawMeshBackend {
             if (claim === undefined)
                 break;
             const owner = readyOwner(claim.owner, this.routingId, this.stateful, domain);
-            batch.push(owner, new MailboxClaim(runtime, claim, () => {
-                // A receive batch may intentionally consume fewer records than the
-                // mailbox claim. Releasing the claim re-queues the remainder, so
-                // expose that newly ready work to the dispatch pump.
-                if (runtime.mailbox.pendingMessages(domain) > 0) {
-                    this.readyHandler?.(domain === 'infrastructure' ? service_runtime_contracts_1.ReadyDomain.Infrastructure : service_runtime_contracts_1.ReadyDomain.Application);
-                }
-            }));
+            batch.push(owner, new MailboxClaim(runtime, claim));
         }
     }
     requireRuntime() {
@@ -1100,7 +1067,7 @@ class RawStreamSessionService {
             submit = submit.message(parts[index]);
         }
         try {
-            await submit.submit();
+            await submit.submit().admitted;
             return true;
         }
         catch (error) {
@@ -1161,29 +1128,37 @@ class RawReadyBatch {
     }
 }
 class RawReceiveBatch {
-    messageCapacity;
+    capacity;
     partCapacity;
-    constructor(messageCapacity, partCapacity) {
-        this.messageCapacity = messageCapacity;
+    receiveCapacity;
+    constructor(capacity, partCapacity) {
+        this.capacity = capacity;
         this.partCapacity = partCapacity;
-        if ([messageCapacity, partCapacity].some(value => !Number.isInteger(value) || value < 1)) {
+        if ([capacity, partCapacity].some(value => !Number.isInteger(value) || value < 1)) {
             throw new RangeError('Receive batch capacities must be positive.');
         }
+        this.receiveCapacity = capacity;
+    }
+    get messageCapacity() {
+        return this.receiveCapacity;
+    }
+    reset(messageCapacity = this.capacity) {
+        if (!Number.isInteger(messageCapacity) || messageCapacity < 1 || messageCapacity > this.capacity) {
+            throw new RangeError('Receive limit must be within the batch capacity.');
+        }
+        this.receiveCapacity = messageCapacity;
     }
-    reset() { }
     close() { }
 }
 class MailboxClaim {
     runtime;
     claim;
-    onRelease;
     consumed = false;
     released = false;
     remaining = [];
-    constructor(runtime, claim, onRelease) {
+    constructor(runtime, claim) {
         this.runtime = runtime;
         this.claim = claim;
-        this.onRelease = onRelease;
     }
     recvBatch(batch) {
         if (this.consumed)
@@ -1206,6 +1181,13 @@ class MailboxClaim {
                 }
                 this.runtime.mailbox.releaseClaimedPayload(record);
                 this.remaining = this.claim.records.slice(index + 1);
+                // Nothing was transferred to the receive caller when decoding throws.
+                // Earlier records therefore still belong to this failed batch.
+                for (const decoded of records) {
+                    for (const part of decoded.parts)
+                        part.close();
+                    decoded.releaseRetainedIngress?.();
+                }
                 throw error;
             }
             const nextParts = decoded.parts.length;
@@ -1227,7 +1209,6 @@ class MailboxClaim {
             return;
         this.released = true;
         this.runtime.mailbox.release(this.claim, this.remaining);
-        this.onRelease?.();
     }
 }
 class CompletionClaim {
@@ -1371,7 +1352,7 @@ function decodeMultipartRecord(runtime, record) {
         reply(parts) {
             if (record.correlation === undefined)
                 return zlink_1.SubmitResult.InvalidState;
-            runtime.reply(record, encodeMultipart(parts));
+            runtime.reply(record, encodeMultipartApplicationFrame(parts));
             return zlink_1.SubmitResult.Ok;
         },
         replyActorJoin: () => zlink_1.SubmitResult.NotSupported
@@ -1630,7 +1611,19 @@ function decodeApplicationEnvelope(frame) {
 }
 function decodeMultipart(payload) {
     const buffers = decodeMultipartBuffers(payload);
-    return buffers.map(part => zlink_1.Message.from(part));
+    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;
+    }
 }
 function decodeMultipartBuffers(payload) {
     const bytes = Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);

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

@@ -1,9 +1,10 @@
 import type { ZLinkBackendObject } from '../contracts';
+import { ZLinkNodeEventLoopPoller } from './node-event-loop-poller';
 export declare function wrapSocket<T extends {
     close(): void;
-}>(nativeInstance: T): T & ZLinkBackendObject;
+}>(nativeInstance: T, pollCompletion?: boolean): T & ZLinkBackendObject;
+export declare function nodeEventLoopPollerOf(socket: object): ZLinkNodeEventLoopPoller;
 export declare function disconnectStreamPeer(socket: {
     disconnectRid(routingId: unknown): void;
 }, routingId: unknown): void;
-export declare function isDisconnectRouteNotFoundError(error: unknown): boolean;
 export declare function isEndpointCloseIgnorableError(error: unknown): boolean;