@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/channels/spot-route-dispatch-strategy.d.ts

@@ -13,6 +13,7 @@ export interface ZLinkLocalSpotRouteDispatcher {
     request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: {
         readonly channelName: string;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<TReply>;
 }
@@ -39,10 +40,10 @@ export declare class ZLinkSpotRouteDispatchStrategy {
     canRoutePacketChannel(routerChannelId: string): boolean;
     routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     private routeSendToSpotScoped;
-    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     private routeRequestToSpotScoped;
-    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
     routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
-    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
-    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/spot-route-dispatch-strategy.js

@@ -70,58 +70,58 @@ class ZLinkSpotRouteDispatchStrategy {
         }
         await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
     }
-    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata));
+    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
+    async routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
         if (localSpotRouteNode !== undefined) {
-            return this.localTransport.request(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, request, timeoutMs, signal);
+            return this.localTransport.request(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, request, timeoutMs, signal, onAdmitted);
         }
         const codecs = (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.options.codecs);
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, spotRouteTarget.routerChannelId, packetName, request, timeoutMs, undefined, codecs, undefined, this.options.flowCreationEnabled?.() ?? true, metadata);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId)) {
-            const namedSpotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal);
+            const namedSpotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
             if (namedSpotNodeRequest !== undefined)
                 return namedSpotNodeRequest;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            return this.bridgeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal);
+            return this.bridgeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
         }
         if (this.targets.hasBoundRouteRouter(spotRouteTarget.routerChannelId)) {
-            return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, ZLINK_SEND_DONT_WAIT, timeoutMs, signal);
+            return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, ZLINK_SEND_DONT_WAIT, timeoutMs, signal, onAdmitted);
         }
-        const spotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal);
+        const spotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
         if (spotNodeRequest !== undefined) {
             return spotNodeRequest;
         }
-        return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, 0, timeoutMs, signal);
+        return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, 0, timeoutMs, signal, onAdmitted);
     }
-    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
-        return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
+    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted) {
+        return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted);
     }
     async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
         await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
-    routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
-        return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal);
+    routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
+        return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted);
     }
-    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal) {
+    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId)) {
-            const namedSpotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+            const namedSpotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
             if (namedSpotNodeRequest !== undefined)
                 return namedSpotNodeRequest;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            return this.bridgeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+            return this.bridgeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
         }
-        const spotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+        const spotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
         if (spotNodeRequest !== undefined) {
             return spotNodeRequest;
         }
-        return this.routerSocketTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+        return this.routerSocketTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
     }
 }
 exports.ZLinkSpotRouteDispatchStrategy = ZLinkSpotRouteDispatchStrategy;

package/dist/runtime/execution/serial-execution-queue.d.ts

@@ -1,5 +1,6 @@
 export type ZLinkSerialWorkLane = 'application' | 'lifecycle';
 export interface ZLinkSerialWorkOptions {
+    readonly onAdmitted?: () => void;
     readonly lane?: ZLinkSerialWorkLane;
     readonly payloadBytes?: number;
     readonly metadataBytes?: number;

package/dist/runtime/execution/serial-execution-queue.js

@@ -181,6 +181,7 @@ class ZLinkSerialExecutionQueue {
             release();
             throw error;
         }
+        options.onAdmitted?.();
         this.scheduleDrain();
         return result;
     }

package/dist/runtime/foundation/actor-join-recovery-codec.js

@@ -56,7 +56,7 @@ function encodeCanonicalActorJoinRecoverySavedWork(input) {
     const request = Buffer.from(input.request);
     const replyContentType = operationId === undefined
         ? null
-        : requireText(input.replyContentType, 'Actor Join reply content type');
+        : (nullableText(input.replyContentType ?? null, 'Actor Join reply content type') ?? null);
     const metadata = encodeMetadataJson({
         Request: {
             ActorId: requireText(input.actorId, 'Actor id'),
@@ -167,7 +167,7 @@ function decodeCanonicalActorJoinRecoverySavedWork(encoded) {
     const operationLow = integer(metadata.OperationIdLow, 'OperationIdLow');
     const hasOperation = operationHigh !== 0n || operationLow !== 0n;
     const replyContentType = nullableText(metadata.ReplyContentType, 'ReplyContentType');
-    if (hasOperation !== (replyContentType !== undefined)) {
+    if (!hasOperation && replyContentType !== undefined) {
         throw new TypeError('Canonical Actor Join recovery reply identity is invalid.');
     }
     const targetNodeRid = base64(metadata.TargetNodeRid, 'TargetNodeRid');

package/dist/runtime/foundation/durable-service-request.d.ts

@@ -0,0 +1,14 @@
+export interface PeerRouteObservation {
+    readonly generation?: bigint;
+    readonly ready: boolean;
+}
+export interface DurableServiceRequestPort {
+    readonly requestStopSignal?: AbortSignal;
+    observePeerRoute(target: string): PeerRouteObservation;
+    observePeerRouteChanged(listener: (target: string) => void): () => void;
+    observePeerConnectionIntentRemoved(listener: (target: string) => void): () => void;
+    requestService(target: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
+}
+/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
+export declare function requestDurableService(port: DurableServiceRequestPort, target: string, parts: readonly Uint8Array[], deadlineMs: number, operationKind: string, signal?: AbortSignal, onSubmitted?: (signal: AbortSignal) => Promise<void>): Promise<readonly Buffer[]>;
+export declare function durableRequestCanReplay(error: unknown): boolean;

package/dist/runtime/foundation/durable-service-request.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDurableService = requestDurableService;
+exports.durableRequestCanReplay = durableRequestCanReplay;
+const abort_1 = require("../abort");
+const runtime_values_1 = require("../backend/runtime-values");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
+async function requestDurableService(port, target, parts, deadlineMs, operationKind, signal, onSubmitted) {
+    let wasAdmitted = false;
+    const stop = new AbortController();
+    const exhausted = (cause) => (0, framework_errors_internal_1.createInternalFrameworkException)(wasAdmitted
+        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded
+        : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} exhausted its end-to-end deadline.`, true, cause);
+    const timer = setTimeout(() => stop.abort(exhausted()), Math.max(0, Math.ceil(deadlineMs - performance.now())));
+    const unobserveIntent = port.observePeerConnectionIntentRemoved((rid) => {
+        if (rid === target)
+            stop.abort((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} target node lifecycle ended.`, true));
+    });
+    const cancellation = AbortSignal.any([
+        stop.signal,
+        ...(signal === undefined ? [] : [signal]),
+        ...(port.requestStopSignal === undefined ? [] : [port.requestStopSignal])
+    ]);
+    try {
+        for (;;) {
+            cancellation.throwIfAborted();
+            const remainingMs = Math.ceil(deadlineMs - performance.now());
+            if (remainingMs <= 0)
+                throw exhausted();
+            let changed;
+            const transition = new Promise((resolve) => {
+                changed = resolve;
+            });
+            let submittedGeneration;
+            const attemptStop = new AbortController();
+            const attemptSignal = AbortSignal.any([cancellation, attemptStop.signal]);
+            const unobserveRoute = port.observePeerRouteChanged((rid) => {
+                if (rid !== target)
+                    return;
+                const route = port.observePeerRoute(target);
+                if (submittedGeneration === undefined
+                    ? route.ready
+                    : route.generation !== undefined && route.generation !== submittedGeneration) {
+                    changed();
+                    attemptStop.abort();
+                }
+            });
+            try {
+                const route = port.observePeerRoute(target);
+                if (!route.ready) {
+                    await (0, abort_1.awaitWithAbort)(transition, cancellation);
+                    continue;
+                }
+                submittedGeneration = route.generation;
+                const reply = port.requestService(target, parts, remainingMs, () => {
+                    wasAdmitted = true;
+                });
+                const request = onSubmitted === undefined
+                    ? reply
+                    : Promise.race([
+                        reply,
+                        Promise.resolve()
+                            .then(() => onSubmitted(attemptSignal))
+                            .then(() => reply)
+                    ]);
+                const result = await (0, abort_1.awaitWithAbort)(Promise.race([request.then((parts) => ({ parts })), transition.then(() => undefined)]), cancellation);
+                if (result !== undefined)
+                    return result.parts;
+            }
+            catch (error) {
+                cancellation.throwIfAborted();
+                if (!durableRequestCanReplay(error))
+                    throw error;
+                if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request')
+                    wasAdmitted = true;
+            }
+            finally {
+                attemptStop.abort();
+                unobserveRoute();
+            }
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        unobserveIntent();
+    }
+}
+function durableRequestCanReplay(error) {
+    if (!(0, runtime_values_1.isZLinkBackendResultError)(error))
+        return false;
+    return error.operation === 'request'
+        ? error.result === runtime_values_1.RequestResult.NotConnected || error.result === runtime_values_1.RequestResult.TimedOut
+        : error.result === runtime_values_1.SubmitResult.NotConnected ||
+            error.result === runtime_values_1.SubmitResult.NotFound ||
+            error.result === runtime_values_1.SubmitResult.NotAdmitted ||
+            error.result === runtime_values_1.SubmitResult.Backpressured;
+}

package/dist/runtime/foundation/operation-identity.d.ts

@@ -10,5 +10,6 @@ export type ZLinkOperationIdentityKey = string & {
     readonly [operationKeyBrand]: true;
 };
 export declare function operationIdentityKey(operationId: ZLinkOperationIdentity128): ZLinkOperationIdentityKey;
+export declare function validateOperationIdentity(operationId: ZLinkOperationIdentity128): void;
 export declare function createRandomOperationIdentity(source?: (size: number) => Buffer): ZLinkOperationIdentity128;
 export {};

package/dist/runtime/foundation/operation-identity.js

@@ -2,18 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = exports.OPERATION_IDENTITY_BYTES = void 0;
 exports.operationIdentityKey = operationIdentityKey;
+exports.validateOperationIdentity = validateOperationIdentity;
 exports.createRandomOperationIdentity = createRandomOperationIdentity;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
 exports.OPERATION_IDENTITY_BYTES = 16;
 exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = 2n;
 function operationIdentityKey(operationId) {
+    validateOperationIdentity(operationId);
+    return `${operationId.high.toString(16)}:${operationId.low.toString(16)}`;
+}
+function validateOperationIdentity(operationId) {
     requireUnsigned64(operationId.high, 'operationId.high');
     requireUnsigned64(operationId.low, 'operationId.low');
     if (operationId.high === 0n && operationId.low === 0n) {
         throw new RangeError('Operation identity must not be all zero.');
     }
-    return `${operationId.high.toString(16)}:${operationId.low.toString(16)}`;
 }
 function createRandomOperationIdentity(source = node_crypto_1.randomBytes) {
     for (;;) {

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -17,6 +17,7 @@ export interface RawServiceRequestResult {
 /** An M6A application frame already owned by the Framework runtime. */
 type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
 export interface RawServiceIngressRecord {
+    readonly onAdmitted?: () => void;
     readonly command: number;
     readonly flags: number;
     readonly sourceRoutingId: string;
@@ -63,6 +64,7 @@ export declare class RawServiceMeshRuntime {
     private readonly expectedPeers;
     private readonly endpointOnlyPeers;
     private readonly peerConnectionIntentRemoved;
+    private readonly peerRouteChanged;
     /**
      * The last observed Core selected route of each RID (Core ROUTER §10.1):
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
@@ -70,10 +72,12 @@ export declare class RawServiceMeshRuntime {
     private selectedRoutes;
     private readonly bindingPort;
     private readonly applicationJobQueue;
+    private readonly nodeMailboxOwner;
     private readonly peerAdmissionSealed?;
     private readonly applicationJobStop;
     private receiveAcquisition?;
     private receivePermit?;
+    private receiveRotation?;
     private readonly controlSends;
     private infrastructureFailure?;
     private readonly onReceiveReady?;
@@ -88,6 +92,7 @@ export declare class RawServiceMeshRuntime {
     private router?;
     private nextCorrelation;
     private serviceIngress?;
+    private serviceIngressAccepts?;
     private closed;
     constructor(options: RawServiceMeshRuntimeOptions);
     start(): void;
@@ -98,6 +103,11 @@ export declare class RawServiceMeshRuntime {
     disconnectPeer(endpoint: string, nodeRoutingId: string, lifecycleGeneration?: bigint): void;
     disconnectPeerEndpoint(endpoint: string): void;
     observePeerConnectionIntentRemoved(listener: (nodeRoutingId: string) => void): () => void;
+    observePeerRoute(nodeRoutingId: string): import('./durable-service-request').PeerRouteObservation;
+    get requestStopSignal(): AbortSignal;
+    observePeerRouteChanged(listener: (nodeRoutingId: string) => void): () => void;
+    hasSelectedPeerRoute(nodeRoutingId: string): boolean;
+    private notifyPeerRouteChanged;
     private notifyPeerConnectionIntentRemoved;
     announcePeer(nodeRoutingId: string): Promise<boolean>;
     isPeerRouteReady(nodeRoutingId: string, lifecycleGeneration?: bigint): boolean;
@@ -108,17 +118,18 @@ export declare class RawServiceMeshRuntime {
         readonly channelWeight?: number;
         readonly state?: 'draining';
     }): Promise<void>;
+    private publishLocalDescriptor;
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
-    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
+    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): boolean | Promise<boolean>;
     sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<SubmitResult>;
-    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
-    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
     private selectChannelTarget;
-    setServiceIngress(handler: RawServiceIngressHandler): void;
+    setServiceIngress(handler: RawServiceIngressHandler, accepts?: (command: number) => boolean): void;
     reserveLocalIngress(signal?: AbortSignal): Promise<ApplicationIngressRecordOwner>;
     sendService(targetNodeRoutingId: string, parts: readonly Uint8Array[]): Promise<boolean>;
-    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
+    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
     replyService(record: Pick<RawServiceIngressRecord, 'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'>, parts: readonly Uint8Array[]): void;
     reply(request: ServiceMailboxRecord, payload: ServiceApplicationPayloadInput, terminalResult?: number, failureCode?: number): void;
     pumpOne(nowMs?: number, observe?: RawServicePumpObserver): Promise<RawServicePumpResult>;
@@ -126,9 +137,15 @@ export declare class RawServiceMeshRuntime {
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     pumpBatch(receiveReady?: boolean, routeReady?: boolean): Promise<boolean>;
     private receiveOne;
+    private finishReceive;
     private reportProtocolError;
     private replyGenericProtocolError;
     private processReceived;
+    private receiveProtocolFailure;
+    private processAdmission;
+    private processLiveness;
+    private processApplicationReceived;
+    private enqueueOrdinaryRecord;
     expireOperations(nowMs: number, turnDeadlineMs: number): number;
     get pendingOperationCount(): number;
     tickLiveness(nowMs?: number): ServiceLivenessTick;