@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -4,7 +4,9 @@ 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 {
     sharedContext;
     routerReceiveTimeoutMs;
@@ -174,13 +176,41 @@ 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) => {
+        // 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')
+            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));
+        (0, node_socket_backend_adapter_1.disconnectSocketPeer)(this.socket, this.preparedRoutingId(routingId));
     }
     constructor(socket, receiveTimeoutMs) {
         super(socket, true);
@@ -197,42 +227,36 @@ 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(bindingRoutingId(targetRid)), parts);
+        return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
     }
-    async request(targetRid, parts, timeoutMs, recordReceived) {
-        this.requireOpen();
-        const deadlineMs = performance.now() + timeoutMs;
+    request(targetRid, parts, timeoutMs, recordReceived, onAdmitted) {
         let submission;
+        const deadlineMs = performance.now() + timeoutMs;
         try {
-            submission = appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+            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);
-            return copyAndClose(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();
@@ -243,14 +267,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 {
@@ -266,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) {
-        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);
-            return copyAndClose(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();
@@ -343,56 +354,97 @@ 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;
     }
 }
-function copyAndClose(messages) {
+/**
+ * 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) => 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

@@ -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';
@@ -30,7 +30,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readonly channels;
     private readonly peerIntents;
     private completionHandler?;
-    private readonly routingId;
+    readonly routingId: string;
     private readonly lifecycleGeneration;
     private bindEndpoint?;
     private advertiseHost?;
@@ -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;
@@ -80,16 +84,17 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
     instanceSpotPlacementTypes(): readonly string[];
     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;
+    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;
     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,19 +120,26 @@ 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;
-    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;
@@ -193,10 +206,10 @@ 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): 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;
@@ -223,20 +236,30 @@ 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;
+        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;
@@ -244,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;