@zlink-systems/framework 0.29.0 → 0.30.0

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

@@ -192,7 +192,7 @@ class ZLinkMeshDispatchPump {
     async drainDomain(domain, readyBatch, receiveBatch, claimBudget) {
         let claimsDrained = 0;
         try {
-            for (;;) {
+            while (!this.disposed) {
                 if (claimBudget !== undefined && claimsDrained >= claimBudget) {
                     // Lifecycle work has priority, but a bounded turn lets application
                     // work make progress when lifecycle records keep arriving.
@@ -217,20 +217,18 @@ class ZLinkMeshDispatchPump {
                         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 {
-                                    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.
+                            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;
+                                ownerReceiveBatch.reset(capacity);
+                                const received = claim.recvBatch(ownerReceiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+                                if (received.ok) {
+                                    // The bounded batch stays in claim order until its records finish.
                                     try {
                                         for (const record of received.records) {
                                             if (this.disposed)
@@ -263,9 +261,6 @@ class ZLinkMeshDispatchPump {
                                                     claimPermit = undefined;
                                                 await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
                                             }
-                                            const yieldTurn = this.yieldIfNeeded();
-                                            if (yieldTurn !== undefined)
-                                                await yieldTurn;
                                         }
                                     }
                                     finally {
@@ -278,9 +273,9 @@ class ZLinkMeshDispatchPump {
                                         }
                                     }
                                 }
-                                finally {
-                                    claimPermit?.releaseAfterInternalProcessing();
-                                }
+                            }
+                            finally {
+                                claimPermit?.releaseAfterInternalProcessing();
                             }
                         }
                         finally {
@@ -288,6 +283,9 @@ class ZLinkMeshDispatchPump {
                             if (receiveBatch === undefined)
                                 ownerReceiveBatch?.close();
                         }
+                        const yieldTurn = this.yieldIfNeeded();
+                        if (yieldTurn !== undefined)
+                            await yieldTurn;
                     };
                     // An application worker drains the one owner it claimed. Infrastructure owners
                     // drain independently, so a suspended owner does not hold the other claims.
@@ -310,10 +308,8 @@ class ZLinkMeshDispatchPump {
                 const yieldTurn = this.yieldIfNeeded();
                 if (yieldTurn !== undefined)
                     await yieldTurn;
-                if (!drained.hasResidue) {
-                    return false;
-                }
             }
+            return false;
         }
         finally {
             readyBatch.reset();
@@ -334,7 +330,7 @@ class ZLinkMeshDispatchPump {
     }
     async acquirePermit() {
         try {
-            return await this.options.applicationJobQueue.acquire(this.capacityStop.signal);
+            return await this.options.applicationJobQueue.acquire(this.capacityStop.signal, 'remote');
         }
         catch (error) {
             if (this.disposed || this.capacityStop.signal.aborted)

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

@@ -34,7 +34,12 @@ class ZLinkNodeChannelBackendAdapter {
         return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createDealerSocket(asNodeContext(context)), true);
     }
     createRouterSocket(context) {
-        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createRouterSocket(asNodeContext(context)), true);
+        const socket = node_backend_adapter_support_1.zlink.createRouterSocket(asNodeContext(context));
+        const adapter = (0, node_socket_backend_adapter_1.wrapSocket)(socket, true);
+        adapter.setReceiveFlowState = (state) => {
+            socket.setReceiveFlowState(state);
+        };
+        return adapter;
     }
     createPublisherSocket(context) {
         return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createPubSocket(asNodeContext(context)));

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

@@ -38,9 +38,10 @@ export declare function isRouteRecvRetryable(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 submitBindingSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): import('../raw-binding-port').ZLinkRawSendSubmission;
 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 bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, deadlineMs: number | undefined): Promise<import('@zlink-systems/zlink').Message[]>;
+export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined, recordReceived?: () => void): Promise<readonly unknown[]>;
+export declare function bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, deadlineMs: number | undefined, recordReceived?: () => void): Promise<import('@zlink-systems/zlink').Message[]>;
 export declare function closeBindingReply(replies: readonly import('@zlink-systems/zlink').Message[]): void;
 /**
  * Closes a binding handle once. An already closed or terminated handle counts as
@@ -50,7 +51,6 @@ export declare function closeBindingHandle(target: {
     close(): 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, phase?: 'submit' | 'completion'): unknown;
 export declare function toNativeActorRef(actor: unknown): unknown;

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

@@ -6,13 +6,13 @@ exports.isRouteRecvRetryable = isRouteRecvRetryable;
 exports.submitBindingPublish = submitBindingPublish;
 exports.submitBindingReply = submitBindingReply;
 exports.submitBindingAsyncSend = submitBindingAsyncSend;
+exports.submitBindingSend = submitBindingSend;
 exports.submitBindingSyncSend = submitBindingSyncSend;
 exports.submitBindingRequest = submitBindingRequest;
 exports.bindingRequestReply = bindingRequestReply;
 exports.closeBindingReply = closeBindingReply;
 exports.closeBindingHandle = closeBindingHandle;
 exports.isContextTerminatedError = isContextTerminatedError;
-exports.disableSocketLinger = disableSocketLinger;
 exports.toNativeRoutingId = toNativeRoutingId;
 exports.translateBindingResultError = translateBindingResultError;
 exports.toNativeActorRef = toNativeActorRef;
@@ -76,6 +76,11 @@ function submitBindingReply(operation, payload) {
     }
 }
 async function submitBindingAsyncSend(operation, payload) {
+    const submission = submitBindingSend(operation, payload);
+    if (submission.result === runtime_values_1.SubmitResult.Backpressured)
+        await submission.admitted;
+}
+function submitBindingSend(operation, payload) {
     let submission;
     try {
         let current;
@@ -91,13 +96,14 @@ async function submitBindingAsyncSend(operation, payload) {
         throw translateBindingResultError(error, 'submit');
     }
     if (submission.result === runtime_values_1.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: runtime_values_1.SubmitResult.Ok, admitted: submission.admitted };
 }
 function submitBindingSyncSend(operation, payload) {
     try {
@@ -114,7 +120,7 @@ function submitBindingSyncSend(operation, payload) {
         throw translateBindingResultError(error);
     }
 }
-async function submitBindingRequest(operation, payload, timeoutMs) {
+async function submitBindingRequest(operation, payload, timeoutMs, recordReceived) {
     const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     try {
         let current;
@@ -132,25 +138,31 @@ async function submitBindingRequest(operation, payload, timeoutMs) {
         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);
     }
 }
-async function bindingRequestReply(submission, deadlineMs) {
+async function bindingRequestReply(submission, deadlineMs, recordReceived) {
     const reply = submission.reply;
     if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
         try {
             const [, replies] = await (0, request_deadline_1.waitRequestReply)(Promise.all([submission.admitted, reply]), '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;
 }
 function closeBindingReply(replies) {
     for (const reply of replies)
@@ -182,23 +194,6 @@ function isSuccessfulOrAlreadyShutdownCloseError(error) {
 function isContextTerminatedError(error) {
     return error instanceof Error && /context was terminated/i.test(error.message);
 }
-function disableSocketLinger(target) {
-    if (target !== null &&
-        typeof target === 'object' &&
-        'options' in target &&
-        typeof target.options === 'object' &&
-        target.options !== null &&
-        'linger' in target.options) {
-        try {
-            target.options.linger = 0;
-        }
-        catch (error) {
-            if (!isContextTerminatedError(error)) {
-                throw error;
-            }
-        }
-    }
-}
 function toNativeRoutingId(routingId) {
     if (typeof routingId === 'string')
         return exports.zlink.RoutingId.from(routingId);

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

@@ -1,12 +1,4 @@
 import type { ZLinkBackendContext, ZLinkBackendMeshNode, ZLinkMeshBackendAdapter } from '../contracts';
 export declare 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;
-    }): ZLinkBackendMeshNode;
+    createMeshNode(context: ZLinkBackendContext, options: Parameters<ZLinkMeshBackendAdapter['createMeshNode']>[1]): ZLinkBackendMeshNode;
 }

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

@@ -12,7 +12,7 @@ class ZLinkNodeMeshBackendAdapter {
         if (!isBindingContext(bindingContext)) {
             throw new TypeError('Node MeshNode creation requires the Node binding Context owned by the host.');
         }
-        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed);
+        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed, options.infrastructureTaskRunner);
     }
 }
 exports.ZLinkNodeMeshBackendAdapter = ZLinkNodeMeshBackendAdapter;

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

@@ -114,10 +114,6 @@ class NodeRawSocketPort {
         connectable(this.socket).disconnect(endpoint);
         this.endpoints.delete(`connect\0${endpoint}`);
     }
-    setReceiveFlowState(state) {
-        this.requireOpen();
-        this.socket.setReceiveFlowState(state === 'paused' ? zlink_1.ReceiveFlowState.PAUSED : zlink_1.ReceiveFlowState.RUNNING);
-    }
     monitor() {
         this.requireOpen();
         const nativeMonitor = this.socket.monitorOpen();
@@ -178,6 +174,10 @@ class NodeRawSocketPort {
 }
 class NodeRawRouterPort extends NodeRawSocketPort {
     nextIncomingRequestSequence = 1n;
+    setReceiveFlowState(state) {
+        this.requireOpen();
+        this.socket.setReceiveFlowState(state === 'paused' ? zlink_1.ReceiveFlowState.PAUSED : zlink_1.ReceiveFlowState.RUNNING);
+    }
     disconnectRid(routingId) {
         this.requireOpen();
         this.socket.disconnectRid(bindingRoutingId(routingId));
@@ -209,7 +209,12 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         requireParts(parts);
         return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
     }
-    async request(targetRid, parts, timeoutMs) {
+    submitSend(targetRid, parts) {
+        this.requireOpen();
+        requireParts(parts);
+        return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
+    }
+    async request(targetRid, parts, timeoutMs, recordReceived) {
         this.requireOpen();
         const deadlineMs = performance.now() + timeoutMs;
         let submission;
@@ -222,7 +227,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
         }
         try {
-            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, recordReceived);
             return copyAndClose(replies);
         }
         catch (error) {

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

@@ -1,4 +1,5 @@
 import { SubmitResult, type RequestResult as RequestResultValue, type SubmitResult as SubmitResultValue } from '@zlink-systems/zlink';
+import type { ZLinkMeshCompletionHandler } from '../mesh-completion-table';
 import { type RoutingId } from '../../../contracts';
 import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
 import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-reporter';
@@ -7,7 +8,7 @@ import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation
 import { type MeshOperationId, type MeshPeerEntry, type MeshPublisher, type ReadyBatch, type ReadyRecord, type ReceiveBatch, type ServiceSpot, type StreamSessionService, MeshNodeRuntimeState } from '../../foundation/service-runtime-contracts';
 import type { ServiceActorRef, ServiceSpotState } from '../../foundation/service-stateful-registry';
 import { type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
-import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceActivationTarget, ServiceInstanceRouteFence, ServiceSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
+import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceActivationTarget, ServiceInstanceColdActivationTarget, ServiceInstanceRouteFence, ServiceSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
 import type { ServiceNodeDescriptor } from '../../foundation/service-topology-registry';
 import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
 import type { ZLinkBackendActorRef, ZLinkBackendMeshNode, ZLinkBackendObjectPlacement } from '../contracts';
@@ -24,12 +25,11 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readonly applicationJobQueue?;
     private readonly applicationJobReceiveFlowFailureSink?;
     private readonly peerAdmissionSealed?;
+    private readonly infrastructureTaskRunner?;
     readonly nativeInstance: this;
     private readonly channels;
     private readonly peerIntents;
-    private readonly completions;
-    private completionHead;
-    private completionCount;
+    private completionHandler?;
     private readonly routingId;
     private readonly lifecycleGeneration;
     private bindEndpoint?;
@@ -56,7 +56,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private messageFollowHandler?;
     private dispatchErrors?;
     private readonly peerDisconnectedHandlers;
-    constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined);
+    constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined, infrastructureTaskRunner?: import("../../spots/spot-actor-join-dispatch").ZLinkDetachedTaskRunner | undefined);
     configureObjectPlacement(options: {
         readonly role: ServiceNodeDescriptor['objectRole'];
         readonly placementWeight: number;
@@ -79,8 +79,8 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     onPeerDisconnected(handler: (endpoint: string) => void): void;
     selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
     instanceSpotPlacementTypes(): readonly string[];
-    sendToMissingInstanceSpot(target: ServiceInstanceActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestToMissingInstanceSpot(target: ServiceInstanceActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    sendToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
+    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: MessageLike | readonly MessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
     setRoutingId(routingId: unknown): void;
     setBind(endpoint: string): void;
     setAdvertiseHost(host: string): void;
@@ -151,6 +151,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         weights: number[];
     };
     createPublisher(): MeshPublisher;
+    setCompletionHandler(handler: ZLinkMeshCompletionHandler): void;
     setReadyHandler(handler: (readyDomains: number) => number): void;
     createReadyBatch(capacity: number): ReadyBatch;
     createReceiveBatch(messageCapacity: number, partCapacity: number): ReceiveBatch;
@@ -249,11 +250,8 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private notifyReady;
     private observeCompletion;
     private observeStateful;
-    private enqueueImmediateFailure;
-    private enqueueCompletion;
-    private drainCompletions;
-    private takeCompletion;
-    private clearCompletions;
+    private observeImmediateFailure;
+    private deliverCompletion;
     private drainMailbox;
     private requireRuntime;
     private requireApplicationJobQueue;