@zlink-systems/framework 0.29.1 → 0.30.0

package/src/runtime/backend/node/node-backend-adapter-factory.ts

@@ -1,4 +1,9 @@
-import type { Context, CoreHwmBudgetSnapshot, TopicMessage } from '@zlink-systems/zlink';
+import type {
+  Context,
+  CoreHwmBudgetSnapshot,
+  ReceiveFlowState,
+  TopicMessage
+} from '@zlink-systems/zlink';
 import type { ZLinkCoreHwmOptions } from '../../../contracts/Configuration';
 import type {
   ZLinkBackendAdapterFactory,
@@ -60,10 +65,12 @@ class ZLinkNodeChannelBackendAdapter implements ZLinkChannelBackendAdapter {
   }
 
   createRouterSocket(context: ZLinkBackendContext): ZLinkBackendRouterSocket {
-    return wrapSocket(
-      zlink.createRouterSocket(asNodeContext(context)),
-      true
-    ) as unknown as ZLinkBackendRouterSocket;
+    const socket = zlink.createRouterSocket(asNodeContext(context));
+    const adapter = wrapSocket(socket, true);
+    adapter.setReceiveFlowState = (state: ReceiveFlowState): void => {
+      socket.setReceiveFlowState(state);
+    };
+    return adapter as unknown as ZLinkBackendRouterSocket;
   }
 
   createPublisherSocket(context: ZLinkBackendContext): ZLinkBackendPublisherSocket {

package/src/runtime/backend/node/node-backend-adapter-support.ts

@@ -123,6 +123,14 @@ export async function submitBindingAsyncSend(
   operation: ZLinkBindingAsyncSendOperation,
   payload: unknown
 ): Promise<void> {
+  const submission = submitBindingSend(operation, payload);
+  if (submission.result === SubmitResult.Backpressured) await submission.admitted;
+}
+
+export function submitBindingSend(
+  operation: ZLinkBindingAsyncSendOperation,
+  payload: unknown
+): import('../raw-binding-port').ZLinkRawSendSubmission {
   let submission: import('@zlink-systems/zlink').SendSubmission;
   try {
     let current: ZLinkBindingAsyncSendSubmitOperation | undefined;
@@ -137,12 +145,14 @@ export async function submitBindingAsyncSend(
     throw translateBindingResultError(error, 'submit');
   }
   if (submission.result === SubmitResult.Backpressured) {
-    try {
-      await submission.admitted;
-    } catch (error) {
-      throw translateBindingResultError(error, 'completion');
-    }
+    return {
+      result: submission.result,
+      admitted: submission.admitted.catch((error) => {
+        throw translateBindingResultError(error, 'completion');
+      })
+    };
   }
+  return { result: SubmitResult.Ok, admitted: submission.admitted };
 }
 
 export function submitBindingSyncSend(
@@ -166,7 +176,8 @@ export function submitBindingSyncSend(
 export async function submitBindingRequest(
   operation: ZLinkBindingRequestOperation,
   payload: unknown,
-  timeoutMs: number | undefined
+  timeoutMs: number | undefined,
+  recordReceived?: () => void
 ): Promise<readonly unknown[]> {
   const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
   try {
@@ -184,7 +195,7 @@ export async function submitBindingRequest(
     if (timeoutMs !== undefined) {
       current = current.timeout(timeoutMs);
     }
-    return await bindingRequestReply(current.submit(), deadlineMs);
+    return await bindingRequestReply(current.submit(), deadlineMs, recordReceived);
   } catch (error) {
     throw translateBindingResultError(error);
   }
@@ -192,7 +203,8 @@ export async function submitBindingRequest(
 
 export async function bindingRequestReply(
   submission: import('@zlink-systems/zlink').RequestSubmission,
-  deadlineMs: number | undefined
+  deadlineMs: number | undefined,
+  recordReceived?: () => void
 ): Promise<import('@zlink-systems/zlink').Message[]> {
   const reply = submission.reply;
   if (submission.result === SubmitResult.Backpressured) {
@@ -202,13 +214,22 @@ export async function bindingRequestReply(
         'Request',
         deadlineMs
       );
+      recordReceived?.();
       return replies;
     } catch (error) {
-      void reply.then(closeBindingReply, () => undefined);
+      void reply.then(
+        (parts) => {
+          recordReceived?.();
+          closeBindingReply(parts);
+        },
+        () => undefined
+      );
       throw error;
     }
   }
-  return reply;
+  const replies = await reply;
+  recordReceived?.();
+  return replies;
 }
 
 export function closeBindingReply(
@@ -248,25 +269,6 @@ export function isContextTerminatedError(error: unknown): boolean {
   return error instanceof Error && /context was terminated/i.test(error.message);
 }
 
-export function disableSocketLinger(target: unknown): void {
-  if (
-    target !== null &&
-    typeof target === 'object' &&
-    'options' in target &&
-    typeof target.options === 'object' &&
-    target.options !== null &&
-    'linger' in target.options
-  ) {
-    try {
-      (target.options as { linger: number }).linger = 0;
-    } catch (error) {
-      if (!isContextTerminatedError(error)) {
-        throw error;
-      }
-    }
-  }
-}
-
 export function toNativeRoutingId(routingId: unknown): unknown {
   if (typeof routingId === 'string') return zlink.RoutingId.from(routingId);
   const toHex = (routingId as { readonly toHex?: unknown } | null)?.toHex;

package/src/runtime/backend/node/node-mesh-backend-adapter.ts

@@ -10,15 +10,7 @@ import type { Context } from '@zlink-systems/zlink';
 export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
   createMeshNode(
     context: ZLinkBackendContext,
-    options: {
-      readonly meshName: string;
-      readonly routingId?: string;
-      readonly receiveTimeoutMs?: number;
-      readonly trustProfile?: string;
-      readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
-      readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
-      readonly peerAdmissionSealed?: () => boolean;
-    }
+    options: Parameters<ZLinkMeshBackendAdapter['createMeshNode']>[1]
   ): ZLinkBackendMeshNode {
     if (options.trustProfile !== undefined) {
       throw new Error(
@@ -37,7 +29,8 @@ export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
       new ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs),
       options.applicationJobQueue,
       options.applicationJobReceiveFlowFailureSink,
-      options.peerAdmissionSealed
+      options.peerAdmissionSealed,
+      options.infrastructureTaskRunner
     );
   }
 }

package/src/runtime/backend/node/node-raw-binding-port.ts

@@ -22,7 +22,8 @@ import {
 import {
   translateBindingResultError,
   bindingRequestReply,
-  submitBindingAsyncSend
+  submitBindingAsyncSend,
+  submitBindingSend
 } from './node-backend-adapter-support';
 import { isEndpointCloseIgnorableError } from './node-socket-backend-adapter';
 import { ZLinkNodeEventLoopPoller } from './node-event-loop-poller';
@@ -171,13 +172,6 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
     this.endpoints.delete(`connect\0${endpoint}`);
   }
 
-  setReceiveFlowState(state: 'running' | 'paused'): void {
-    this.requireOpen();
-    this.socket.setReceiveFlowState(
-      state === 'paused' ? ReceiveFlowState.PAUSED : ReceiveFlowState.RUNNING
-    );
-  }
-
   monitor(): ZLinkRawMonitorPort {
     this.requireOpen();
     const nativeMonitor = this.socket.monitorOpen();
@@ -232,6 +226,14 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
 
 class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLinkRawRouterPort {
   private nextIncomingRequestSequence = 1n;
+
+  setReceiveFlowState(state: 'running' | 'paused'): void {
+    this.requireOpen();
+    this.socket.setReceiveFlowState(
+      state === 'paused' ? ReceiveFlowState.PAUSED : ReceiveFlowState.RUNNING
+    );
+  }
+
   disconnectRid(routingId: string): void {
     this.requireOpen();
     (
@@ -273,10 +275,17 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
     return submitBindingAsyncSend(this.socket.send(bindingRoutingId(targetRid)), parts);
   }
 
+  submitSend(targetRid: string, parts: readonly Uint8Array[]) {
+    this.requireOpen();
+    requireParts(parts);
+    return submitBindingSend(this.socket.send(bindingRoutingId(targetRid)), parts);
+  }
+
   async request(
     targetRid: string,
     parts: readonly Uint8Array[],
-    timeoutMs: number
+    timeoutMs: number,
+    recordReceived?: () => void
   ): Promise<readonly Buffer[]> {
     this.requireOpen();
     const deadlineMs = performance.now() + timeoutMs;
@@ -289,7 +298,7 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
       throw translateBindingResultError(error, 'submit');
     }
     try {
-      const replies = await bindingRequestReply(submission, deadlineMs);
+      const replies = await bindingRequestReply(submission, deadlineMs, recordReceived);
       return copyAndClose(replies);
     } catch (error) {
       throw translateBindingResultError(error, 'completion');

package/src/runtime/backend/node/node-raw-mesh-backend.ts

@@ -17,6 +17,7 @@ import {
   type SubmitResult as SubmitResultValue
 } from '@zlink-systems/zlink';
 import { randomBytes } from 'node:crypto';
+import type { ZLinkMeshCompletionHandler } from '../mesh-completion-table';
 import { setImmediate as yieldToIO } from 'node:timers/promises';
 import { type RoutingId, ZLinkFrameworkException } from '../../../contracts';
 
@@ -32,7 +33,6 @@ import {
   ZLINK_MAX_CAPACITY,
   ZLINK_MAX_PUBLIC_WEIGHT
 } from '../../../contracts/Configuration/RegistrationBuilderPolicy';
-import { shouldCompactBackingArray } from '../../admission';
 import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
 import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-reporter';
 import { ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE } from '../../foundation/operation-identity';
@@ -91,6 +91,7 @@ import type {
   ServiceActorCreateRecord,
   ServiceDirectSpotRouteFence,
   ServiceInstanceActivationTarget,
+  ServiceInstanceColdActivationTarget,
   ServiceInstanceRouteFence,
   ServiceRetiredBoundSessionRouteFence,
   ServiceSpotRouteFence,
@@ -170,9 +171,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       readonly lifecycleGeneration?: bigint;
     }
   >();
-  private readonly completions: Array<PendingCompletion | undefined> = [];
-  private completionHead = 0;
-  private completionCount = 0;
+  private completionHandler?: ZLinkMeshCompletionHandler;
   private readonly routingId: string;
   private readonly lifecycleGeneration: bigint;
   private bindEndpoint?: string;
@@ -231,7 +230,8 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readonly bindingPort: ZLinkRawBindingPort,
     private readonly applicationJobQueue?: ApplicationJobQueuePort,
     private readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void,
-    private readonly peerAdmissionSealed?: () => boolean
+    private readonly peerAdmissionSealed?: () => boolean,
+    private readonly infrastructureTaskRunner?: import('../../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner
   ) {
     if (meshName.length === 0) throw new TypeError('MeshName must be non-empty.');
     if (routingId === undefined || routingId.length === 0) {
@@ -321,7 +321,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   }
 
   async sendToMissingInstanceSpot(
-    target: ServiceInstanceActivationTarget,
+    target: ServiceInstanceColdActivationTarget,
     parts: MessageLike | readonly MessageLike[],
     deadlineUnixMs: bigint,
     sourceSpotId?: string,
@@ -338,7 +338,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   }
 
   requestToMissingInstanceSpot(
-    target: ServiceInstanceActivationTarget,
+    target: ServiceInstanceColdActivationTarget,
     parts: MessageLike | readonly MessageLike[],
     deadlineUnixMs: bigint,
     sourceSpotId?: string,
@@ -386,6 +386,8 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       resolveAdvertisedEndpoint: (boundEndpoint) => this.resolveAdvertisedEndpoint(boundEndpoint),
       bindingPort: this.bindingPort,
       applicationJobQueue: this.requireApplicationJobQueue(),
+      onReceiveReady: () => this.onReadable(true, false),
+      infrastructureTaskRunner: this.infrastructureTaskRunner,
       peerAdmissionSealed: this.peerAdmissionSealed,
       onReceiveFlowConfigFailure: this.applicationJobReceiveFlowFailureSink,
       onMailboxReady: (domain) =>
@@ -481,7 +483,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     this.stateful = undefined;
     this.runtime?.close();
     this.runtime = undefined;
-    this.clearCompletions();
     this.closed = true;
   }
 
@@ -730,7 +731,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       drainingPeerCount: peers.filter((peer) => peer.descriptor.state === 'draining').length,
       pendingApplicationMessages: BigInt(this.runtime?.mailbox.pendingMessages('application') ?? 0),
       pendingInfrastructureMessages: BigInt(
-        (this.runtime?.mailbox.pendingMessages('infrastructure') ?? 0) + this.completionCount
+        this.runtime?.mailbox.pendingMessages('infrastructure') ?? 0
       ),
       pendingBytes: BigInt(
         (this.runtime?.mailbox.pendingBytes('application') ?? 0) +
@@ -846,6 +847,10 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     };
   }
 
+  setCompletionHandler(handler: ZLinkMeshCompletionHandler): void {
+    this.completionHandler = handler;
+  }
+
   setReadyHandler(handler: (readyDomains: number) => number): void {
     this.readyHandler = handler;
     this.notifyReady();
@@ -869,7 +874,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   } {
     const target = requireRawReadyBatch(batch);
     if ((domains & ReadyDomain.Infrastructure) !== 0) {
-      this.drainCompletions(target);
       this.drainMailbox('infrastructure', target);
     }
     if ((domains & ReadyDomain.Application) !== 0) {
@@ -878,7 +882,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     const runtime = this.runtime;
     const infrastructureResidue =
       (domains & ReadyDomain.Infrastructure) !== 0 &&
-      (this.completionCount > 0 || (runtime?.mailbox.pendingMessages('infrastructure') ?? 0) > 0);
+      (runtime?.mailbox.pendingMessages('infrastructure') ?? 0) > 0;
     const applicationResidue =
       (domains & ReadyDomain.Application) !== 0 &&
       (runtime?.mailbox.pendingMessages('application') ?? 0) > 0;
@@ -1391,7 +1395,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): MeshOperationId {
     const binding = this.requireStateful().registry.binding(actor);
     if (binding === undefined) {
-      return this.enqueueImmediateFailure(OperationKind.StreamUnbind, RequestResult.NotFound);
+      return this.observeImmediateFailure(OperationKind.StreamUnbind, RequestResult.NotFound);
     }
     return this.observeStateful(
       OperationKind.StreamUnbind,
@@ -1559,7 +1563,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   private notifyReady(): void {
     const runtime = this.runtime;
     let domains = ReadyDomain.None;
-    if (this.completionCount > 0 || (runtime?.mailbox.pendingMessages('infrastructure') ?? 0) > 0) {
+    if ((runtime?.mailbox.pendingMessages('infrastructure') ?? 0) > 0) {
       domains |= ReadyDomain.Infrastructure;
     }
     if ((runtime?.mailbox.pendingMessages('application') ?? 0) > 0) {
@@ -1575,8 +1579,8 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): MeshOperationId {
     const id = { high: 1n, low };
     void promise.then(
-      (result) => this.enqueueCompletion(id, operationKind, result),
-      (error) => this.enqueueCompletion(id, operationKind, requestFailureResult(error))
+      (result) => this.deliverCompletion(id, operationKind, result),
+      (error) => this.deliverCompletion(id, operationKind, requestFailureResult(error))
     );
     return id;
   }
@@ -1587,66 +1591,40 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): MeshOperationId {
     const id = { high: ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id };
     void pending.promise.then(
-      (result) => this.enqueueCompletion(id, operationKind, result),
-      (error) => this.enqueueCompletion(id, operationKind, requestFailureResult(error))
+      (result) => this.deliverCompletion(id, operationKind, result),
+      (error) => this.deliverCompletion(id, operationKind, requestFailureResult(error))
     );
     return id;
   }
 
-  private enqueueImmediateFailure(operationKind: number, terminalResult: number): MeshOperationId {
+  private observeImmediateFailure(operationKind: number, terminalResult: number): MeshOperationId {
     const low = this.nextPeerIntent++;
-    const id = { high: 1n, low };
-    this.enqueueCompletion(id, operationKind, { terminalResult, failureCode: 0 });
-    return id;
+    return this.observeCompletion(
+      low,
+      operationKind,
+      Promise.resolve({ terminalResult, failureCode: 0 })
+    );
   }
 
-  private enqueueCompletion(
+  private deliverCompletion(
     operationId: MeshOperationId,
     operationKind: number,
     result: RawServiceRequestResult | ServiceStatefulResult
   ): void {
-    if (this.closed) return;
-    this.completions.push({ operationId, operationKind, result });
-    this.completionCount += 1;
-    this.readyHandler?.(ReadyDomain.Infrastructure);
-  }
-
-  private drainCompletions(batch: RawReadyBatch): void {
-    while (!batch.full && this.completionCount > 0) {
-      const completion = this.takeCompletion();
-      if (completion === undefined) continue;
-      batch.push(
-        {
-          ownerKind: ReadyOwnerKind.Node,
-          domain: ReadyDomain.Infrastructure,
-          spotId: null,
-          actor: null,
-          terminalCompletion: true
-        },
-        new CompletionClaim(completion)
+    if (this.completionHandler !== undefined) {
+      this.completionHandler({ operationId, terminalResult: result.terminalResult }, () =>
+        completionRecord(operationId, operationKind, result)
       );
+      return;
     }
-  }
-
-  private takeCompletion(): PendingCompletion | undefined {
-    const completion = this.completions[this.completionHead];
-    if (completion === undefined) return undefined;
-    this.completions[this.completionHead] = undefined;
-    this.completionHead += 1;
-    this.completionCount -= 1;
-    if (this.completionCount === 0) {
-      this.clearCompletions();
-    } else if (shouldCompactBackingArray(this.completionHead, this.completions.length)) {
-      this.completions.splice(0, this.completionHead);
-      this.completionHead = 0;
-    }
-    return completion;
-  }
-
-  private clearCompletions(): void {
-    this.completions.length = 0;
-    this.completionHead = 0;
-    this.completionCount = 0;
+    // The raw pull contract uses the existing infrastructure mailbox. A
+    // registered Framework owner receives the terminal directly above.
+    this.runtime?.mailbox.tryEnqueue({
+      owner: this.routingId,
+      domain: 'infrastructure',
+      parts: [],
+      completion: completionRecord(operationId, operationKind, result)
+    });
   }
 
   private drainMailbox(domain: ServiceMailboxDomain, batch: RawReadyBatch): void {
@@ -1655,7 +1633,16 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     while (!batch.full) {
       const claim = runtime.mailbox.tryClaim(domain, MAX_DRAIN_RECORDS, Number.MAX_SAFE_INTEGER);
       if (claim === undefined) break;
-      const owner = readyOwner(claim.owner, this.routingId, this.stateful, domain);
+      const owner =
+        claim.records[0]?.completion === undefined
+          ? readyOwner(claim.owner, this.routingId, this.stateful, domain)
+          : {
+              ownerKind: ReadyOwnerKind.Node,
+              domain: ReadyDomain.Infrastructure,
+              spotId: null,
+              actor: null,
+              terminalCompletion: true
+            };
       batch.push(owner, new MailboxClaim(runtime, claim));
     }
   }
@@ -1690,12 +1677,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   }
 }
 
-interface PendingCompletion {
-  readonly operationId: MeshOperationId;
-  readonly operationKind: number;
-  readonly result: RawServiceRequestResult | ServiceStatefulResult;
-}
-
 interface RawClaim {
   recvBatch(batch: ReceiveBatch): {
     readonly ok: boolean;
@@ -2166,54 +2147,43 @@ class MailboxClaim implements RawClaim {
   }
 }
 
-class CompletionClaim implements RawClaim {
-  private consumed = false;
-
-  constructor(private readonly completion: PendingCompletion) {}
-
-  recvBatch(): { readonly ok: boolean; readonly records: ReceiveRecord[] } {
-    if (this.consumed) return { ok: false, records: [] };
-    this.consumed = true;
-    const payload = this.completion.result.payload;
-    return {
-      ok: true,
-      records: [
-        {
-          kind: ReceiveKind.Completion,
-          domain: ReadyDomain.Infrastructure,
-          sourceNodeRid: null,
-          sourceSpotId: null,
-          sourceBindingGeneration: 0n,
-          sourceActor: null,
-          operationId: this.completion.operationId,
-          operationKind: this.completion.operationKind,
-          channelName: null,
-          topic: null,
-          applicationMetadata: null,
-          kindData:
-            'kindData' in this.completion.result ? (this.completion.result.kindData ?? null) : null,
-          terminalResult: this.completion.result.terminalResult,
-          failureErrno: this.completion.result.failureCode,
-          parts:
-            payload === undefined
-              ? []
-              : payload.contentType === MULTIPART_CONTENT_TYPE
-                ? decodeMultipart(payload.payload)
-                : [Message.from(payload.payload)],
-          reply: () => SubmitResult.InvalidState,
-          replyActorJoin: () => SubmitResult.NotSupported
-        }
-      ]
-    };
-  }
-
-  release(): void {}
+function completionRecord(
+  operationId: MeshOperationId,
+  operationKind: number,
+  result: RawServiceRequestResult | ServiceStatefulResult
+): ReceiveRecord {
+  const payload = result.payload;
+  return {
+    kind: ReceiveKind.Completion,
+    domain: ReadyDomain.Infrastructure,
+    sourceNodeRid: null,
+    sourceSpotId: null,
+    sourceBindingGeneration: 0n,
+    sourceActor: null,
+    operationId,
+    operationKind,
+    channelName: null,
+    topic: null,
+    applicationMetadata: null,
+    kindData: 'kindData' in result ? (result.kindData ?? null) : null,
+    terminalResult: result.terminalResult,
+    failureErrno: result.failureCode,
+    parts:
+      payload === undefined
+        ? []
+        : payload.contentType === MULTIPART_CONTENT_TYPE
+          ? decodeMultipart(payload.payload)
+          : [ZLinkBufferMessage.from(payload.payload)],
+    reply: () => SubmitResult.InvalidState,
+    replyActorJoin: () => SubmitResult.NotSupported
+  };
 }
 
 function decodeMultipartRecord(
   runtime: RawServiceMeshRuntime,
   record: ServiceMailboxRecord
 ): ReceiveRecord {
+  if (record.completion !== undefined) return record.completion;
   const stateful = statefulMailboxData(record);
   if (stateful !== undefined) {
     return decodeStatefulRecord(record, stateful);

package/src/runtime/backend/node/node-socket-backend-adapter.ts

@@ -3,7 +3,6 @@ import type { Socket } from '@zlink-systems/zlink';
 import type { ZLinkBackendObject } from '../contracts';
 import {
   closeBindingHandle,
-  disableSocketLinger,
   isBindingNotFound,
   isContextTerminatedError,
   isRouteRecvRetryable,
@@ -36,10 +35,12 @@ export function wrapSocket<T extends { close(): void }>(
       recvTimeout?: number;
       sendTimeout?: number;
       noDrop?: boolean;
+      linger?: number;
       maxMsgSize?: bigint;
       lastEndpoint?: string;
     };
   };
+  if (socket.options !== undefined) socket.options.linger = 0;
   const hasRequest = typeof (nativeInstance as { request?: unknown }).request === 'function';
   const hasRoutedPeer =
     hasRequest && typeof (nativeInstance as { reply?: unknown }).reply === 'function';
@@ -50,9 +51,10 @@ export function wrapSocket<T extends { close(): void }>(
       : new ZLinkNodeEventLoopPoller(nativeInstance as unknown as Socket, pollCompletion, () => {});
   const adapter = {
     nativeInstance,
+    receiveAdmission: undefined as
+      import('../../foundation/service-liveness-registry').ServiceLivenessConnection | undefined,
     async dispose(): Promise<void> {
       eventLoopPoller?.dispose();
-      disableSocketLinger(nativeInstance);
       closeBindingHandle(nativeInstance);
     },
     close(): void {
@@ -76,11 +78,6 @@ export function wrapSocket<T extends { close(): void }>(
         .setChannelName;
       setChannelName?.call(nativeInstance, channelName);
     },
-    setReceiveFlowState(state: 0 | 1): void {
-      (nativeInstance as T & { setReceiveFlowState(value: 0 | 1): void }).setReceiveFlowState(
-        state
-      );
-    },
     setProbe(enabled: boolean): void {
       requireSocketOptions(socket).probe = enabled;
     },
@@ -114,6 +111,12 @@ export function wrapSocket<T extends { close(): void }>(
         toNativeRoutingId(routingId)
       );
     },
+    get lingerMs(): number {
+      return requireSocketOptions(socket).linger!;
+    },
+    set lingerMs(value: number) {
+      requireSocketOptions(socket).linger = value;
+    },
     get peerWeight(): number {
       return socket.options?.peerWeight ?? ZLINK_DEFAULT_PUBLIC_WEIGHT;
     },
@@ -219,7 +222,8 @@ export function wrapSocket<T extends { close(): void }>(
         return submitBindingRequest(
           (nativeInstance as T & { request(): ZLinkBindingRequestOperation }).request(),
           payload,
-          timeoutMs
+          timeoutMs,
+          adapter.receiveAdmission?.recordReceived
         );
       }
       throw new TypeError('Backend request requires a DEALER or ROUTER socket.');