@zlink-systems/framework 0.30.0 → 0.30.2

package/src/runtime/actors/spot-actor-dispatch.ts

@@ -49,7 +49,8 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
     );
     const resolvedPacketName = packetName ?? metadata?.packetName;
     if (metadata === undefined || resolvedPacketName === undefined) {
-      throw new ZLinkConfigurationException(
+      throw createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.InvalidOperation,
         `Actor packet handler '${handlerType.name}' must declare a packet name.`
       );
     }
@@ -68,7 +69,8 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
   addPacket(descriptor: ZLinkActorPacketDescriptor): this {
     const key = packetKey(descriptor.kind, descriptor.actorType, descriptor.packetName);
     if (this.packets.has(key)) {
-      throw new ZLinkConfigurationException(
+      throw createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.InvalidOperation,
         `Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`
       );
     }

package/src/runtime/admission.ts

@@ -2,8 +2,15 @@ import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
 } from './framework-errors-internal';
+import { isPromiseLike } from './abort';
 const BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
 
+/** Runs host admission inside the domain's request completion boundary. */
+export type ZLinkMeshDispatchAdmission = (
+  dispatch: () => void | Promise<void>,
+  onRejected?: (error: unknown) => void | Promise<void>
+) => void | Promise<void>;
+
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
 export function shouldCompactBackingArray(head: number, length: number): boolean {
   return head >= BACKING_ARRAY_COMPACTION_MIN_HEAD && head * 2 >= length;
@@ -64,21 +71,63 @@ export class ZLinkRuntimeAdmissionGate {
   }
 
   claim(meshName: string, operation: string): ZLinkApplicationWorkClaim {
+    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<T>(
+    meshName: string,
+    operation: string,
+    work: () => T | Promise<T>,
+    onRejected?: (error: unknown) => T | Promise<T>
+  ): T | Promise<T> {
+    let state: ZLinkMeshAdmissionState;
+    let result: T | Promise<T>;
+    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 (!isPromiseLike(result)) {
+      exitAdmission(state);
+      return result;
+    }
+    return Promise.resolve(result).then(
+      (value) => {
+        exitAdmission(state);
+        return value;
+      },
+      (error: unknown) => {
+        exitAdmission(state);
+        throw error;
+      }
+    );
+  }
+
+  private enter(meshName: string, operation: string): ZLinkMeshAdmissionState {
     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: (() => void) | undefined;
-            while ((resolve = takeWaiter(state)) !== undefined) resolve();
-          }
-        }
-      };
+      return state;
     }
     throw createInternalFrameworkException(
       state.sealedReason,
@@ -86,15 +135,6 @@ export class ZLinkRuntimeAdmissionGate {
     );
   }
 
-  async run<T>(meshName: string, operation: string, work: () => Promise<T>): Promise<T> {
-    const claim = this.claim(meshName, operation);
-    try {
-      return await work();
-    } finally {
-      claim.close();
-    }
-  }
-
   awaitZero(meshName: string, signal?: AbortSignal): Promise<void> {
     const state = this.requireState(meshName);
     if (state.active === 0) return Promise.resolve();
@@ -178,6 +218,14 @@ interface ZLinkMeshAdmissionState {
   waiterCount: number;
 }
 
+function exitAdmission(state: ZLinkMeshAdmissionState): void {
+  state.active -= 1;
+  if (state.active === 0) {
+    let resolve: (() => void) | undefined;
+    while ((resolve = takeWaiter(state)) !== undefined) resolve();
+  }
+}
+
 function takeWaiter(state: ZLinkMeshAdmissionState): (() => void) | undefined {
   advanceWaiterHead(state);
   const waiter = state.waiters[state.waiterHead];

package/src/runtime/application-jobs/application-ingress-record-owner.ts

@@ -16,7 +16,7 @@ export interface IngressRecordPort {
  * ordinary Framework-owned ingress record closes after the last child terminal.
  */
 export class ApplicationIngressRecordOwner {
-  private readonly stop = new AbortController();
+  private stop?: AbortController;
   private closed = false;
 
   private constructor(private readonly shared: SharedIngressRecordState) {}
@@ -46,17 +46,34 @@ export class ApplicationIngressRecordOwner {
     return job;
   }
 
-  async acquire(
+  acquire(
     domain: ApplicationJobRecordDomain,
     signal?: AbortSignal
-  ): Promise<ApplicationJobRecordLease> {
-    this.requireOpen();
-    const initial = this.shared.takeInitialPermit(domain);
-    if (initial !== undefined) return initial;
+  ): ApplicationJobRecordLease | Promise<ApplicationJobRecordLease> {
+    try {
+      this.requireOpen();
+      const initial = this.shared.takeInitialPermit(domain);
+      if (initial !== undefined) return initial;
+    } catch (error) {
+      return Promise.reject(error);
+    }
 
-    const waitSignal =
-      signal === undefined ? this.stop.signal : AbortSignal.any([this.stop.signal, signal]);
-    const permit = await this.shared.acquirePermit(waitSignal);
+    return this.acquireAdditional(domain, signal);
+  }
+
+  private async acquireAdditional(
+    domain: ApplicationJobRecordDomain,
+    signal?: AbortSignal
+  ): Promise<ApplicationJobRecordLease> {
+    const stop = (this.stop ??= new AbortController());
+    const waitSignal = signal === undefined ? stop.signal : AbortSignal.any([stop.signal, signal]);
+    let permit: ApplicationJobPermitPort;
+    try {
+      permit = await this.shared.acquirePermit(waitSignal);
+    } catch (error) {
+      if (error === ownerClosedError) throw ownerClosedError();
+      throw error;
+    }
     if (this.closed) {
       permit.releaseAfterInternalProcessing();
       throw ownerClosedError();
@@ -67,7 +84,8 @@ export class ApplicationIngressRecordOwner {
   close(): void {
     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();
   }
 
@@ -79,14 +97,12 @@ export class ApplicationIngressRecordOwner {
 /** Queue-permit child of one shared raw ingress record. */
 export class ApplicationJobRecordLease implements ApplicationJobPermitPort {
   private ingressClosed = false;
-  private permitReleased = false;
   private processingTerminal = false;
-  private detachedForHandlerTurn = false;
-  private jobReleased = false;
+  detachedForHandlerTurn = false;
 
   constructor(
     private readonly shared: SharedIngressRecordState,
-    private readonly permit: ApplicationJobPermitPort
+    private permit: ApplicationJobPermitPort | undefined
   ) {}
 
   get origin(): ApplicationJobOrigin {
@@ -103,12 +119,12 @@ export class ApplicationJobRecordLease implements ApplicationJobPermitPort {
   }
 
   releaseBeforeHandler(): void {
-    this.releasePermit(() => this.permit.releaseBeforeHandler());
+    this.permit?.releaseBeforeHandler();
   }
 
   releaseAfterInternalProcessing(): void {
     this.processingTerminal = true;
-    this.releasePermit(() => this.permit.releaseAfterInternalProcessing());
+    this.permit?.releaseAfterInternalProcessing();
     this.releaseJobIfTerminal();
   }
 
@@ -122,16 +138,15 @@ export class ApplicationJobRecordLease implements ApplicationJobPermitPort {
     this.releaseJobIfTerminal();
   }
 
-  private releasePermit(release: () => void): void {
-    if (this.permitReleased) return;
-    this.permitReleased = true;
-    release();
-  }
-
   private releaseJobIfTerminal(): void {
-    if (this.jobReleased || !this.ingressClosed || !this.processingTerminal) return;
-    this.jobReleased = true;
-    this.shared.releaseJob();
+    const permit = this.permit;
+    if (permit === undefined || !this.ingressClosed || !this.processingTerminal) return;
+    this.permit = undefined;
+    try {
+      this.shared.releaseJob();
+    } finally {
+      permit.releaseStorage?.();
+    }
   }
 }
 
@@ -203,6 +218,7 @@ class SharedIngressRecordState {
     try {
       this.initialPermit?.releaseAfterInternalProcessing();
     } finally {
+      this.initialPermit?.releaseStorage?.();
       this.initialPermit = undefined;
       this.record.close();
     }

package/src/runtime/application-jobs/application-job-queue-scope.ts

@@ -2,39 +2,96 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 
 import type { ApplicationJobOrigin, ApplicationJobPermitPort } from './contracts';
 
-interface ApplicationJobPermitScope {
-  readonly permit: ApplicationJobPermitPort;
-  detached: boolean;
+const applicationJobPermitScope = new AsyncLocalStorage<ApplicationJobPermitPort | undefined>();
+
+function releasePermitTurn(): void {
+  releaseApplicationJobPermitTurn(applicationJobPermitScope.getStore());
 }
 
-const applicationJobPermitScope = new AsyncLocalStorage<ApplicationJobPermitScope>();
+/** Ends the internal processing of one record turn unless its handler detached the permit. */
+export function releaseApplicationJobPermitTurn(
+  permit: ApplicationJobPermitPort | undefined
+): void {
+  if (permit !== undefined && !permit.detachedForHandlerTurn)
+    permit.releaseAfterInternalProcessing();
+}
+
+/**
+ * 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 function enterApplicationJobPermitScope(
+  permit: ApplicationJobPermitPort
+): ApplicationJobPermitPort | undefined {
+  const previous = applicationJobPermitScope.getStore();
+  applicationJobPermitScope.enterWith(permit);
+  return previous;
+}
+
+export function leaveApplicationJobPermitScope(
+  previous: ApplicationJobPermitPort | undefined
+): void {
+  applicationJobPermitScope.enterWith(previous);
+}
+
+function releasePermitSuccess<TResult>(value: TResult): TResult {
+  releasePermitTurn();
+  return value;
+}
+
+function releasePermitFailure(error: unknown): never {
+  releasePermitTurn();
+  throw error;
+}
 
 /**
  * Carries the host-owned queue permit through internal async dispatch without
  * leaking capacity ownership into public handler contracts.
  */
-export async function runWithApplicationJobPermit<TResult>(
+export function runWithApplicationJobPermit<TResult>(
+  permit: ApplicationJobPermitPort,
+  callback: () => Promise<TResult>
+): Promise<TResult>;
+export function runWithApplicationJobPermit<TResult, TFirst = undefined, TSecond = undefined>(
   permit: ApplicationJobPermitPort,
-  callback: () => Promise<TResult> | TResult
-): Promise<TResult> {
-  const scope: ApplicationJobPermitScope = { permit, detached: false };
-  return applicationJobPermitScope.run(scope, async () => {
-    try {
-      return await callback();
-    } finally {
-      if (!scope.detached) permit.releaseAfterInternalProcessing();
+  callback: (first: TFirst, second: TSecond) => Promise<TResult> | TResult,
+  first?: TFirst,
+  second?: TSecond
+): TResult | Promise<TResult>;
+export function runWithApplicationJobPermit<TResult, TFirst, TSecond>(
+  permit: ApplicationJobPermitPort,
+  callback: (first: TFirst, second: TSecond) => Promise<TResult> | TResult,
+  first?: TFirst,
+  second?: TSecond
+): TResult | Promise<TResult> {
+  const previous = applicationJobPermitScope.getStore();
+  applicationJobPermitScope.enterWith(permit);
+  try {
+    const result = callback(first as TFirst, second as TSecond);
+    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. */
 export function releaseApplicationJobPermitBeforeHandler(): void {
-  applicationJobPermitScope.getStore()?.permit.releaseBeforeHandler();
+  applicationJobPermitScope.getStore()?.releaseBeforeHandler();
 }
 
 /** @internal Returns an ingress permit after a durable queue takes record ownership. */
 export function releaseApplicationJobPermitForDurableHandoff(): void {
-  applicationJobPermitScope.getStore()?.permit.releaseAfterInternalProcessing();
+  applicationJobPermitScope.getStore()?.releaseAfterInternalProcessing();
 }
 
 /** True while dispatch already owns the host-wide application job permit. */
@@ -42,9 +99,14 @@ export function hasApplicationJobPermit(): boolean {
   return applicationJobPermitScope.getStore() !== undefined;
 }
 
+/** The current ingress reservation; capacity remains owned by its host queue. */
+export function currentApplicationJobPermit(): ApplicationJobPermitPort | undefined {
+  return applicationJobPermitScope.getStore();
+}
+
 /** Keeps the ingress origin when a durable record later reacquires its permit. */
 export function currentApplicationJobOrigin(): ApplicationJobOrigin {
-  return applicationJobPermitScope.getStore()!.permit.origin;
+  return applicationJobPermitScope.getStore()!.origin;
 }
 
 /** Re-enters the captured permit scope when a serial executor runs later. */
@@ -61,9 +123,8 @@ export function bindApplicationJobPermit<TResult, TArgument>(
  * detached owner must release it at handler entry or at a pre-start terminal.
  */
 export function detachApplicationJobPermit(): ApplicationJobPermitPort | undefined {
-  const scope = applicationJobPermitScope.getStore();
-  if (scope === undefined) return undefined;
-  scope.permit.detachForHandlerTurn?.();
-  scope.detached = true;
-  return scope.permit;
+  const permit = applicationJobPermitScope.getStore();
+  if (permit === undefined) return undefined;
+  permit.detachForHandlerTurn();
+  return permit;
 }

package/src/runtime/application-jobs/contracts.ts

@@ -1,15 +1,30 @@
 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

package/src/runtime/backend/contracts/index.ts

@@ -61,12 +61,32 @@ export type ZLinkBackendObjectPlacement =
   | { readonly kind: 'capacity' }
   | { 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;
@@ -97,9 +117,9 @@ export interface ZLinkBackendMeshNode {
       '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>;
@@ -125,7 +145,8 @@ export interface ZLinkBackendMeshNode {
     parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[],
     deadlineUnixMs: bigint,
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): MeshOperationId;
   sendToInstanceSpot(
     route: ServiceInstanceRouteFence,
@@ -140,7 +161,8 @@ export interface ZLinkBackendMeshNode {
     timeoutMs?: number,
     sourceSpotId?: string,
     metadata?: ReadonlyMap<string, string>,
-    instanceIntent?: boolean
+    instanceIntent?: boolean,
+    onAdmitted?: () => void
   ): MeshOperationId;
   registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
   requestUserSpotCreate(
@@ -181,13 +203,28 @@ 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.
@@ -208,12 +245,21 @@ export interface ZLinkBackendMeshNode {
   requestInfrastructureControlFrames?(
     targetRid: unknown,
     frames: readonly Uint8Array[],
-    options?: { readonly timeoutMs?: number }
+    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 }
+    options?: {
+      flags?: number;
+      timeoutMs?: number;
+      applicationMetadata?: Buffer;
+      onAdmitted?: () => void;
+    }
   ): MeshOperationId;
   sendToChannel(
     channelName: string,
@@ -223,7 +269,12 @@ export interface ZLinkBackendMeshNode {
   requestToChannel(
     channelName: string,
     parts: MessageLike | readonly MessageLike[],
-    options?: { flags?: number; timeoutMs?: number; applicationMetadata?: Buffer }
+    options?: {
+      flags?: number;
+      timeoutMs?: number;
+      applicationMetadata?: Buffer;
+      onAdmitted?: () => void;
+    }
   ): MeshOperationId;
   status(): MeshNodeStatus;
   peers(): MeshPeerEntry[];
@@ -296,9 +347,10 @@ export interface ZLinkBackendMeshNode {
     source: ServiceDirectSpotRouteFence
   ): ServiceSpotMessageFollowSeal | undefined;
   abortSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal): boolean;
+  /** A null target consumes the committed seal without installing a Follow route. */
   commitSpotMessageFollowIngress?(
     seal: ServiceSpotMessageFollowSeal,
-    target: ServiceDirectSpotRouteFence,
+    target: ServiceDirectSpotRouteFence | null,
     durationMs: number
   ): Promise<boolean>;
   joinActorSpot(
@@ -344,12 +396,21 @@ export interface ZLinkBackendMeshNode {
   sendToActor(
     actor: ZLinkBackendActorRef,
     parts: MessageLike | readonly MessageLike[],
-    options?: { flags?: number }
+    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 }
+    options?: {
+      flags?: number;
+      timeoutMs?: number;
+      applicationMetadata?: Buffer;
+      onAdmitted?: () => void;
+      routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
+    }
   ): MeshOperationId;
   actorSendToActor(
     source: ZLinkBackendActorRef,
@@ -361,7 +422,12 @@ export interface ZLinkBackendMeshNode {
     source: ZLinkBackendActorRef,
     target: ZLinkBackendActorRef,
     parts: MessageLike | readonly MessageLike[],
-    options?: { flags?: number; timeoutMs?: number; applicationMetadata?: Buffer }
+    options?: {
+      flags?: number;
+      timeoutMs?: number;
+      applicationMetadata?: Buffer;
+      onAdmitted?: () => void;
+    }
   ): MeshOperationId;
   sendActorBoundSession(
     actor: ZLinkBackendActorRef,
@@ -484,7 +550,11 @@ 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;
 }
 
@@ -501,7 +571,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 {
@@ -519,7 +589,8 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
   request(
     routingId: RoutingId,
     message: Message | readonly Message[],
-    timeoutMs?: number
+    timeoutMs?: number,
+    onAdmitted?: () => void
   ): Promise<readonly Message[]>;
   sendToSpot(
     targetNodeRid: RoutingId,
@@ -531,7 +602,8 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     targetNodeRid: RoutingId,
     targetSpotId: RoutingId,
     parts: readonly Message[],
-    timeoutMs?: number
+    timeoutMs?: number,
+    onAdmitted?: () => void
   ): Promise<readonly Message[]>;
   disconnectPeer(routingId: RoutingId): void;
   reply(routingId: RoutingId, replyToken: unknown): ZLinkBackendReplyOperation;
@@ -688,7 +760,8 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
   requestToChannel(
     channelName: string,
     payload: Message | readonly Message[],
-    timeoutMs?: number
+    timeoutMs?: number,
+    onAdmitted?: () => void
   ): Promise<readonly Message[]>;
   sendToChannel(channelName: string, payload: Message | readonly Message[]): Promise<void>;
   publish(
@@ -705,7 +778,8 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     targetRid: RoutingId,
     spotId: RoutingId,
     payload: Message | readonly Message[],
-    timeoutMs?: number
+    timeoutMs?: number,
+    onAdmitted?: () => void
   ): Promise<readonly Message[]>;
   dispose(): Promise<void>;
 }