@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/backend/contracts/index.d.ts

@@ -80,8 +80,8 @@ export interface ZLinkBackendMeshNode {
         readonly stableType: string;
         readonly descriptorVersion: string;
     }, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
-    sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): Promise<SubmitResult>;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): MeshOperationId;
     registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
     requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
@@ -156,11 +156,12 @@ export interface ZLinkBackendMeshNode {
         readonly stableType: string;
         readonly objectGeneration: bigint;
     } | undefined;
+    registerInstanceIntent?(instanceType: string, route: import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence, expectedCurrentRoute?: import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence | null): void;
     waitForInstanceApplicationQuiescence?(spotId: string, signal?: AbortSignal): Promise<void>;
     restoreUserSpotAuthority?(spotId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpot;
     restoreSpotAuthority?(spotId: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpot;
     createActor(actorId: string, parts?: MessageLike | readonly MessageLike[]): ZLinkBackendActorRef;
-    restoreActorAuthority?(actorId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint, spotId: string, spotGeneration: bigint, membershipEpoch: bigint): ZLinkBackendActorRef;
+    restoreActorAuthority?(actorId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint, spotId: string | undefined, spotGeneration: bigint, membershipEpoch: bigint): ZLinkBackendActorRef;
     discardRelocatedActor?(actor: ZLinkBackendActorRef): void;
     restoreActorSessionBinding?(actor: ZLinkBackendActorRef, sessionNodeRid: unknown, sessionRid: unknown, bindingGeneration: bigint): void;
     actorLookup(actorId: string): {
@@ -210,7 +211,7 @@ export interface ZLinkBackendMeshNode {
         timeoutMs?: number;
         applicationMetadata?: Buffer;
     }): MeshOperationId;
-    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], flags?: number, actorFence?: ZLinkBackendActorSessionSendFence): Promise<SubmitResult>;
+    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], flags?: number): Promise<SubmitResult>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     setReadyHandler(handler: (readyDomains: number) => number): void;
@@ -237,14 +238,8 @@ export interface ZLinkBackendActorRef {
     readonly actorId: string;
     readonly generation: bigint;
 }
-export interface ZLinkBackendActorSessionSendFence {
-    readonly targetNodeGeneration: bigint;
-    readonly authorityOwnerGeneration: bigint;
-    readonly ownerLeaseGeneration: bigint;
-}
 export interface ZLinkBackendActorSessionNode {
-    actorNodeGeneration?(actor: ZLinkBackendActorRef): bigint | undefined;
-    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: readonly Message[], flags: number, actorFence?: ZLinkBackendActorSessionSendFence): Promise<ZLinkSubmitResult>;
+    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: readonly Message[], flags: number): Promise<ZLinkSubmitResult>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs: number, signal?: AbortSignal): Promise<void>;
 }
 export interface ZLinkBackendActorRecvInfo {
@@ -254,24 +249,6 @@ export interface ZLinkBackendActorRecvInfo {
     readonly requestId: bigint;
     readonly flags: number;
 }
-export interface ZLinkBackendActorJoinInfo {
-    readonly sourceActor: ZLinkBackendActorRef;
-    readonly targetActor: ZLinkBackendActorRef;
-    readonly sourceNodeRid: RoutingId;
-    readonly sourceSpotId: RoutingId;
-    readonly targetNodeRid: RoutingId;
-    readonly targetSpotId: RoutingId;
-    readonly joinEpoch: bigint;
-    readonly flags: number;
-}
-export interface ZLinkBackendActorJoinRequest {
-    readonly info: ZLinkBackendActorJoinInfo;
-    readonly message: Message;
-}
-export interface ZLinkBackendActorJoinReplyOperation {
-    message(message: Message): ZLinkBackendActorJoinReplyOperation;
-    submit(): void;
-}
 export interface ZLinkBackendSpotDispatchInfo {
     readonly event: ZLinkBackendSpotDispatchEvent;
     readonly subjectKind?: number;
@@ -280,6 +257,7 @@ export interface ZLinkBackendSpotDispatchInfo {
 }
 export interface ZLinkBackendSocketMonitorEvent {
     readonly nativeEvent: MonitorEventType;
+    readonly readyEdge: boolean;
     readonly routingId?: unknown;
     readonly localAddr: string;
     readonly remoteAddr: string;
@@ -354,6 +332,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     reply(routingId: RoutingId, replyToken: unknown, message: Message | readonly Message[]): void;
 }
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
+    sendTimeoutMs: number;
     sendHighWaterMark: number;
     noDrop: boolean;
     publish(topic: string, message: Message | readonly Message[]): void;
@@ -446,15 +425,12 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     recvActorLifecycle(flags: ZLinkBackendRecvFlags): unknown | null;
     drainReply(): number;
     drainChannelReply(subjectHandle: bigint): number;
-    recvRoute(result: Received, flags: ZLinkBackendRecvFlags): boolean;
     setDispatchHandler(handler: (info: ZLinkBackendSpotDispatchInfo) => void): void;
     requestToChannel(channelName: string, payload: Message | readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
     sendToChannel(channelName: string, payload: Message | readonly Message[]): Promise<void>;
     publish(topic: string, payload: Message | readonly Message[], flags: ZLinkBackendSendFlags): boolean;
     sendToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[]): Promise<void>;
     requestToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
-    recvActorJoin(flags: ZLinkBackendRecvFlags): ZLinkBackendActorJoinRequest | null;
-    replyActorJoin(request: ZLinkBackendActorJoinRequest, joinResultCode: number): ZLinkBackendActorJoinReplyOperation;
     dispose(): Promise<void>;
 }
 export interface ZLinkChannelBackendAdapter {
@@ -486,7 +462,6 @@ export interface ZLinkMonitoringBackendAdapter {
     openSocketMonitor(socket: ZLinkBackendSocket): ZLinkBackendSocketMonitor;
 }
 export interface ZLinkBackendAdapterFactory {
-    createReceived(): Received;
     createTopicMessage(): TopicMessage;
     createChannelAdapter(): ZLinkChannelBackendAdapter;
     createMeshAdapter(): ZLinkMeshBackendAdapter;

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

@@ -1,36 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.meshActorSessionNodeAdapter = meshActorSessionNodeAdapter;
-const runtime_values_1 = require("./runtime-values");
 const submission_result_1 = require("../messaging/submission-result");
 const mesh_completion_table_1 = require("./mesh-completion-table");
-const routing_id_1 = require("../routing-id");
 function meshActorSessionNodeAdapter(node, completions) {
     return {
-        actorNodeGeneration(actor) {
-            const status = node.status();
-            return (0, routing_id_1.routingIdsEqual)(status.routingId, actor.nodeRid)
-                ? status.lifecycleGeneration
-                : undefined;
-        },
-        async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags, actorFence) {
-            const result = await node.sendActorBoundSession(actor, expectedBindingGeneration, parts, flags, actorFence);
-            switch (result) {
-                case runtime_values_1.SubmitResult.Ok:
-                    return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
-                case runtime_values_1.SubmitResult.Backpressured:
-                case runtime_values_1.SubmitResult.NotAdmitted:
-                    return { status: submission_result_1.ZLinkSubmitStatus.Backpressured };
-                case runtime_values_1.SubmitResult.NotFound:
-                case runtime_values_1.SubmitResult.InvalidState:
-                    return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
-                case runtime_values_1.SubmitResult.NotConnected:
-                    return { status: submission_result_1.ZLinkSubmitStatus.RouteNotConnected };
-                case runtime_values_1.SubmitResult.Terminated:
-                    return { status: submission_result_1.ZLinkSubmitStatus.Shutdown };
-                default:
-                    throw new Error(`Actor bound-session send failed with result '${result}'.`);
-            }
+        async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags) {
+            const result = await node.sendActorBoundSession(actor, expectedBindingGeneration, parts, flags);
+            return (0, submission_result_1.classifySubmitResult)(result, 'Actor bound-session send');
         },
         async closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs, signal) {
             if (completions === undefined) {

package/dist/runtime/backend/mesh-dispatch-pump.d.ts

@@ -1,6 +1,6 @@
+import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
 import { type ReadyRecord, type ReceiveRecord } from '../foundation/service-runtime-contracts';
 import type { ZLinkBackendMeshNode } from './contracts';
-import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
 export interface ZLinkMeshDispatchPumpOptions {
     readonly readyCapacity?: number;
     readonly messageCapacity?: number;
@@ -23,7 +23,6 @@ export declare class ZLinkMeshDispatchPump {
     private pendingDomains;
     private infrastructureScheduled;
     private disposed;
-    private infrastructureDrainPromise?;
     private readonly activeDrains;
     private readonly idleApplicationWorkers;
     private applicationWorkerCount;

package/dist/runtime/backend/mesh-dispatch-pump.js

@@ -3,10 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkMeshDispatchPump = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
 const node_os_1 = require("node:os");
-const runtime_values_1 = require("./runtime-values");
-const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
-const execution_1 = require("../execution");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
+const execution_1 = require("../execution");
+const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
+const service_wire_binary_primitives_1 = require("../foundation/service-wire-binary-primitives");
+const service_wire_constants_generated_1 = require("../foundation/service-wire-constants.generated");
+const runtime_values_1 = require("./runtime-values");
+const DEFAULT_MESH_READY_CAPACITY = 32;
+const DEFAULT_MESH_PART_CAPACITY = 256;
 const MESH_DISPATCH_YIELD_RECORDS = 16;
 const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
 const MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET = 4;
@@ -17,23 +21,12 @@ const MESH_DISPATCH_MAX_APPLICATION_WORKERS = Math.max(2, (0, node_os_1.availabl
 // must enter like an independent receive-loop task, without inheriting that
 // owner's AsyncLocalStorage identity.
 const detachedMeshDispatchScope = node_async_hooks_1.AsyncLocalStorage.snapshot();
-class ZLinkMeshDispatchFailure extends Error {
-    context;
-    dispatchCause;
-    constructor(context, dispatchCause) {
-        super('Mesh record dispatch failed.', { cause: dispatchCause });
-        this.context = context;
-        this.dispatchCause = dispatchCause;
-        this.name = 'ZLinkMeshDispatchFailure';
-    }
-}
 class ZLinkMeshDispatchPump {
     node;
     options;
     pendingDomains = service_runtime_contracts_1.ReadyDomain.None;
     infrastructureScheduled = false;
     disposed = false;
-    infrastructureDrainPromise;
     activeDrains = new Set();
     idleApplicationWorkers = new Set();
     applicationWorkerCount = 0;
@@ -119,7 +112,7 @@ class ZLinkMeshDispatchPump {
         // A worker claims one owner at a time so a suspended handler cannot hold
         // unrelated owners. Each owner may supply up to 64 pre-admitted records.
         const readyBatch = this.node.createReadyBatch(1);
-        const receiveBatch = this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? 256);
+        const receiveBatch = this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
         try {
             for (;;) {
                 await this.waitForApplicationReady();
@@ -147,12 +140,8 @@ class ZLinkMeshDispatchPump {
         }
         return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
     }
-    reportDispatchError(error) {
-        if (error instanceof ZLinkMeshDispatchFailure) {
-            this.options.reportError?.(error.dispatchCause, error.context);
-            return;
-        }
-        this.options.reportError?.(error);
+    reportDispatchError(error, context) {
+        this.options.reportError?.(error, context);
     }
     /**
      * Infrastructure controls must not wait for an application permit. During
@@ -168,29 +157,18 @@ class ZLinkMeshDispatchPump {
         this.infrastructureScheduled = true;
         const drain = (startTurn ?? this.yieldIfNeeded() ?? Promise.resolve())
             .then(() => detachedMeshDispatchScope(() => (0, execution_1.runZLinkExecutionArea)('infrastructure', () => this.drainInfrastructure())))
-            .catch((error) => {
-            if (error instanceof ZLinkMeshDispatchFailure) {
-                this.options.reportError?.(error.dispatchCause, error.context);
-                return;
-            }
-            this.options.reportError?.(error);
-        });
+            .catch((error) => this.reportDispatchError(error));
         this.activeDrains.add(drain);
-        this.infrastructureDrainPromise = drain;
         void drain.finally(() => {
             this.activeDrains.delete(drain);
-            if (this.infrastructureDrainPromise === drain) {
-                this.infrastructureDrainPromise = undefined;
-                this.infrastructureScheduled = false;
-                if (!this.disposed && (this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
-                    this.scheduleInfrastructure();
-                }
+            this.infrastructureScheduled = false;
+            if (!this.disposed && (this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
+                this.scheduleInfrastructure();
             }
         });
     }
     async drainInfrastructure() {
-        const readyBatch = this.node.createReadyBatch(Math.min(this.options.readyCapacity ?? 32, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET));
-        const receiveBatch = this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? 256);
+        const readyBatch = this.node.createReadyBatch(Math.min(this.options.readyCapacity ?? DEFAULT_MESH_READY_CAPACITY, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET));
         try {
             while (!this.disposed) {
                 if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) === 0) {
@@ -200,7 +178,7 @@ class ZLinkMeshDispatchPump {
                 if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) !== 0) {
                     setImmediate(() => this.wakeApplicationWorker());
                 }
-                const lifecycleBudgetExhausted = await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Infrastructure, readyBatch, receiveBatch, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET);
+                const lifecycleBudgetExhausted = await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Infrastructure, readyBatch, undefined, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET);
                 if (lifecycleBudgetExhausted) {
                     this.pendingDomains |= service_runtime_contracts_1.ReadyDomain.Infrastructure;
                     await yieldToEventLoop();
@@ -208,7 +186,6 @@ class ZLinkMeshDispatchPump {
             }
         }
         finally {
-            receiveBatch.close();
             readyBatch.close();
         }
     }
@@ -235,84 +212,92 @@ class ZLinkMeshDispatchPump {
                     const owner = drained.records[index];
                     // Raw ingress already attached one host permit to each record.
                     // A claim that reserves admission here may receive only that permit's record.
-                    try {
-                        const capacity = owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
-                        for (;;) {
-                            let claimPermit = owner.terminalCompletion === true ||
-                                owner.ordinaryIngressPreAdmitted === true ||
-                                domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
-                                ? undefined
-                                : await this.acquirePermit();
-                            try {
-                                if (this.capacityStop.signal.aborted)
-                                    return false;
-                                receiveBatch.reset(capacity);
-                                const received = claim.recvBatch(receiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
-                                if (!received.ok)
-                                    break;
-                                // This owner keeps its claim while it drains. Other owners and
-                                // infrastructure may progress if one of its handlers suspends.
-                                if (domain === service_runtime_contracts_1.ReadyDomain.Infrastructure) {
-                                    this.infrastructureScheduled = false;
-                                    this.infrastructureDrainPromise = undefined;
-                                    if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
-                                        this.scheduleInfrastructure();
-                                    }
-                                }
+                    const drainClaim = async () => {
+                        let ownerReceiveBatch = receiveBatch;
+                        try {
+                            ownerReceiveBatch ??= this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
+                            const capacity = owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
+                            for (;;) {
+                                let claimPermit = owner.terminalCompletion === true ||
+                                    owner.ordinaryIngressPreAdmitted === true ||
+                                    domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
+                                    ? undefined
+                                    : await this.acquirePermit();
                                 try {
-                                    for (const record of received.records) {
-                                        if (this.disposed)
-                                            break;
-                                        const permit = record.applicationJobPermit ?? claimPermit;
-                                        if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
-                                            throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
-                                        }
-                                        this.recordsSinceYield += 1;
-                                        const dispatch = async () => {
-                                            try {
-                                                await this.options.dispatch(drained.records[index], record);
+                                    if (this.capacityStop.signal.aborted)
+                                        return;
+                                    ownerReceiveBatch.reset(capacity);
+                                    const received = claim.recvBatch(ownerReceiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+                                    if (!received.ok)
+                                        break;
+                                    // This owner keeps its claim while it drains, so its records stay in FIFO order.
+                                    try {
+                                        for (const record of received.records) {
+                                            if (this.disposed)
+                                                break;
+                                            const permit = record.applicationJobPermit ?? claimPermit;
+                                            if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
+                                                throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
                                             }
-                                            catch (error) {
-                                                throw new ZLinkMeshDispatchFailure(meshDispatchFailureContext(record), error);
+                                            this.recordsSinceYield += 1;
+                                            const dispatch = async () => {
+                                                try {
+                                                    await this.options.dispatch(owner, record);
+                                                    await record.onTerminalCompletion?.();
+                                                }
+                                                catch (error) {
+                                                    this.reportDispatchError(error, meshDispatchFailureContext(record));
+                                                }
+                                            };
+                                            if (permit === undefined) {
+                                                await dispatch();
                                             }
-                                            await record.onTerminalCompletion?.();
-                                        };
-                                        if (permit === undefined) {
-                                            await dispatch();
+                                            else {
+                                                if (domain === service_runtime_contracts_1.ReadyDomain.Application &&
+                                                    record.applicationJobPermit === undefined)
+                                                    permit.markApplicationQueued();
+                                                // The scope now owns this reservation, including failure
+                                                // and detached handler handoff. Only unused permits remain
+                                                // owned by the receive attempt's finally block.
+                                                if (permit === claimPermit)
+                                                    claimPermit = undefined;
+                                                await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
+                                            }
+                                            const yieldTurn = this.yieldIfNeeded();
+                                            if (yieldTurn !== undefined)
+                                                await yieldTurn;
                                         }
-                                        else {
-                                            if (domain === service_runtime_contracts_1.ReadyDomain.Application &&
-                                                record.applicationJobPermit === undefined)
-                                                permit.markApplicationQueued();
-                                            // The scope now owns this reservation, including failure
-                                            // and detached handler handoff. Only unused permits remain
-                                            // owned by the receive attempt's finally block.
-                                            if (permit === claimPermit)
-                                                claimPermit = undefined;
-                                            await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
+                                    }
+                                    finally {
+                                        // Batch ownership includes records whose dispatch never began,
+                                        // including on failure or shutdown in the middle of the batch.
+                                        for (const record of received.records) {
+                                            for (const part of record.parts)
+                                                part.close();
+                                            record.releaseRetainedIngress?.();
                                         }
-                                        const yieldTurn = this.yieldIfNeeded();
-                                        if (yieldTurn !== undefined)
-                                            await yieldTurn;
                                     }
                                 }
                                 finally {
-                                    // Batch ownership includes records whose dispatch never began,
-                                    // including on failure or shutdown in the middle of the batch.
-                                    for (const record of received.records) {
-                                        for (const part of record.parts)
-                                            part.close();
-                                        record.releaseRetainedIngress?.();
-                                    }
+                                    claimPermit?.releaseAfterInternalProcessing();
                                 }
                             }
-                            finally {
-                                claimPermit?.releaseAfterInternalProcessing();
-                            }
                         }
+                        finally {
+                            claim.release();
+                            if (receiveBatch === undefined)
+                                ownerReceiveBatch?.close();
+                        }
+                    };
+                    // An application worker drains the one owner it claimed. Infrastructure owners
+                    // drain independently, so a suspended owner does not hold the other claims.
+                    if (receiveBatch !== undefined) {
+                        await drainClaim();
                     }
-                    finally {
-                        claim.release();
+                    else {
+                        const drain = drainClaim().catch((error) => this.reportDispatchError(error));
+                        this.activeDrains.add(drain);
+                        void drain.finally(() => this.activeDrains.delete(drain));
                     }
                 }
                 if (claimBudget !== undefined && claimsDrained >= claimBudget) {
@@ -373,8 +358,11 @@ function serviceWireCommand(record) {
     if (record.parts.length !== 1)
         return undefined;
     const bytes = record.parts[0].data();
-    return bytes.byteLength >= 5 && bytes[0] === 0x5a && bytes[1] === 0x4d && bytes[2] === 1
-        ? bytes[3]
+    return bytes.byteLength >= service_wire_binary_primitives_1.SERVICE_WIRE_PREFIX_SIZE &&
+        bytes[0] === service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[0] &&
+        bytes[1] === service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[1] &&
+        bytes[service_wire_binary_primitives_1.SERVICE_WIRE_MAJOR_OFFSET] === service_wire_constants_generated_1.SERVICE_WIRE_MAJOR
+        ? bytes[service_wire_binary_primitives_1.SERVICE_WIRE_COMMAND_OFFSET]
         : undefined;
 }
 function yieldToEventLoop() {

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

@@ -1,8 +1,7 @@
 import type { TopicMessage } from '@zlink-systems/zlink';
-import type { ZLinkBackendAdapterFactory, ZLinkBackendReceived, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
+import type { ZLinkBackendAdapterFactory, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
 import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
 export declare class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
-    createReceived(): ZLinkBackendReceived;
     createTopicMessage(): TopicMessage;
     createChannelAdapter(): ZLinkChannelBackendAdapter;
     createMeshAdapter(): ZLinkNodeMeshBackendAdapter;

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

@@ -6,9 +6,6 @@ const node_monitor_backend_adapter_1 = require("./node-monitor-backend-adapter")
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const node_mesh_backend_adapter_1 = require("./node-mesh-backend-adapter");
 class ZLinkNodeBackendAdapterFactory {
-    createReceived() {
-        return new node_backend_adapter_support_1.zlink.Received();
-    }
     createTopicMessage() {
         return new node_backend_adapter_support_1.zlink.TopicMessage();
     }
@@ -51,7 +48,8 @@ class ZLinkNodeChannelBackendAdapter {
 }
 class ZLinkNodeStreamBackendAdapter {
     createStreamSocket(context) {
-        const socket = node_backend_adapter_support_1.zlink.createStreamSocket(asNodeContext(context));
+        const nodeContext = asNodeContext(context);
+        const socket = node_backend_adapter_support_1.zlink.createStreamSocket(nodeContext);
         socket.options.recvMode = node_backend_adapter_support_1.zlink.StreamRecvMode.Packet;
         return (0, node_socket_backend_adapter_1.wrapSocket)(socket, true);
     }
@@ -93,20 +91,8 @@ class ZLinkNodeBackendContext {
         this.nativeInstance.resetCoreHwmBudgetMetrics();
     }
     async dispose() {
-        // Terminal cleanup shuts the context down before terminating it, the same
-        // sequence the .NET reference binding runs inside `Context.Dispose()`
-        // (`zlink_ctx_shutdown` then `zlink_ctx_term`). Without the shutdown signal
-        // termination can block forever waiting on the reaper even after every
-        // socket this runtime owns has been closed.
-        try {
-            this.nativeInstance.shutdown();
-        }
-        catch (error) {
-            if (!(0, node_backend_adapter_support_1.isContextTerminatedError)(error)) {
-                throw error;
-            }
-        }
-        await (0, node_backend_adapter_support_1.closeWithBusyRetry)(this.nativeInstance);
+        // Binding Context.close() shuts down and then terminates the native context.
+        (0, node_backend_adapter_support_1.closeBindingHandle)(this.nativeInstance);
     }
     close() {
         this.nativeInstance.close();

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

@@ -35,18 +35,21 @@ interface ZLinkBindingRequestSubmitOperation {
 }
 export declare function isBindingNotFound(error: unknown): boolean;
 export declare function isRouteRecvRetryable(error: unknown): boolean;
-export declare function isPollerInterruptedError(error: unknown): boolean;
 export declare function submitBindingPublish(operation: ZLinkBindingPublishOperation, payload: unknown): void;
 export declare function submitBindingReply(operation: ZLinkBindingReplyOperation, payload: unknown): void;
 export declare function submitBindingAsyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): Promise<void>;
 export declare function submitBindingSyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): void;
 export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined): Promise<readonly unknown[]>;
-export declare function closeWithBusyRetry(target: {
+/**
+ * Closes a binding handle once. An already closed or terminated handle counts as
+ * closed. A busy close propagates to the caller.
+ */
+export declare function closeBindingHandle(target: {
     close(): void;
-}): Promise<void>;
+}): void;
 export declare function isContextTerminatedError(error: unknown): boolean;
 export declare function disableSocketLinger(target: unknown): void;
 export declare function toNativeRoutingId(routingId: unknown): unknown;
-export declare function translateBindingResultError(error: unknown): unknown;
+export declare function translateBindingResultError(error: unknown, phase?: 'submit' | 'completion'): unknown;
 export declare function toNativeActorRef(actor: unknown): unknown;
 export {};