@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/actors/actor-remote-wire.js

@@ -13,7 +13,22 @@ exports.REMOTE_ACTOR_JOIN_PACKET = exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET;
 exports.REMOTE_ACTOR_JOIN_ADMISSION = 'admission';
 exports.REMOTE_ACTOR_JOIN_COMMIT = 'commit';
 exports.REMOTE_ACTOR_JOIN_ABORT = 'abort';
+const JSON_OBJECT_START = '{'.charCodeAt(0);
+const JSON_SPACE = ' '.charCodeAt(0);
+const JSON_TAB = '\t'.charCodeAt(0);
+const JSON_LINE_FEED = '\n'.charCodeAt(0);
+const JSON_CARRIAGE_RETURN = '\r'.charCodeAt(0);
 function decodeRemoteActorSourceLeaveTerminal(payload) {
+    // A SourceLeave terminal is a JSON object. Binary channel frames and JSON
+    // primitives cannot be terminals, so do not materialize or parse them.
+    let offset = 0;
+    while (payload[offset] === JSON_SPACE ||
+        payload[offset] === JSON_TAB ||
+        payload[offset] === JSON_LINE_FEED ||
+        payload[offset] === JSON_CARRIAGE_RETURN)
+        offset++;
+    if (payload[offset] !== JSON_OBJECT_START)
+        return undefined;
     let decoded;
     try {
         decoded = JSON.parse(payload.toString());

package/dist/runtime/actors/actor-routed-join-transport.d.ts

@@ -6,27 +6,31 @@ export interface ZLinkActorRoutedJoinTransport {
     canRouteChannel?(routerChannelId: string): boolean;
     canRoutePacketChannel?(routerChannelId: string): boolean;
     request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): Promise<ZLinkSubmitResult>;
-    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): Promise<ZLinkSubmitResult>;
+    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
+    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
     }): Promise<ZLinkSubmitResult>;
     requestRawToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<TReply>;
     requestFromSpotToSpot?<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<TReply>;
     requestRawFromSpotToSpot?(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
 }

package/dist/runtime/actors/actor-routed-json-request.d.ts

@@ -4,8 +4,10 @@ import type { ZLinkActorRoutedJoinTransport } from './actor-routed-join-transpor
 export declare function tryRequestRoutedJson(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
+    readonly onAdmitted?: () => void;
 }): Promise<boolean>;
 export declare function requestRoutedJsonReply<T>(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
+    readonly onAdmitted?: () => void;
 }, unavailableMessage: string, decode: (replyParts: readonly Message[]) => T): Promise<T>;

package/dist/runtime/actors/index.d.ts

@@ -51,7 +51,8 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     publishRelocationActor(actorId: string): void;
     abortRelocationActor(actorId: string): Promise<void>;
     completeRelocationSource(actorId: string, sourceActorRef?: ZLinkBackendActorRef): Promise<void>;
-    private removeRelocationActor;
+    releaseSpotActorMembers(meshName: string, spotId?: RoutingId): Promise<void>;
+    private releaseLocalActor;
     completeCoreRelocationSource(actorId: string): Promise<void>;
     private finalizeActorState;
     private finalizeDestroyedActor;

package/dist/runtime/actors/index.js

@@ -118,7 +118,7 @@ class DefaultZLinkActorManager {
         const actorRef = this.actorRefForState(state);
         return {
             spotId: spotId,
-            objectGeneration: state.locationGeneration ?? 0n,
+            objectGeneration: state.spotGeneration ?? 0n,
             meshName: this.actorMeshNames.get(actorId) ?? '',
             nodeRid: actorRef.nodeRid
         };
@@ -302,7 +302,7 @@ class DefaultZLinkActorManager {
             }
             state.setLocationGeneration(authorityOwnerGeneration);
             if (spotId !== undefined)
-                state.setJoinedSpot(spotId, undefined, membershipEpoch);
+                state.setJoinedSpot(spotId, undefined, membershipEpoch, spotGeneration);
             return actor;
         }
         catch (error) {
@@ -321,12 +321,24 @@ class DefaultZLinkActorManager {
         this.relocationStaged.delete(actorId);
     }
     async abortRelocationActor(actorId) {
-        await this.removeRelocationActor(actorId);
+        await this.releaseLocalActor(actorId);
     }
     async completeRelocationSource(actorId, sourceActorRef) {
-        await this.removeRelocationActor(actorId, sourceActorRef);
-    }
-    async removeRelocationActor(actorId, exactNativeActorRef) {
+        await this.releaseLocalActor(actorId, sourceActorRef);
+    }
+    async releaseSpotActorMembers(meshName, spotId) {
+        const results = await Promise.allSettled([...this.states.values()]
+            .filter((state) => state.meshName === meshName && state.spotId === spotId)
+            .map((state) => this.releaseLocalActor(state.actorId)));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, 'Actor member cleanup failed.');
+    }
+    async releaseLocalActor(actorId, exactNativeActorRef) {
         const state = this.states.get(actorId);
         const node = this.options.nativeActorNodeProvider?.() ?? this.options.nativeActorNode;
         const nativeActorRef = exactNativeActorRef ?? state?.nativeActorRef;

package/dist/runtime/actors/spot-actor-dispatch.js

@@ -21,7 +21,7 @@ class ZLinkSpotActorHandlerRegistryRuntime {
         const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(handlerType).find((entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
         const resolvedPacketName = packetName ?? metadata?.packetName;
         if (metadata === undefined || resolvedPacketName === undefined) {
-            throw new configuration_1.ZLinkConfigurationException(`Actor packet handler '${handlerType.name}' must declare a packet name.`);
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet handler '${handlerType.name}' must declare a packet name.`);
         }
         return this.addPacket({
             kind: metadata.kind === 'spotActorSend'
@@ -36,7 +36,7 @@ class ZLinkSpotActorHandlerRegistryRuntime {
     addPacket(descriptor) {
         const key = packetKey(descriptor.kind, descriptor.actorType, descriptor.packetName);
         if (this.packets.has(key)) {
-            throw new configuration_1.ZLinkConfigurationException(`Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`);
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`);
         }
         const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(descriptor.handlerType).find((entry) => entry.kind ===
             (descriptor.kind === ZLinkActorPacketKind.Send ? 'spotActorSend' : 'spotActorRequest') &&

package/dist/runtime/admission.d.ts

@@ -16,7 +16,7 @@ export declare class ZLinkRuntimeAdmissionGate {
     seal(meshName: string, reason?: ZLinkFrameworkInternalErrorKind): void;
     close(): void;
     claim(meshName: string, operation: string): ZLinkApplicationWorkClaim;
-    run<T>(meshName: string, operation: string, work: () => Promise<T>): Promise<T>;
+    run<T>(meshName: string, operation: string, work: () => T | Promise<T>): Promise<T>;
     awaitZero(meshName: string, signal?: AbortSignal): Promise<void>;
     requireRequest(operation: string, meshName?: string): void;
     requireActorCreate(actorId: string, meshName?: string): void;

package/dist/runtime/admission.js

@@ -77,13 +77,23 @@ class ZLinkRuntimeAdmissionGate {
         }
         throw (0, framework_errors_internal_1.createInternalFrameworkException)(state.sealedReason, `${operation} was rejected because framework admission is closed.`);
     }
-    async run(meshName, operation, work) {
-        const claim = this.claim(meshName, operation);
+    run(meshName, operation, work) {
+        let claim;
         try {
-            return await work();
+            claim = this.claim(meshName, operation);
+            const result = work();
+            const close = claim.close;
+            return Promise.resolve(result).then((value) => {
+                close();
+                return value;
+            }, (error) => {
+                close();
+                throw error;
+            });
         }
-        finally {
-            claim.close();
+        catch (error) {
+            claim?.close();
+            return Promise.reject(error);
         }
     }
     awaitZero(meshName, signal) {

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

@@ -10,33 +10,31 @@ export interface IngressRecordPort {
  */
 export declare class ApplicationIngressRecordOwner {
     private readonly shared;
-    private readonly stop;
+    private stop?;
     private closed;
     private constructor();
     static create(queue: ApplicationJobQueuePort, initialPermit: ApplicationJobPermitPort, record: IngressRecordPort): ApplicationIngressRecordOwner;
     retain(): ApplicationIngressRecordOwner;
     takeInitial(domain: ApplicationJobRecordDomain): ApplicationJobRecordLease;
-    acquire(domain: ApplicationJobRecordDomain, signal?: AbortSignal): Promise<ApplicationJobRecordLease>;
+    acquire(domain: ApplicationJobRecordDomain, signal?: AbortSignal): ApplicationJobRecordLease | Promise<ApplicationJobRecordLease>;
+    private acquireAdditional;
     close(): void;
     private requireOpen;
 }
 /** Queue-permit child of one shared raw ingress record. */
 export declare class ApplicationJobRecordLease implements ApplicationJobPermitPort {
     private readonly shared;
-    private readonly permit;
+    private permit;
     private ingressClosed;
-    private permitReleased;
     private processingTerminal;
-    private detachedForHandlerTurn;
-    private jobReleased;
-    constructor(shared: SharedIngressRecordState, permit: ApplicationJobPermitPort);
+    detachedForHandlerTurn: boolean;
+    constructor(shared: SharedIngressRecordState, permit: ApplicationJobPermitPort | undefined);
     get origin(): ApplicationJobOrigin;
     markApplicationQueued(): void;
     detachForHandlerTurn(): void;
     releaseBeforeHandler(): void;
     releaseAfterInternalProcessing(): void;
     close(): void;
-    private releasePermit;
     private releaseJobIfTerminal;
 }
 declare class SharedIngressRecordState {

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,10 +78,8 @@ class ApplicationJobRecordLease {
     shared;
     permit;
     ingressClosed = false;
-    permitReleased = false;
     processingTerminal = false;
     detachedForHandlerTurn = false;
-    jobReleased = false;
     constructor(shared, permit) {
         this.shared = shared;
         this.permit = permit;
@@ -79,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() {
@@ -96,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;
@@ -174,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

@@ -3,7 +3,8 @@ 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. */

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

@@ -9,29 +9,45 @@ 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() {
@@ -39,7 +55,7 @@ function hasApplicationJobPermit() {
 }
 /** Keeps the ingress origin when a durable record later reacquires its permit. */
 function currentApplicationJobOrigin() {
-    return applicationJobPermitScope.getStore().permit.origin;
+    return applicationJobPermitScope.getStore().origin;
 }
 /** Re-enters the captured permit scope when a serial executor runs later. */
 function bindApplicationJobPermit(callback) {
@@ -53,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,13 +1,22 @@
 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 {
+    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;

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

@@ -33,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;
@@ -68,9 +69,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>): MeshOperationId;
+    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>;
@@ -97,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.
@@ -114,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;
@@ -127,6 +133,7 @@ export interface ZLinkBackendMeshNode {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     status(): MeshNodeStatus;
     peers(): MeshPeerEntry[];
@@ -191,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;
@@ -199,6 +207,7 @@ 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;
@@ -283,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 {
@@ -297,7 +306,7 @@ 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: ReceiveFlowState): void;
@@ -311,9 +320,9 @@ 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;
@@ -413,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 {

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

@@ -16,9 +16,17 @@ export type ZLinkMeshCompletionTerminal = Pick<ReceiveRecord, 'operationId' | 't
 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;
     /**
      * Reserves the dispatcher slot before transport submission. The backend
      * observes native terminals through Promises, so identity binding finishes