@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/application-jobs/application-ingress-record-owner.d.ts

@@ -29,6 +29,7 @@ export declare class ApplicationJobRecordLease implements ApplicationJobPermitPo
     private processingTerminal;
     detachedForHandlerTurn: boolean;
     constructor(shared: SharedIngressRecordState, permit: ApplicationJobPermitPort | undefined);
+    reacquire(signal: AbortSignal): Promise<ApplicationJobPermitPort>;
     get origin(): ApplicationJobOrigin;
     markApplicationQueued(): void;
     detachForHandlerTurn(): void;

package/dist/runtime/application-jobs/application-ingress-record-owner.js

@@ -84,6 +84,9 @@ class ApplicationJobRecordLease {
         this.shared = shared;
         this.permit = permit;
     }
+    reacquire(signal) {
+        return this.shared.acquirePermit(signal);
+    }
     get origin() {
         return this.shared.origin;
     }

package/dist/runtime/backend/contracts/index.d.ts

@@ -1,3 +1,5 @@
+import type { PendingOperation } from '../../foundation/operation-registry';
+import type { RequestRuntime } from '../../foundation/request-runtime';
 import type { RequestResult, SubmitResult, ZLinkBackendMessageLike, ZLinkBackendMonitorEventType, ZLinkBackendReceived, ZLinkBackendTopicMessage } from '../runtime-values';
 import type { CoreHwmBudgetSnapshot, ReceiveFlowState } from '@zlink-systems/zlink';
 import { type ZLinkBackendRecvFlags, type ZLinkBackendSendFlags } from '../runtime-values';
@@ -34,6 +36,7 @@ export type ZLinkBackendObjectPlacement = {
 };
 export type ZLinkBackendRequestSourceAcceptance = (nodeRid: string, nodeGeneration: bigint, nodeRidStorageHex: string, signal?: AbortSignal) => import('../../locations/request-source-resolver').ZLinkRequestSourceFence | undefined | Promise<import('../../locations/request-source-resolver').ZLinkRequestSourceFence | undefined>;
 export interface ZLinkBackendMeshNode {
+    setRequestRuntime?(requests: RequestRuntime): void;
     acceptRelocatedActorTerminal?(operation: {
         readonly high: bigint;
         readonly low: bigint;
@@ -76,9 +79,9 @@ export interface ZLinkBackendMeshNode {
     selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
     instanceSpotPlacementTypes?(): readonly string[];
     sendToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): MeshOperationId;
+    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): MeshOperationId;
     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;
+    requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>, completion?: ZLinkMeshCompletionHandler): MeshOperationId;
     registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
     requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
     requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
@@ -130,24 +133,27 @@ export interface ZLinkBackendMeshNode {
      */
     requestInfrastructureControlFrames?(targetRid: unknown, frames: readonly Uint8Array[], options?: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onSubmitted?: (signal: AbortSignal) => Promise<void>;
     }): Promise<readonly Uint8Array[]>;
     requestToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         applicationMetadata?: Buffer;
         onAdmitted?: () => void;
-    }): MeshOperationId;
+    }, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
     }): Promise<SubmitResult>;
     requestToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         applicationMetadata?: Buffer;
         onAdmitted?: () => void;
-    }): MeshOperationId;
+    }, completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler): MeshOperationId;
     status(): MeshNodeStatus;
     peers(): MeshPeerEntry[];
     peerChannels(peerRid: unknown, lifecycleGeneration: bigint): {
@@ -212,16 +218,18 @@ export interface ZLinkBackendMeshNode {
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         applicationMetadata?: Buffer;
         onAdmitted?: () => void;
         routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
-    }): MeshOperationId;
+    }, completion?: ZLinkMeshCompletionHandler): MeshOperationId;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
     }): Promise<SubmitResult>;
     actorRequestToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         applicationMetadata?: Buffer;
         onAdmitted?: () => void;
     }): MeshOperationId;
@@ -308,7 +316,8 @@ export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket
     receiveTimeoutMs: number;
     maxMessageSize: number;
     send(message: Message | readonly Message[]): Promise<void>;
-    request(message: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
+    request(message: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void, requestOperation?: undefined): Promise<readonly Message[]>;
+    request(message: Message | readonly Message[], timeoutMs: number | undefined, onAdmitted: (() => void) | undefined, requestOperation: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
     recv(flags?: ZLinkBackendRecvFlags): Received | undefined;
 }
 export interface ZLinkBackendReplyOperation {
@@ -323,6 +332,7 @@ export interface ZLinkBackendRequestOperation {
     message(message: MessageLike): ZLinkBackendRequestOperation;
     timeout(timeoutMs: number): ZLinkBackendRequestOperation;
     submit(onAdmitted?: () => void): Promise<readonly Message[]>;
+    submit(onAdmitted: (() => void) | undefined, requestOperation: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
 }
 export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket {
     setReceiveFlowState(state: ReceiveFlowState): void;
@@ -336,9 +346,11 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     setRoutingId(routingId: RoutingId): void;
     recv(flags?: ZLinkBackendRecvFlags): Received | undefined;
     send(routingId: RoutingId, message: Message | readonly Message[]): Promise<void>;
-    request(routingId: RoutingId, message: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
+    request(routingId: RoutingId, message: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void, requestOperation?: undefined): Promise<readonly Message[]>;
+    request(routingId: RoutingId, message: Message | readonly Message[], timeoutMs: number | undefined, onAdmitted: (() => void) | undefined, requestOperation: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
     sendToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], flags?: ZLinkBackendSendFlags): Promise<void>;
-    requestToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
+    requestToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], timeoutMs?: number, onAdmitted?: () => void, requestOperation?: undefined): Promise<readonly Message[]>;
+    requestToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], timeoutMs: number | undefined, onAdmitted: (() => void) | undefined, requestOperation: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
     disconnectPeer(routingId: RoutingId): void;
     reply(routingId: RoutingId, replyToken: unknown): ZLinkBackendReplyOperation;
     reply(routingId: RoutingId, replyToken: unknown, message: Message | readonly Message[]): void;
@@ -438,11 +450,13 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     drainReply(): number;
     drainChannelReply(subjectHandle: bigint): number;
     setDispatchHandler(handler: (info: ZLinkBackendSpotDispatchInfo) => void): void;
-    requestToChannel(channelName: string, payload: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
+    requestToChannel(channelName: string, payload: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void, requestOperation?: undefined): Promise<readonly Message[]>;
+    requestToChannel(channelName: string, payload: Message | readonly Message[], timeoutMs: number | undefined, onAdmitted: (() => void) | undefined, requestOperation: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
     sendToChannel(channelName: string, payload: Message | readonly Message[]): Promise<void>;
     publish(topic: string, payload: Message | readonly Message[], flags: ZLinkBackendSendFlags): boolean;
     sendToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[]): Promise<void>;
-    requestToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
+    requestToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void, requestOperation?: undefined): Promise<readonly Message[]>;
+    requestToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[], timeoutMs: number | undefined, onAdmitted: (() => void) | undefined, requestOperation: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
     dispose(): Promise<void>;
 }
 export interface ZLinkChannelBackendAdapter {
@@ -458,6 +472,8 @@ export interface ZLinkMeshBackendAdapter {
     createMeshNode(context: ZLinkBackendContext, options: {
         readonly meshName: string;
         readonly routingId?: RoutingId;
+        readonly sendHighWaterMark?: number;
+        readonly receiveHighWaterMark?: number;
         readonly receiveTimeoutMs?: number;
         readonly trustProfile?: string;
         readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;

package/dist/runtime/backend/mesh-completion-table.d.ts

@@ -1,3 +1,4 @@
+import { type OperationHandle, type OperationObserver } from '../foundation/operation-registry';
 import { ZLinkBufferMessage as Message } from './runtime-message';
 import type { MeshOperationId, ReceiveKindData, ReceiveRecord } from '../foundation/service-runtime-contracts';
 export interface ZLinkMeshCompletionDiagnostic {
@@ -8,10 +9,14 @@ export interface ZLinkMeshCompletionDiagnostic {
 export interface ZLinkMeshCompletion {
     readonly terminalResult: number;
     readonly failureErrno: number;
+    readonly failureMessage?: string;
     readonly operationKind: number;
     readonly kindData: ReceiveKindData | null;
     readonly parts: Message[];
 }
+export interface MeshOperationSubmission extends MeshOperationId {
+    readonly requestOperation?: OperationHandle<unknown>;
+}
 export type ZLinkMeshCompletionTerminal = Pick<ReceiveRecord, 'operationId' | 'terminalResult'>;
 export type ZLinkMeshCompletionHandler = (terminal: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord) => void;
 export declare class ZLinkMeshCompletionTable {
@@ -32,7 +37,8 @@ export declare class ZLinkMeshCompletionTable {
      * observes native terminals through Promises, so identity binding finishes
      * before the terminal callback can run, without an infrastructure pump.
      */
-    submit(operation: () => MeshOperationId, signal?: AbortSignal): Promise<ZLinkMeshCompletion>;
+    submit(operation: (completion?: ZLinkMeshCompletionHandler) => MeshOperationSubmission, signal: AbortSignal | undefined, requestOperation: OperationHandle<unknown>, receiver: OperationObserver<unknown, unknown>): void;
+    submit(operation: () => MeshOperationSubmission, signal?: AbortSignal, requestOperation?: OperationHandle<unknown>): Promise<ZLinkMeshCompletion>;
     private isDisposed;
     complete(record: ReceiveRecord): void;
     complete(record: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord): void;

package/dist/runtime/backend/mesh-completion-table.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkMeshCompletionTable = void 0;
 exports.closeMeshCompletion = closeMeshCompletion;
+const request_deadline_1 = require("../messaging/request-deadline");
+const operation_registry_1 = require("../foundation/operation-registry");
 const runtime_message_1 = require("./runtime-message");
 const operation_identity_1 = require("../foundation/operation-identity");
 const COMPLETION_SLOT_BLOCK_SIZE = 64;
@@ -19,6 +21,7 @@ class CompletionSlot {
     resolve;
     reject;
     signal;
+    operation;
     constructor(abort) {
         this.abort = abort;
     }
@@ -40,10 +43,13 @@ class ZLinkMeshCompletionTable {
             const slot = new CompletionSlot(() => {
                 const reject = slot.reject;
                 const signal = slot.signal;
-                if (reject === undefined)
+                if (reject === undefined || (slot.high === undefined && slot.operation === undefined))
+                    return;
+                const reason = signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError');
+                if (slot.operation !== undefined && !slot.operation.takeFailure(reason))
                     return;
                 this.releaseSlot(index);
-                reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+                reject(reason);
             });
             slot.next = this.free;
             this.slots.push(slot);
@@ -107,22 +113,43 @@ class ZLinkMeshCompletionTable {
         slot.low = undefined;
         slot.hashNext = -1;
         slot.signal = undefined;
+        slot.operation = undefined;
         slot.resolve = undefined;
         slot.reject = undefined;
         slot.next = this.free;
         this.free = index;
         this.activeCount--;
     }
-    /**
-     * Reserves the dispatcher slot before transport submission. The backend
-     * observes native terminals through Promises, so identity binding finishes
-     * before the terminal callback can run, without an infrastructure pump.
-     */
-    submit(operation, signal) {
+    submit(operation, signal, requestOperation, receiver) {
+        if (receiver !== undefined && requestOperation?.promise !== undefined) {
+            if (requestOperation.isPending()) {
+                try {
+                    operation((_terminal, materialize) => {
+                        try {
+                            receiver.operationCompleted(requestOperation.id, retainCompletion(materialize()), undefined);
+                        }
+                        catch (error) {
+                            receiver.operationFailed(requestOperation.id, error, undefined);
+                        }
+                    });
+                }
+                catch (error) {
+                    receiver.operationFailed(requestOperation.id, error, undefined);
+                }
+            }
+            return;
+        }
+        if (requestOperation?.promise !== undefined && !requestOperation.isPending()) {
+            return requestOperation.promise.then(() => {
+                throw new operation_registry_1.OperationCancelledError(requestOperation.id, 'Request is already terminal.');
+            });
+        }
         if (this.isDisposed()) {
+            requestOperation?.takeFailure(new Error('Mesh completion table is disposed.'));
             return Promise.reject(new Error('Mesh completion table is disposed.'));
         }
         if (signal?.aborted === true) {
+            requestOperation?.takeFailure(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
             return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
         }
         return new Promise((resolve, reject) => {
@@ -135,9 +162,23 @@ class ZLinkMeshCompletionTable {
             slot.resolve = resolve;
             slot.reject = reject;
             slot.signal = signal;
+            slot.operation = requestOperation;
             this.activeCount++;
             try {
                 signal?.addEventListener('abort', slot.abort, COMPLETION_ABORT_OPTIONS);
+                const bind = (entry, observeFailure = true) => {
+                    slot.operation = entry;
+                    if (!observeFailure)
+                        return;
+                    entry.setFailureDispatcher((reason) => {
+                        if (slot.generation !== generation || slot.resolve !== resolve)
+                            return;
+                        this.releaseSlot(index);
+                        reject((0, request_deadline_1.requestTerminalError)('Request', reason));
+                    });
+                };
+                if (requestOperation !== undefined)
+                    bind(requestOperation);
                 const operationId = operation();
                 // A reentrant abort may release and reuse this slot during submission.
                 if (slot.generation !== generation || slot.resolve !== resolve)
@@ -148,10 +189,18 @@ class ZLinkMeshCompletionTable {
                 slot.high = operationId.high;
                 slot.low = operationId.low;
                 this.indexSlot(index);
+                if (requestOperation === undefined && operationId.requestOperation !== undefined)
+                    bind(operationId.requestOperation, false);
+                Reflect.deleteProperty(operationId, 'requestOperation');
+                if (signal?.aborted === true)
+                    slot.abort();
             }
             catch (error) {
-                if (slot.generation === generation && slot.resolve === resolve)
-                    this.releaseSlot(index);
+                if (slot.generation !== generation || slot.resolve !== resolve)
+                    return;
+                if (slot.operation !== undefined && !slot.operation.replyFailure(error))
+                    return;
+                this.releaseSlot(index);
                 reject(error);
             }
         });
@@ -170,14 +219,25 @@ class ZLinkMeshCompletionTable {
             return;
         }
         const slot = this.slots[index];
-        const resolve = slot.resolve;
-        const reject = slot.reject;
-        this.releaseSlot(index);
-        try {
-            resolve(retainCompletion(materialize === undefined ? record : materialize()));
-        }
-        catch (error) {
-            reject(error);
+        const generation = slot.generation;
+        const deliver = () => {
+            if (slot.generation !== generation || slot.resolve === undefined)
+                return;
+            const resolve = slot.resolve;
+            const reject = slot.reject;
+            this.releaseSlot(index);
+            try {
+                resolve(retainCompletion(materialize === undefined ? record : materialize()));
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        if (slot.operation === undefined)
+            deliver();
+        else {
+            slot.operation.reply(record);
+            deliver();
         }
     }
     dispose(reason = new Error('Mesh completion table is disposed.')) {
@@ -189,6 +249,9 @@ class ZLinkMeshCompletionTable {
             const reject = this.slots[index].reject;
             if (reject === undefined)
                 continue;
+            const slot = this.slots[index];
+            if (slot.operation !== undefined && !slot.operation.takeFailure(reason))
+                continue;
             this.releaseSlot(index);
             reject(reason);
         }
@@ -206,6 +269,7 @@ function retainCompletion(record) {
     return {
         terminalResult: record.terminalResult,
         failureErrno: record.failureErrno,
+        ...(record.failureMessage === undefined ? {} : { failureMessage: record.failureMessage }),
         operationKind: record.operationKind,
         kindData: record.kindData,
         parts
@@ -227,7 +291,7 @@ function closeMeshCompletion(completion) {
     closeParts(completion.parts);
 }
 function closeParts(parts) {
-    for (const part of parts) {
-        part.close();
+    for (let index = 0; index < parts.length; index++) {
+        parts[index].close();
     }
 }

package/dist/runtime/backend/mesh-dispatch-pump.d.ts

@@ -3,7 +3,6 @@ import { type ReadyRecord, type ReceiveRecord } from '../foundation/service-runt
 import type { ZLinkBackendMeshNode } from './contracts';
 export interface ZLinkMeshDispatchPumpOptions {
     readonly readyCapacity?: number;
-    readonly messageCapacity?: number;
     readonly partCapacity?: number;
     readonly dispatch: (owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
     readonly applicationJobQueue: ApplicationJobQueuePort;
@@ -37,21 +36,25 @@ export declare class ZLinkMeshDispatchPump {
     start(): void;
     dispose(signal?: AbortSignal): Promise<void>;
     private markReady;
+    private scheduleApplicationWorker;
     private wakeApplicationWorker;
     private startApplicationWorker;
-    private runApplicationWorker;
     private waitForApplicationReady;
     /**
      * Starts one record in this worker's turn; a permit's scope covers the
-     * synchronous dispatch. Returns `false` when the dispatch threw (already
-     * reported), `true` when it returned synchronously, or the handler's pending
-     * completion, which the draining turn awaits itself before
+     * synchronous dispatch. Returns `false` when preparation rejects the record,
+     * shutdown starts, or dispatch throws (already reported), `true` when dispatch
+     * returns synchronously, or the pending preparation/handler completion,
+     * which the draining turn awaits itself before
      * {@link finishRecord}.
      */
     private dispatchRecord;
+    private continuePreparingRecord;
+    private invokeRecord;
     private failRecord;
     /** Runs the record's terminal completion, then releases its permit turn. */
     private finishRecord;
+    private finishPendingRecord;
     private reportDispatchError;
     /**
      * Infrastructure controls must not wait for an application permit. During
@@ -68,8 +71,18 @@ export declare class ZLinkMeshDispatchPump {
      * pump, its batch budget starts with it (spec 08 §6).
      */
     private beginDrain;
-    /** Drains one claimed owner in this worker's turn, in claim order. */
+    /** Each worker owns claim continuations for its entire lifetime. */
+    private runApplicationWorker;
     private drainClaim;
+    private createClaimDrain;
+    /** A synchronous claim finishes without an async wrapper or a Promise. */
+    private dispatchClaim;
+    private receiveClaim;
+    private dispatchClaimRecords;
+    private observeRecordTerminal;
+    private continuePendingClaim;
+    private releaseRecord;
+    private finishClaim;
     /**
      * The batch budget is shared by every drain of this pump, so once it is
      * spent every drain waits for the same macrotask boundary; one drain that