@zlink-systems/framework 0.26.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): {
@@ -248,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;
@@ -274,6 +257,7 @@ export interface ZLinkBackendSpotDispatchInfo {
 }
 export interface ZLinkBackendSocketMonitorEvent {
     readonly nativeEvent: MonitorEventType;
+    readonly readyEdge: boolean;
     readonly routingId?: unknown;
     readonly localAddr: string;
     readonly remoteAddr: string;
@@ -348,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,8 +431,6 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     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 {

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

@@ -1,29 +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");
 function meshActorSessionNodeAdapter(node, completions) {
     return {
         async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags) {
             const result = await node.sendActorBoundSession(actor, expectedBindingGeneration, parts, flags);
-            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}'.`);
-            }
+            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-support.d.ts

@@ -50,6 +50,6 @@ export declare function closeBindingHandle(target: {
 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 {};

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

@@ -14,12 +14,14 @@ exports.disableSocketLinger = disableSocketLinger;
 exports.toNativeRoutingId = toNativeRoutingId;
 exports.translateBindingResultError = translateBindingResultError;
 exports.toNativeActorRef = toNativeActorRef;
+const node_os_1 = require("node:os");
+const submission_result_1 = require("../../messaging/submission-result");
 const node_backend_adapter_1 = require("../node-backend-adapter");
 const runtime_values_1 = require("../runtime-values");
-const submission_result_1 = require("../../messaging/submission-result");
+const nativeErrnoValues = node_os_1.constants.errno;
 exports.zlink = (0, node_backend_adapter_1.loadBinding)();
 function isBindingNotFound(error) {
-    return error instanceof exports.zlink.ConfigError && error.result === exports.zlink.ConfigResult.NotFound;
+    return error instanceof exports.zlink.ConnectError && error.result === exports.zlink.ConnectResult.NotFound;
 }
 function isNonBlockingRecvEmpty(error) {
     return error instanceof exports.zlink.RecvError && error.result === exports.zlink.RecvResult.NoData;
@@ -32,7 +34,8 @@ function isRouteRecvRetryable(error) {
             isNativeBadAddress(error)));
 }
 function isNativeBadAddress(error) {
-    return error.nativeErrno === 14 || /Bad address/i.test(String(error.message ?? ''));
+    return (error.nativeErrno === nativeErrnoValues.EFAULT ||
+        /Bad address/i.test(String(error.message ?? '')));
 }
 function submitBindingPublish(operation, payload) {
     try {
@@ -139,7 +142,11 @@ function isSuccessfulOrAlreadyShutdownCloseError(error) {
     return (isContextTerminatedError(error) ||
         (error instanceof Error &&
             'code' in error &&
-            [0, 402, 403].includes(error.code)));
+            [
+                exports.zlink.CloseResult.Ok,
+                exports.zlink.CloseResult.Shutdown,
+                exports.zlink.CloseResult.InvalidHandle
+            ].includes(error.code)));
 }
 function isContextTerminatedError(error) {
     return error instanceof Error && /context was terminated/i.test(error.message);
@@ -182,9 +189,12 @@ function toNativeMessageLike(message) {
     }
     return message;
 }
-function translateBindingResultError(error) {
+function translateBindingResultError(error, phase = 'completion') {
     if (error instanceof exports.zlink.SubmitError) {
-        return new runtime_values_1.ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
+        return new runtime_values_1.ZLinkBackendResultError('submit', error.result, error.nativeErrno, {
+            cause: error,
+            phase
+        });
     }
     if (error instanceof exports.zlink.RequestError) {
         return new runtime_values_1.ZLinkBackendResultError('request', error.result, error.nativeErrno, {

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

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

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

@@ -37,19 +37,18 @@ class ZLinkNodeEventLoopPoller {
     dispose() {
         if (this.disposed)
             return;
-        this.disposed = true;
-        this.events.close();
         this.poller.close();
+        this.events.close();
+        this.disposed = true;
     }
     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.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute)) {
-            this.readableHandler();
-        }
+        const receiveReady = ready === 0 || this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn);
+        const routeReady = ready > 0 && this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute);
+        if (receiveReady || routeReady)
+            this.readableHandler(receiveReady, routeReady);
     };
 }
 exports.ZLinkNodeEventLoopPoller = ZLinkNodeEventLoopPoller;

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

@@ -30,6 +30,7 @@ function wrapMonitorSocket(nativeInstance) {
 function toBackendMonitorEvent(event) {
     return {
         nativeEvent: event.event,
+        readyEdge: (event.flags & node_backend_adapter_support_1.zlink.MonitorEventFlag.ConnectionReadyEdge) !== 0,
         routingId: event.routingId ?? undefined,
         localAddr: event.localAddr,
         remoteAddr: event.remoteAddr,