@zlink-systems/framework 0.30.1 → 0.30.2

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

@@ -4,6 +4,7 @@ exports.ZLinkNodeRawBindingPort = void 0;
 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 runtime_values_1 = require("../runtime-values");
 const node_event_loop_poller_1 = require("./node-event-loop-poller");
 const runtime_message_1 = require("../runtime-message");
 class ZLinkNodeRawBindingPort {
@@ -183,7 +184,9 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         return current;
     };
     replyParts = (targetRid, replyToken, parts) => {
-        appendReplyParts(this.socket.reply(this.preparedRoutingId(targetRid), replyToken), parts).submit();
+        // The receive record keeps the binding RoutingId it was delivered with,
+        // so the reply addresses that route without rebuilding the identity.
+        appendReplyParts(this.socket.reply(targetRid, replyToken), parts).submit();
     };
     preparedRoutingId(routingId) {
         if (typeof routingId !== 'string')
@@ -207,7 +210,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     disconnectRid(routingId) {
         this.requireOpen();
-        this.socket.disconnectRid(this.preparedRoutingId(routingId));
+        (0, node_socket_backend_adapter_1.disconnectSocketPeer)(this.socket, this.preparedRoutingId(routingId));
     }
     constructor(socket, receiveTimeoutMs) {
         super(socket, true);
@@ -241,25 +244,19 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         requireParts(parts);
         return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
     }
-    async request(targetRid, parts, timeoutMs, recordReceived, onAdmitted) {
-        this.requireOpen();
-        const deadlineMs = performance.now() + timeoutMs;
+    request(targetRid, parts, timeoutMs, recordReceived, onAdmitted) {
         let submission;
+        const deadlineMs = performance.now() + timeoutMs;
         try {
+            this.requireOpen();
             submission = appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts)
                 .timeout(timeoutMs)
                 .submit();
         }
         catch (error) {
-            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
-        }
-        try {
-            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');
+            return Promise.reject((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit'));
         }
+        return requestReply(submission, deadlineMs, recordReceived, onAdmitted);
     }
     routesSnapshot() {
         this.requireOpen();
@@ -286,23 +283,17 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         requireParts(parts);
         return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(), parts);
     }
-    async request(parts, timeoutMs, onAdmitted) {
-        this.requireOpen();
-        const deadlineMs = performance.now() + timeoutMs;
+    request(parts, timeoutMs, onAdmitted) {
         let submission;
+        const deadlineMs = performance.now() + timeoutMs;
         try {
+            this.requireOpen();
             submission = appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
         }
         catch (error) {
-            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
-        }
-        try {
-            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');
+            return Promise.reject((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit'));
         }
+        return requestReply(submission, deadlineMs, undefined, onAdmitted);
     }
     receive(dontWait = false) {
         this.requireOpen();
@@ -363,53 +354,94 @@ function requireParts(parts) {
         throw new TypeError('Raw multipart operation requires at least one part.');
     return parts;
 }
+const EMPTY_SOURCE_ROUTE = Buffer.alloc(0);
+/**
+ * One received binding record. The payload Buffers are the binding's own
+ * `data()` storage, retained under the runtime payload policy instead of a
+ * second Framework copy; closing the record releases the binding handles.
+ */
+class NodeRawReceivedRecord {
+    received;
+    sourceRid;
+    sourceRoute;
+    routeGeneration;
+    requestSeq;
+    reply;
+    parts;
+    closed = false;
+    constructor(received, nextRequestSequence, reply) {
+        this.received = received;
+        const routingId = received.routingId;
+        this.sourceRid = routingId?.toString() ?? '';
+        this.sourceRoute = routingId?.toBytes() ?? EMPTY_SOURCE_ROUTE;
+        this.routeGeneration = received.routeGeneration;
+        const replyToken = received.replyToken;
+        if (replyToken !== null) {
+            this.requestSeq = nextRequestSequence?.();
+            if (reply === undefined) {
+                const operation = received.reply();
+                this.reply = (parts) => appendReplyParts(operation, parts).submit();
+            }
+            else {
+                const target = routingId ?? bindingRoutingId(EMPTY_SOURCE_ROUTE);
+                this.reply = (parts) => reply(target, replyToken, parts);
+            }
+        }
+        const parts = received.parts;
+        const retained = new Array(parts.length);
+        for (let index = 0; index < parts.length; index++)
+            retained[index] = runtime_message_1.ZLinkBufferMessage.retainPayload(parts[index]);
+        this.parts = retained;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.received.close();
+    }
+}
 function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
     const received = new zlink_1.Received();
     if (!socket.recv(received, dontWait ? zlink_1.RecvFlags.DontWait : zlink_1.RecvFlags.None)) {
         received.close();
         return undefined;
     }
-    let closed = false;
     try {
-        const sourceRid = received.routingId?.toString() ?? '';
-        const sourceRoute = received.routingId?.toBytes() ?? Buffer.alloc(0);
-        const requestSeq = received.replyToken === null ? undefined : nextRequestSequence?.();
-        const replyToken = received.replyToken;
-        const receivedReply = replyToken === null
-            ? undefined
-            : reply === undefined
-                ? received.reply()
-                : (parts) => reply(sourceRoute, replyToken, parts);
-        return {
-            sourceRid,
-            sourceRoute,
-            routeGeneration: received.routeGeneration,
-            ...(requestSeq === undefined ? {} : { requestSeq }),
-            ...(receivedReply === undefined
-                ? {}
-                : {
-                    reply: (parts) => {
-                        if (typeof receivedReply === 'function') {
-                            receivedReply(parts);
-                            return;
-                        }
-                        appendReplyParts(receivedReply, parts).submit();
-                    }
-                }),
-            parts: received.parts.map((part) => part.toBytes()),
-            close: () => {
-                if (closed)
-                    return;
-                closed = true;
-                received.close();
-            }
-        };
+        return new NodeRawReceivedRecord(received, nextRequestSequence, reply);
     }
     catch (error) {
         received.close();
         throw error;
     }
 }
+/**
+ * Continues once on the binding reply. Admission that completed at submit is
+ * confirmed in this turn; a backpressured submission keeps the admission
+ * wait that bounds it by the request deadline.
+ */
+function requestReply(submission, deadlineMs, recordReceived, onAdmitted) {
+    if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
+        return (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, recordReceived, onAdmitted).then(retainAndClose, rejectCompletion);
+    }
+    try {
+        onAdmitted?.();
+    }
+    catch (error) {
+        return Promise.reject((0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion'));
+    }
+    return submission.reply.then((replies) => {
+        try {
+            recordReceived?.();
+            return retainAndClose(replies);
+        }
+        catch (error) {
+            throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
+        }
+    }, rejectCompletion);
+}
+function rejectCompletion(error) {
+    throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
+}
 function retainAndClose(messages) {
     try {
         return messages.map((message) => runtime_message_1.ZLinkBufferMessage.retainPayload(message));

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

@@ -7,7 +7,7 @@ import { type RawServiceRequestResult } from '../../foundation/raw-service-mesh-
 import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
 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 ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSessionOwnerDescriptors, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
 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';
@@ -38,7 +38,8 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private stateful?;
     private readyHandler?;
     private maintenanceTimer?;
-    private pumping;
+    private maintenanceDueMs;
+    private pumpTask?;
     private readable;
     private readonly onReadable;
     private readonly onMaintenance;
@@ -55,6 +56,8 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private protocolError?;
     private messageFollowHandler?;
     private dispatchErrors?;
+    private sessionOwnerDescriptors?;
+    private requestSourceAcceptance?;
     private readonly peerDisconnectedHandlers;
     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: {
@@ -70,6 +73,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly owner: string;
     }) => void): void;
     setDispatchErrorReporter(reporter: ZLinkDispatchErrorReporter): void;
+    setSessionOwnerDescriptors(source: ServiceSessionOwnerDescriptors): void;
     setProtocolErrorHandler(handler: (record: {
         readonly sourceNodeRid: string;
         readonly request: boolean;
@@ -87,9 +91,10 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     start(): void;
     setMessageFollowHandler(handler: (record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord) => void): void;
     sendMessageFollowNotification(targetNodeRid: string, record: Omit<import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord, 'kind'>): Promise<boolean>;
-    shutdown(_timeoutMs: number): RequestResultValue;
+    shutdown(_timeoutMs: number): Promise<RequestResultValue>;
+    cancelPendingOperations(reason: unknown): void;
     publishDraining(): Promise<void>;
-    close(): void;
+    close(): Promise<void>;
     addChannelName(name: string): void;
     setChannelWeight(name: string, weight: number): Promise<void>;
     setPlacementWeight(weight: number): Promise<void>;
@@ -99,6 +104,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly expectedSecurityIdentity?: string;
         readonly expectedLifecycleGeneration?: bigint;
     }): Promise<bigint>;
+    setRequestSourceAcceptance(acceptance: import('../contracts').ZLinkBackendRequestSourceAcceptance): void;
     expectPeer(peer: {
         readonly nodeRoutingId: string;
         readonly endpoint: string;
@@ -114,6 +120,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly endpoint: string;
     }[]): void;
     isObjectClientNodeDirectTarget(targetRid: unknown): boolean;
+    waitForPeerRoute(targetRid: unknown, lifecycleGeneration: bigint, deadlineUnixMs: bigint, signal?: AbortSignal): Promise<void>;
     observePeerRoute(targetRid: unknown): import("../../foundation/durable-service-request").PeerRouteObservation;
     hasPeerRouteOrConnectionIntent(targetRid: unknown, endpoint: string): boolean;
     isPeerRouteReady(targetRid: unknown, lifecycleGeneration?: bigint): boolean;
@@ -199,7 +206,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     entrySpotRouteFence(targetNodeRid: string, targetSpotId: string): ServiceDirectSpotRouteFence;
     sealSpotMessageFollowIngress(source: ServiceDirectSpotRouteFence): ServiceSpotMessageFollowSeal | undefined;
     abortSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal): boolean;
-    commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
+    commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence | null, 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, onAdmitted?: () => void): MeshOperationId;
@@ -229,11 +236,19 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly phase: 'admission';
         readonly transferId: string;
     }, timeoutMs?: number): MeshOperationId;
-    sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
+    sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
+        readonly flags?: number;
+        readonly routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
+    }): Promise<SubmitResultValue>;
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
         readonly onAdmitted?: () => void;
+        readonly routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
     }): MeshOperationId;
+    acceptRelocatedActorTerminal(operation: {
+        readonly high: bigint;
+        readonly low: bigint;
+    }, replyRouteId: bigint, result: import('../../foundation/service-stateful-runtime').ServiceStatefulResult): 'terminalReceived' | 'alreadyTerminal' | undefined;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[]): Promise<SubmitResultValue>;
     actorRequestToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
@@ -252,13 +267,23 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     clearSpotSubscriptions(state: ServiceSpotState): void;
     private createDescriptor;
     private resolveAdvertisedEndpoint;
+    /**
+     * Arms the one maintenance timer for the nearest management deadline
+     * (spec 08 §4.2): request expiry, liveness, or a pending peer handshake.
+     * An earlier deadline re-arms it; a later one keeps the armed time.
+     */
     private scheduleMaintenance;
     private pump;
-    private isClosed;
+    private runPump;
     private notifyReady;
+    /**
+     * The raw registry takes a remote request's terminal and hands it here,
+     * where the Framework completion owner receives it in the same turn.
+     */
+    private readonly requestObserver;
+    private observedOperation;
     private observeCompletion;
     private observeStateful;
-    private observeImmediateFailure;
     private deliverCompletion;
     private drainMailbox;
     private requireRuntime;