@zlink-systems/framework 0.29.1 → 0.30.1

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

@@ -5,6 +5,7 @@ const zlink_1 = require("@zlink-systems/zlink");
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const node_event_loop_poller_1 = require("./node-event-loop-poller");
+const runtime_message_1 = require("../runtime-message");
 class ZLinkNodeRawBindingPort {
     sharedContext;
     routerReceiveTimeoutMs;
@@ -114,10 +115,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,9 +175,39 @@ class NodeRawSocketPort {
 }
 class NodeRawRouterPort extends NodeRawSocketPort {
     nextIncomingRequestSequence = 1n;
+    routingIds = new Map();
+    nextRequestSequence = () => {
+        const current = this.nextIncomingRequestSequence;
+        this.nextIncomingRequestSequence =
+            current === BigInt(Number.MAX_SAFE_INTEGER) ? 1n : current + 1n;
+        return current;
+    };
+    replyParts = (targetRid, replyToken, parts) => {
+        appendReplyParts(this.socket.reply(this.preparedRoutingId(targetRid), replyToken), parts).submit();
+    };
+    preparedRoutingId(routingId) {
+        if (typeof routingId !== 'string')
+            return bindingRoutingId(routingId);
+        let prepared = this.routingIds.get(routingId);
+        if (prepared === undefined)
+            this.routingIds.set(routingId, (prepared = bindingRoutingId(routingId)));
+        return prepared;
+    }
+    close() {
+        try {
+            super.close();
+        }
+        finally {
+            this.routingIds.clear();
+        }
+    }
+    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));
+        this.socket.disconnectRid(this.preparedRoutingId(routingId));
     }
     constructor(socket, receiveTimeoutMs) {
         super(socket, true);
@@ -197,24 +224,29 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     setRoutingId(routingId) {
         this.requireOpen();
-        this.socket.setRoutingId(bindingRoutingId(routingId));
+        this.socket.setRoutingId(this.preparedRoutingId(routingId));
     }
     connectToRoutingId(routingId, endpoint) {
         this.requireOpen();
-        this.socket.options.setConnectRoutingId(bindingRoutingId(routingId));
+        this.socket.options.setConnectRoutingId(this.preparedRoutingId(routingId));
         this.connect(endpoint);
     }
     send(targetRid, parts) {
         this.requireOpen();
         requireParts(parts);
-        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
+        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
+    }
+    submitSend(targetRid, parts) {
+        this.requireOpen();
+        requireParts(parts);
+        return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
     }
-    async request(targetRid, parts, timeoutMs) {
+    async request(targetRid, parts, timeoutMs, recordReceived, onAdmitted) {
         this.requireOpen();
         const deadlineMs = performance.now() + timeoutMs;
         let submission;
         try {
-            submission = appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+            submission = appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts)
                 .timeout(timeoutMs)
                 .submit();
         }
@@ -222,8 +254,8 @@ 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);
-            return copyAndClose(replies);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, recordReceived, onAdmitted);
+            return retainAndClose(replies);
         }
         catch (error) {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
@@ -238,14 +270,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     receive(dontWait = false) {
         this.requireOpen();
-        return receiveRecord(this.socket, dontWait, () => {
-            const current = this.nextIncomingRequestSequence;
-            this.nextIncomingRequestSequence =
-                current === BigInt(Number.MAX_SAFE_INTEGER) ? 1n : current + 1n;
-            return current;
-        }, (targetRid, replyToken, parts) => {
-            appendReplyParts(this.socket.reply(bindingRoutingId(targetRid), replyToken), parts).submit();
-        });
+        return receiveRecord(this.socket, dontWait, this.nextRequestSequence, this.replyParts);
     }
 }
 class NodeRawDealerPort extends NodeRawSocketPort {
@@ -261,7 +286,7 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         requireParts(parts);
         return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(), parts);
     }
-    async request(parts, timeoutMs) {
+    async request(parts, timeoutMs, onAdmitted) {
         this.requireOpen();
         const deadlineMs = performance.now() + timeoutMs;
         let submission;
@@ -272,8 +297,8 @@ class NodeRawDealerPort 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);
-            return copyAndClose(replies);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, undefined, onAdmitted);
+            return retainAndClose(replies);
         }
         catch (error) {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
@@ -385,9 +410,9 @@ function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
         throw error;
     }
 }
-function copyAndClose(messages) {
+function retainAndClose(messages) {
     try {
-        return messages.map((message) => message.toBytes());
+        return messages.map((message) => runtime_message_1.ZLinkBufferMessage.retainPayload(message));
     }
     finally {
         for (const message of messages)

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,13 +25,12 @@ 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 readonly routingId;
+    private completionHandler?;
+    readonly routingId: string;
     private readonly lifecycleGeneration;
     private bindEndpoint?;
     private advertiseHost?;
@@ -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>, onAdmitted?: () => void): MeshOperationId;
     setRoutingId(routingId: unknown): void;
     setBind(endpoint: string): void;
     setAdvertiseHost(host: string): void;
@@ -114,19 +114,25 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly endpoint: string;
     }[]): void;
     isObjectClientNodeDirectTarget(targetRid: unknown): boolean;
+    observePeerRoute(targetRid: unknown): import("../../foundation/durable-service-request").PeerRouteObservation;
+    hasPeerRouteOrConnectionIntent(targetRid: unknown, endpoint: string): boolean;
     isPeerRouteReady(targetRid: unknown, lifecycleGeneration?: bigint): boolean;
-    sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[]): SubmitResultValue | Promise<SubmitResultValue>;
     sendInfrastructureControl(targetRid: unknown, record: Uint8Array | readonly Uint8Array[]): Promise<SubmitResultValue>;
     sendInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[]): Promise<SubmitResultValue>;
     requestInfrastructureControlFrames(targetRid: unknown, frames: readonly Uint8Array[], options?: {
         readonly timeoutMs?: number;
+        readonly signal?: AbortSignal;
+        readonly onSubmitted?: (signal: AbortSignal) => Promise<void>;
     }): Promise<readonly Uint8Array[]>;
     requestToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     status(): {
         state: MeshNodeRuntimeState;
@@ -151,6 +157,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;
@@ -195,7 +202,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
     forgetSpotRoute(spot: ServiceSpotRouteFence['spot'], authorityOwnerGeneration: bigint, storeVersion?: string): void;
     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;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean, onAdmitted?: () => void): MeshOperationId;
     actorLookup(actorId: string): {
         actor: ServiceActorRef;
         spotId: string;
@@ -225,17 +232,19 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     actorRequestToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
+        readonly onAdmitted?: () => void;
     }): MeshOperationId;
     sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], _flags?: number): Promise<SubmitResultValue>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     createStreamSessionService(stream: unknown): StreamSessionService;
     sendFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
-    requestFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs: number): MeshOperationId;
+    requestFromSpot(source: ServiceSpotState, target: ServiceDirectSpotRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs: number, onAdmitted?: () => void): MeshOperationId;
     closeSpot(state: ServiceSpotState): boolean;
     publishFromSpot(state: ServiceSpotState, channelName: string, topic: string, parts: MessageLike | readonly MessageLike[]): Promise<void>;
     setSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;
@@ -249,11 +258,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;