@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/admission.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRuntimeAdmissionGate = void 0;
 exports.shouldCompactBackingArray = shouldCompactBackingArray;
 const framework_errors_internal_1 = require("./framework-errors-internal");
+const abort_1 = require("./abort");
 const BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
 function shouldCompactBackingArray(head, length) {
@@ -57,35 +58,59 @@ class ZLinkRuntimeAdmissionGate {
         }
     }
     claim(meshName, operation) {
+        const state = this.enter(meshName, operation);
+        let closed = false;
+        return {
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                exitAdmission(state);
+            }
+        };
+    }
+    /**
+     * Runs one admitted unit of work. Work that completes synchronously leaves
+     * admission in the same turn; asynchronous work leaves it from the single
+     * continuation on its result.
+     */
+    run(meshName, operation, work, onRejected) {
+        let state;
+        let result;
+        try {
+            state = this.enter(meshName, operation);
+        }
+        catch (error) {
+            // The domain owns admission rejection completion, just as it owns handler failure.
+            return onRejected === undefined ? Promise.reject(error) : onRejected(error);
+        }
+        try {
+            result = work();
+        }
+        catch (error) {
+            exitAdmission(state);
+            return Promise.reject(error);
+        }
+        if (!(0, abort_1.isPromiseLike)(result)) {
+            exitAdmission(state);
+            return result;
+        }
+        return Promise.resolve(result).then((value) => {
+            exitAdmission(state);
+            return value;
+        }, (error) => {
+            exitAdmission(state);
+            throw error;
+        });
+    }
+    enter(meshName, operation) {
         const state = this.requireState(meshName);
         if (this.ownerAdmissionOpen() && !state.sealed) {
             state.active += 1;
-            let closed = false;
-            return {
-                close: () => {
-                    if (closed)
-                        return;
-                    closed = true;
-                    state.active -= 1;
-                    if (state.active === 0) {
-                        let resolve;
-                        while ((resolve = takeWaiter(state)) !== undefined)
-                            resolve();
-                    }
-                }
-            };
+            return state;
         }
         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);
-        try {
-            return await work();
-        }
-        finally {
-            claim.close();
-        }
-    }
     awaitZero(meshName, signal) {
         const state = this.requireState(meshName);
         if (state.active === 0)
@@ -150,6 +175,14 @@ class ZLinkRuntimeAdmissionGate {
     }
 }
 exports.ZLinkRuntimeAdmissionGate = ZLinkRuntimeAdmissionGate;
+function exitAdmission(state) {
+    state.active -= 1;
+    if (state.active === 0) {
+        let resolve;
+        while ((resolve = takeWaiter(state)) !== undefined)
+            resolve();
+    }
+}
 function takeWaiter(state) {
     advanceWaiterHead(state);
     const waiter = state.waiters[state.waiterHead];

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

@@ -1,13 +1,27 @@
 import type { ApplicationJobOrigin, ApplicationJobPermitPort } from './contracts';
+/** Ends the internal processing of one record turn unless its handler detached the permit. */
+export declare function releaseApplicationJobPermitTurn(permit: ApplicationJobPermitPort | undefined): void;
+/**
+ * Makes `permit` the current record's permit for the synchronous part of a
+ * dispatch. The caller restores the returned previous scope with
+ * {@link leaveApplicationJobPermitScope} and releases the turn itself, so a
+ * dispatcher that already continues on the handler result needs no second
+ * continuation here.
+ */
+export declare function enterApplicationJobPermitScope(permit: ApplicationJobPermitPort): ApplicationJobPermitPort | undefined;
+export declare function leaveApplicationJobPermitScope(previous: ApplicationJobPermitPort | undefined): void;
 /**
  * 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;
+/** The current ingress reservation; capacity remains owned by its host queue. */
+export declare function currentApplicationJobPermit(): ApplicationJobPermitPort | undefined;
 /** 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. */

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

@@ -1,45 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseApplicationJobPermitTurn = releaseApplicationJobPermitTurn;
+exports.enterApplicationJobPermitScope = enterApplicationJobPermitScope;
+exports.leaveApplicationJobPermitScope = leaveApplicationJobPermitScope;
 exports.runWithApplicationJobPermit = runWithApplicationJobPermit;
 exports.releaseApplicationJobPermitBeforeHandler = releaseApplicationJobPermitBeforeHandler;
 exports.releaseApplicationJobPermitForDurableHandoff = releaseApplicationJobPermitForDurableHandoff;
 exports.hasApplicationJobPermit = hasApplicationJobPermit;
+exports.currentApplicationJobPermit = currentApplicationJobPermit;
 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();
+function releasePermitTurn() {
+    releaseApplicationJobPermitTurn(applicationJobPermitScope.getStore());
+}
+/** Ends the internal processing of one record turn unless its handler detached the permit. */
+function releaseApplicationJobPermitTurn(permit) {
+    if (permit !== undefined && !permit.detachedForHandlerTurn)
+        permit.releaseAfterInternalProcessing();
+}
 /**
- * Carries the host-owned queue permit through internal async dispatch without
- * leaking capacity ownership into public handler contracts.
+ * Makes `permit` the current record's permit for the synchronous part of a
+ * dispatch. The caller restores the returned previous scope with
+ * {@link leaveApplicationJobPermitScope} and releases the turn itself, so a
+ * dispatcher that already continues on the handler result needs no second
+ * continuation here.
  */
-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 enterApplicationJobPermitScope(permit) {
+    const previous = applicationJobPermitScope.getStore();
+    applicationJobPermitScope.enterWith(permit);
+    return previous;
+}
+function leaveApplicationJobPermitScope(previous) {
+    applicationJobPermitScope.enterWith(previous);
+}
+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;
 }
+/** The current ingress reservation; capacity remains owned by its host queue. */
+function currentApplicationJobPermit() {
+    return applicationJobPermitScope.getStore();
+}
 /** 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 +95,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,24 @@
 export type ApplicationJobOrigin = 'local' | 'remote';
 export interface ApplicationJobPermitPort {
+    /** Reacquires this record's host supply after durable FIFO ownership. */
+    reacquire?(signal: AbortSignal): Promise<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

@@ -32,9 +32,17 @@ export type ZLinkBackendObjectPlacement = {
 } | {
     readonly kind: 'unavailable';
 };
+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 {
+    acceptRelocatedActorTerminal?(operation: {
+        readonly high: bigint;
+        readonly low: bigint;
+    }, replyRouteId: bigint, result: import('../../foundation/service-stateful-runtime').ServiceStatefulResult): 'terminalReceived' | 'alreadyTerminal' | undefined;
+    readonly routingId?: RoutingId;
+    cancelPendingOperations?(reason: unknown): void;
     completeClosedInstance?(spotId: string, objectGeneration: bigint): void;
     setDispatchErrorReporter?(reporter: import('../../channels/dispatch-error-reporter').ZLinkDispatchErrorReporter, meshName: string): void;
+    setSessionOwnerDescriptors?(source: import('../../foundation/service-stateful-runtime').ServiceSessionOwnerDescriptors): void;
     setRoutingId(routingId: unknown): void;
     setBind(endpoint: string): void;
     setAdvertiseHost(host: string): void;
@@ -51,9 +59,9 @@ export interface ZLinkBackendMeshNode {
     }) => void): void;
     setMessageFollowHandler?(handler: (record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord) => void): void;
     sendMessageFollowNotification?(targetNodeRid: string, record: Omit<import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord, 'kind'>): Promise<boolean>;
-    shutdown(timeoutMs: number): RequestResult;
+    shutdown(timeoutMs: number): Promise<RequestResult>;
     publishDraining?(): Promise<void>;
-    close(): void;
+    close(): Promise<void>;
     addChannelName(name: string): void;
     setChannelWeight(name: string, weight: number): Promise<void>;
     setPlacementWeight(weight: number): Promise<void>;
@@ -68,9 +76,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>;
@@ -96,11 +104,19 @@ export interface ZLinkBackendMeshNode {
         readonly securityIdentity?: string;
         readonly lifecycleGeneration: bigint;
     }): void;
+    /**
+     * Installs the source request owner check the first accepting owner runs on Actor and Spot
+     * ingress (Location runtime §9.3). Undefined from the check ends the request Unavailable.
+     */
+    setRequestSourceAcceptance?(acceptance: ZLinkBackendRequestSourceAcceptance): 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;
+    waitForPeerRoute?(targetRid: unknown, lifecycleGeneration: bigint, deadlineUnixMs: bigint, signal?: AbortSignal): Promise<void>;
     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 +130,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 +146,7 @@ export interface ZLinkBackendMeshNode {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
     }): MeshOperationId;
     status(): MeshNodeStatus;
     peers(): MeshPeerEntry[];
@@ -165,7 +185,8 @@ export interface ZLinkBackendMeshNode {
     forgetSpotRoute?(spot: ServiceDirectSpotRouteFence['spot'], authorityOwnerGeneration: bigint, storeVersion?: string): void;
     sealSpotMessageFollowIngress?(source: ServiceDirectSpotRouteFence): ServiceSpotMessageFollowSeal | undefined;
     abortSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal): boolean;
-    commitSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
+    /** A null target consumes the committed seal without installing a Follow route. */
+    commitSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence | null, durationMs: number): Promise<boolean>;
     joinActorSpot(actor: ZLinkBackendActorRef, targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, request: ServiceApplicationPayload, timeoutMs?: number): MeshOperationId;
     joinActorSpotCanonical(actor: ZLinkBackendActorRef, targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, request: ServiceApplicationPayload, actorFence: {
         readonly targetNodeGeneration: bigint;
@@ -186,11 +207,14 @@ export interface ZLinkBackendMeshNode {
     }, timeoutMs?: number): MeshOperationId;
     sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
+        routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
     }): Promise<SubmitResult>;
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
+        onAdmitted?: () => void;
+        routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
     }): MeshOperationId;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
@@ -199,6 +223,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 +308,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 +322,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 +336,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 +438,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-actor-session-node-adapter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.meshActorSessionNodeAdapter = meshActorSessionNodeAdapter;
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const mesh_completion_table_1 = require("./mesh-completion-table");
 function meshActorSessionNodeAdapter(node, completions) {
@@ -16,8 +17,7 @@ function meshActorSessionNodeAdapter(node, completions) {
             const completion = await completions.submit(() => node.closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs), signal);
             try {
                 if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
-                    throw new Error(`Actor '${actor.actorId}' bound-session close failed with result ` +
-                        `'${completion.terminalResult}' and errno '${completion.failureErrno}'.`);
+                    throw (0, framework_errors_internal_1.wireReplyFailureException)(completion.terminalResult, completion.failureErrno, `Actor '${actor.actorId}' bound-session close failed.`);
                 }
             }
             finally {

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