@zlink-systems/framework 0.29.1 → 0.30.1

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

@@ -8,7 +8,7 @@ exports.ApplicationJobRecordLease = exports.ApplicationIngressRecordOwner = void
  */
 class ApplicationIngressRecordOwner {
     shared;
-    stop = new AbortController();
+    stop;
     closed = false;
     constructor(shared) {
         this.shared = shared;
@@ -29,13 +29,30 @@ class ApplicationIngressRecordOwner {
         }
         return job;
     }
-    async acquire(domain, signal) {
-        this.requireOpen();
-        const initial = this.shared.takeInitialPermit(domain);
-        if (initial !== undefined)
-            return initial;
-        const waitSignal = signal === undefined ? this.stop.signal : AbortSignal.any([this.stop.signal, signal]);
-        const permit = await this.shared.acquirePermit(waitSignal);
+    acquire(domain, signal) {
+        try {
+            this.requireOpen();
+            const initial = this.shared.takeInitialPermit(domain);
+            if (initial !== undefined)
+                return initial;
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        return this.acquireAdditional(domain, signal);
+    }
+    async acquireAdditional(domain, signal) {
+        const stop = (this.stop ??= new AbortController());
+        const waitSignal = signal === undefined ? stop.signal : AbortSignal.any([stop.signal, signal]);
+        let permit;
+        try {
+            permit = await this.shared.acquirePermit(waitSignal);
+        }
+        catch (error) {
+            if (error === ownerClosedError)
+                throw ownerClosedError();
+            throw error;
+        }
         if (this.closed) {
             permit.releaseAfterInternalProcessing();
             throw ownerClosedError();
@@ -46,7 +63,8 @@ class ApplicationIngressRecordOwner {
         if (this.closed)
             return;
         this.closed = true;
-        this.stop.abort(ownerClosedError());
+        // The queue forwards this reason; only a rejected acquisition constructs the error.
+        this.stop?.abort(ownerClosedError);
         this.shared.releaseOwner();
     }
     requireOpen() {
@@ -60,14 +78,15 @@ class ApplicationJobRecordLease {
     shared;
     permit;
     ingressClosed = false;
-    permitReleased = false;
     processingTerminal = false;
     detachedForHandlerTurn = false;
-    jobReleased = false;
     constructor(shared, permit) {
         this.shared = shared;
         this.permit = permit;
     }
+    get origin() {
+        return this.shared.origin;
+    }
     markApplicationQueued() {
         // The owner classifies and marks the child atomically when it is created;
         // downstream dispatch must not mutate queue accounting a second time.
@@ -76,11 +95,11 @@ class ApplicationJobRecordLease {
         this.detachedForHandlerTurn = true;
     }
     releaseBeforeHandler() {
-        this.releasePermit(() => this.permit.releaseBeforeHandler());
+        this.permit?.releaseBeforeHandler();
     }
     releaseAfterInternalProcessing() {
         this.processingTerminal = true;
-        this.releasePermit(() => this.permit.releaseAfterInternalProcessing());
+        this.permit?.releaseAfterInternalProcessing();
         this.releaseJobIfTerminal();
     }
     close() {
@@ -93,17 +112,17 @@ class ApplicationJobRecordLease {
         }
         this.releaseJobIfTerminal();
     }
-    releasePermit(release) {
-        if (this.permitReleased)
-            return;
-        this.permitReleased = true;
-        release();
-    }
     releaseJobIfTerminal() {
-        if (this.jobReleased || !this.ingressClosed || !this.processingTerminal)
+        const permit = this.permit;
+        if (permit === undefined || !this.ingressClosed || !this.processingTerminal)
             return;
-        this.jobReleased = true;
-        this.shared.releaseJob();
+        this.permit = undefined;
+        try {
+            this.shared.releaseJob();
+        }
+        finally {
+            permit.releaseStorage?.();
+        }
     }
 }
 exports.ApplicationJobRecordLease = ApplicationJobRecordLease;
@@ -114,9 +133,11 @@ class SharedIngressRecordState {
     jobCount = 0;
     initialPermit;
     recordClosed = false;
+    origin;
     constructor(queue, initialPermit, record) {
         this.queue = queue;
         this.record = record;
+        this.origin = initialPermit.origin;
         this.initialPermit = initialPermit;
     }
     retainOwner() {
@@ -138,7 +159,7 @@ class SharedIngressRecordState {
         return this.createJob(permit, domain);
     }
     acquirePermit(signal) {
-        return this.queue.acquire(signal);
+        return this.queue.acquire(signal, this.origin);
     }
     createJob(permit, domain) {
         this.jobCount += 1;
@@ -169,6 +190,7 @@ class SharedIngressRecordState {
             this.initialPermit?.releaseAfterInternalProcessing();
         }
         finally {
+            this.initialPermit?.releaseStorage?.();
             this.initialPermit = undefined;
             this.record.close();
         }

package/dist/runtime/application-jobs/application-job-queue-scope.d.ts

@@ -1,13 +1,16 @@
-import type { ApplicationJobPermitPort } from './contracts';
+import type { ApplicationJobOrigin, ApplicationJobPermitPort } from './contracts';
 /**
  * Carries the host-owned queue permit through internal async dispatch without
  * leaking capacity ownership into public handler contracts.
  */
-export declare function runWithApplicationJobPermit<TResult>(permit: ApplicationJobPermitPort, callback: () => Promise<TResult> | TResult): Promise<TResult>;
+export declare function runWithApplicationJobPermit<TResult>(permit: ApplicationJobPermitPort, callback: () => Promise<TResult>): Promise<TResult>;
+export declare function runWithApplicationJobPermit<TResult, TFirst = undefined, TSecond = undefined>(permit: ApplicationJobPermitPort, callback: (first: TFirst, second: TSecond) => Promise<TResult> | TResult, first?: TFirst, second?: TSecond): TResult | Promise<TResult>;
 /** Releases the current job permit immediately before the first user callback. */
 export declare function releaseApplicationJobPermitBeforeHandler(): void;
 /** True while dispatch already owns the host-wide application job permit. */
 export declare function hasApplicationJobPermit(): boolean;
+/** Keeps the ingress origin when a durable record later reacquires its permit. */
+export declare function currentApplicationJobOrigin(): ApplicationJobOrigin;
 /** Re-enters the captured permit scope when a serial executor runs later. */
 export declare function bindApplicationJobPermit<TResult, TArgument>(callback: (argument?: TArgument) => Promise<TResult> | TResult): (argument?: TArgument) => Promise<TResult> | TResult;
 /**

package/dist/runtime/application-jobs/application-job-queue-scope.js

@@ -4,38 +4,59 @@ exports.runWithApplicationJobPermit = runWithApplicationJobPermit;
 exports.releaseApplicationJobPermitBeforeHandler = releaseApplicationJobPermitBeforeHandler;
 exports.releaseApplicationJobPermitForDurableHandoff = releaseApplicationJobPermitForDurableHandoff;
 exports.hasApplicationJobPermit = hasApplicationJobPermit;
+exports.currentApplicationJobOrigin = currentApplicationJobOrigin;
 exports.bindApplicationJobPermit = bindApplicationJobPermit;
 exports.detachApplicationJobPermit = detachApplicationJobPermit;
 const node_async_hooks_1 = require("node:async_hooks");
 const applicationJobPermitScope = new node_async_hooks_1.AsyncLocalStorage();
-/**
- * Carries the host-owned queue permit through internal async dispatch without
- * leaking capacity ownership into public handler contracts.
- */
-async function runWithApplicationJobPermit(permit, callback) {
-    const scope = { permit, detached: false };
-    return applicationJobPermitScope.run(scope, async () => {
-        try {
-            return await callback();
-        }
-        finally {
-            if (!scope.detached)
-                permit.releaseAfterInternalProcessing();
+function releasePermitTurn() {
+    const permit = applicationJobPermitScope.getStore();
+    if (permit !== undefined && !permit.detachedForHandlerTurn)
+        permit.releaseAfterInternalProcessing();
+}
+function releasePermitSuccess(value) {
+    releasePermitTurn();
+    return value;
+}
+function releasePermitFailure(error) {
+    releasePermitTurn();
+    throw error;
+}
+function runWithApplicationJobPermit(permit, callback, first, second) {
+    const previous = applicationJobPermitScope.getStore();
+    applicationJobPermitScope.enterWith(permit);
+    try {
+        const result = callback(first, second);
+        if (result !== null && (typeof result === 'object' || typeof result === 'function')) {
+            return Promise.resolve(result).then(releasePermitSuccess, releasePermitFailure);
         }
-    });
+        releasePermitTurn();
+        return result;
+    }
+    catch (error) {
+        releasePermitTurn();
+        return Promise.reject(error);
+    }
+    finally {
+        applicationJobPermitScope.enterWith(previous);
+    }
 }
 /** Releases the current job permit immediately before the first user callback. */
 function releaseApplicationJobPermitBeforeHandler() {
-    applicationJobPermitScope.getStore()?.permit.releaseBeforeHandler();
+    applicationJobPermitScope.getStore()?.releaseBeforeHandler();
 }
 /** @internal Returns an ingress permit after a durable queue takes record ownership. */
 function releaseApplicationJobPermitForDurableHandoff() {
-    applicationJobPermitScope.getStore()?.permit.releaseAfterInternalProcessing();
+    applicationJobPermitScope.getStore()?.releaseAfterInternalProcessing();
 }
 /** True while dispatch already owns the host-wide application job permit. */
 function hasApplicationJobPermit() {
     return applicationJobPermitScope.getStore() !== undefined;
 }
+/** Keeps the ingress origin when a durable record later reacquires its permit. */
+function currentApplicationJobOrigin() {
+    return applicationJobPermitScope.getStore().origin;
+}
 /** Re-enters the captured permit scope when a serial executor runs later. */
 function bindApplicationJobPermit(callback) {
     const scope = applicationJobPermitScope.getStore();
@@ -48,10 +69,9 @@ function bindApplicationJobPermit(callback) {
  * detached owner must release it at handler entry or at a pre-start terminal.
  */
 function detachApplicationJobPermit() {
-    const scope = applicationJobPermitScope.getStore();
-    if (scope === undefined)
+    const permit = applicationJobPermitScope.getStore();
+    if (permit === undefined)
         return undefined;
-    scope.permit.detachForHandlerTurn?.();
-    scope.detached = true;
-    return scope.permit;
+    permit.detachForHandlerTurn();
+    return permit;
 }

package/dist/runtime/application-jobs/contracts.d.ts

@@ -1,12 +1,25 @@
+export type ApplicationJobOrigin = 'local' | 'remote';
 export interface ApplicationJobPermitPort {
+    readonly origin: ApplicationJobOrigin;
+    readonly detachedForHandlerTurn: boolean;
     markApplicationQueued(): void;
     /** Transfers ingress-record cleanup to a detached exact-target handler turn. */
-    detachForHandlerTurn?(): void;
+    detachForHandlerTurn(): void;
     releaseBeforeHandler(): void;
     releaseAfterInternalProcessing(): void;
+    /** Returns reusable reservation storage only after its ingress lifetime ends. */
+    releaseStorage?(): void;
+}
+export interface ApplicationJobReceiveRotationPort {
+    reserve(): void;
+    take(): ApplicationJobPermitPort | undefined;
+    releaseUnused(): void;
 }
 export interface ApplicationJobQueuePort {
-    acquire(signal?: AbortSignal): Promise<ApplicationJobPermitPort>;
+    createReceiveRotation(capacity: number, origin: ApplicationJobOrigin): ApplicationJobReceiveRotationPort;
+    acquire(signal: AbortSignal | undefined, origin: ApplicationJobOrigin): Promise<ApplicationJobPermitPort>;
+    /** Returns a grant now, or registers one FIFO waiter that later calls resume. */
+    acquireOrResume(resume: (permit: ApplicationJobPermitPort) => void, reject: (reason: unknown) => void, signal: AbortSignal | undefined, origin: ApplicationJobOrigin): ApplicationJobPermitPort | undefined;
     registerReceiveFlowTarget?(identity: object, applyState: (state: 'running' | 'paused') => void, failureSink?: (error: unknown) => void): boolean;
     unregisterReceiveFlowTarget?(identity: object): void;
     pressureState?(): 'running' | 'paused';

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

@@ -1,5 +1,5 @@
 import type { RequestResult, SubmitResult, ZLinkBackendMessageLike, ZLinkBackendMonitorEventType, ZLinkBackendReceived, ZLinkBackendTopicMessage } from '../runtime-values';
-import type { CoreHwmBudgetSnapshot } from '@zlink-systems/zlink';
+import type { CoreHwmBudgetSnapshot, ReceiveFlowState } from '@zlink-systems/zlink';
 import { type ZLinkBackendRecvFlags, type ZLinkBackendSendFlags } from '../runtime-values';
 export * from '../runtime-values';
 type MessageLike = ZLinkBackendMessageLike;
@@ -10,10 +10,11 @@ import type { MeshNodeStatus, MeshOperationId, MeshPeerEntry, MeshPublisher, Rea
 import type { RoutingId } from '../../../contracts';
 import type { ZLinkCoreHwmOptions } from '../../../contracts/Configuration';
 import type { ZLinkSubmitResult } from '../../messaging/submission-result';
+import type { ZLinkMeshCompletionHandler } from '../mesh-completion-table';
 import type { Message } from '../../../contracts/Common/Message';
 import type { ServiceSpotMessageFollowSeal, ServiceUserSpotOperationHandler, ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
 import type { ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
-import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
+import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceRouteFence, ServiceInstanceColdActivationTarget, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
 export declare const ZLINK_BACKEND_SPOT_ROUTE_BRIDGE_ROUTE_WITH_CHANNEL_INBOUND = 3;
 export type ZLinkBackendMeshNodeStatus = MeshNodeStatus;
 export type ZLinkBackendMeshPeerEntry = MeshPeerEntry;
@@ -32,6 +33,7 @@ export type ZLinkBackendObjectPlacement = {
     readonly kind: 'unavailable';
 };
 export interface ZLinkBackendMeshNode {
+    readonly routingId?: RoutingId;
     completeClosedInstance?(spotId: string, objectGeneration: bigint): void;
     setDispatchErrorReporter?(reporter: import('../../channels/dispatch-error-reporter').ZLinkDispatchErrorReporter, meshName: string): void;
     setRoutingId(routingId: unknown): void;
@@ -66,22 +68,10 @@ export interface ZLinkBackendMeshNode {
     }): void;
     selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
     instanceSpotPlacementTypes?(): readonly string[];
-    sendToMissingInstanceSpot(target: {
-        readonly targetNodeRid: string;
-        readonly targetNodeGeneration: bigint;
-        readonly targetSpotId: string;
-        readonly stableType: string;
-        readonly descriptorVersion: string;
-    }, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestToMissingInstanceSpot(target: {
-        readonly targetNodeRid: string;
-        readonly targetNodeGeneration: bigint;
-        readonly targetSpotId: string;
-        readonly stableType: string;
-        readonly descriptorVersion: string;
-    }, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    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;
     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;
     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>;
@@ -108,10 +98,12 @@ export interface ZLinkBackendMeshNode {
         readonly lifecycleGeneration: bigint;
     }): void;
     isObjectClientNodeDirectTarget?(targetRid: unknown): boolean;
+    observePeerRoute?(targetRid: unknown): import('../../foundation/durable-service-request').PeerRouteObservation;
+    hasPeerRouteOrConnectionIntent?(targetRid: unknown, endpoint: string): boolean;
     isPeerRouteReady?(targetRid: unknown, lifecycleGeneration?: bigint): boolean;
     sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
-    }): Promise<SubmitResult>;
+    }): SubmitResult | Promise<SubmitResult>;
     /**
      * Sends service-wire infrastructure frames directly to a peer. Relocation
      * Prepare may add NODE-INTERNAL sideband frames after its canonical frame.
@@ -125,11 +117,14 @@ export interface ZLinkBackendMeshNode {
      */
     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?: {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     sendToChannel(channelName: string, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
@@ -138,6 +133,7 @@ export interface ZLinkBackendMeshNode {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     status(): MeshNodeStatus;
     peers(): MeshPeerEntry[];
@@ -202,6 +198,7 @@ export interface ZLinkBackendMeshNode {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
@@ -210,11 +207,13 @@ export interface ZLinkBackendMeshNode {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], flags?: number): Promise<SubmitResult>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     setReadyHandler(handler: (readyDomains: number) => number): void;
+    setCompletionHandler(handler: ZLinkMeshCompletionHandler): void;
     createReadyBatch(capacity: number): ReadyBatch;
     createReceiveBatch(messageCapacity: number, partCapacity: number): ReceiveBatch;
     drainReady(domains: number, batch: ReadyBatch, flags?: number): {
@@ -278,7 +277,6 @@ export interface ZLinkBackendSocket extends ZLinkBackendObject {
     readonly lastEndpoint?: string;
     bind(endpoint: string): void;
     setChannelName(channelName: string): void;
-    setReceiveFlowState?(state: 0 | 1): void;
     dispose(): Promise<void>;
 }
 export interface ZLinkBackendConnectableSocket extends ZLinkBackendSocket {
@@ -286,7 +284,7 @@ export interface ZLinkBackendConnectableSocket extends ZLinkBackendSocket {
     disconnect(endpoint: string): void;
 }
 export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket {
-    setReceiveFlowState(state: 0 | 1): void;
+    receiveAdmission?: import('../../foundation/service-liveness-registry').ServiceLivenessConnection;
     setRoutingId(routingId: RoutingId): void;
     peerWeight: number;
     sendHighWaterMark: number;
@@ -294,7 +292,7 @@ export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket
     receiveTimeoutMs: number;
     maxMessageSize: number;
     send(message: Message | readonly Message[]): Promise<void>;
-    request(message: Message | readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
+    request(message: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
     recv(flags?: ZLinkBackendRecvFlags): Received | undefined;
 }
 export interface ZLinkBackendReplyOperation {
@@ -308,10 +306,10 @@ export interface ZLinkBackendSendOperation {
 export interface ZLinkBackendRequestOperation {
     message(message: MessageLike): ZLinkBackendRequestOperation;
     timeout(timeoutMs: number): ZLinkBackendRequestOperation;
-    submit(): Promise<readonly Message[]>;
+    submit(onAdmitted?: () => void): Promise<readonly Message[]>;
 }
 export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket {
-    setReceiveFlowState(state: 0 | 1): void;
+    setReceiveFlowState(state: ReceiveFlowState): void;
     /** Enables the native probe handshake for manually configured routes. */
     setProbe(enabled: boolean): void;
     peerWeight: number;
@@ -322,14 +320,15 @@ 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): Promise<readonly Message[]>;
+    request(routingId: RoutingId, message: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
     sendToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], flags?: ZLinkBackendSendFlags): Promise<void>;
-    requestToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
+    requestToSpot(targetNodeRid: RoutingId, targetSpotId: RoutingId, parts: readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
     disconnectPeer(routingId: RoutingId): void;
     reply(routingId: RoutingId, replyToken: unknown): ZLinkBackendReplyOperation;
     reply(routingId: RoutingId, replyToken: unknown, message: Message | readonly Message[]): void;
 }
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
+    lingerMs: number;
     sendTimeoutMs: number;
     sendHighWaterMark: number;
     noDrop: boolean;
@@ -423,11 +422,11 @@ 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): Promise<readonly Message[]>;
+    requestToChannel(channelName: string, payload: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
     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): Promise<readonly Message[]>;
+    requestToSpot(targetRid: RoutingId, spotId: RoutingId, payload: Message | readonly Message[], timeoutMs?: number, onAdmitted?: () => void): Promise<readonly Message[]>;
     dispose(): Promise<void>;
 }
 export interface ZLinkChannelBackendAdapter {
@@ -447,6 +446,7 @@ export interface ZLinkMeshBackendAdapter {
         readonly trustProfile?: string;
         readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
         readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
+        readonly infrastructureTaskRunner?: import('../../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner;
         readonly peerAdmissionSealed?: () => boolean;
     }): ZLinkBackendMeshNode;
 }

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

@@ -12,20 +12,30 @@ export interface ZLinkMeshCompletion {
     readonly kindData: ReceiveKindData | null;
     readonly parts: Message[];
 }
+export type ZLinkMeshCompletionTerminal = Pick<ReceiveRecord, 'operationId' | 'terminalResult'>;
+export type ZLinkMeshCompletionHandler = (terminal: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord) => void;
 export declare class ZLinkMeshCompletionTable {
     private readonly onDiagnostic?;
-    private readonly pending;
+    private buckets;
+    private readonly slots;
+    private free;
+    private activeCount;
     private disposed;
     constructor(onDiagnostic?: ((diagnostic: ZLinkMeshCompletionDiagnostic) => void) | undefined);
+    private prepareSlots;
+    private bucket;
+    private indexSlot;
+    private findSlot;
+    private releaseSlot;
     /**
-     * Submits and registers without yielding control to the event loop. Mesh
-     * completion dispatch is asynchronous, so a completion cannot overtake the
-     * registration. The table therefore does not need to retain responses that
-     * arrived before their waiter.
+     * 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: () => MeshOperationId, signal?: AbortSignal): Promise<ZLinkMeshCompletion>;
     private isDisposed;
     complete(record: ReceiveRecord): void;
+    complete(record: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord): void;
     dispose(reason?: unknown): void;
     get pendingCount(): number;
 }