@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,3 +1,4 @@
+import type { ZLinkHandlerMessageType } from '../../contracts/Common/HandlerMessageType';
 import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import {
   type Type,
@@ -14,6 +15,10 @@ import {
 } from '../../contracts';
 
 import type { Message } from '../../contracts/Common/Message';
+import {
+  resolveHandlerMessageType,
+  resolveMessageTypeForDecode
+} from '../../contracts/Common/HandlerMessageType';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import { readZLinkDecoratorMetadata } from '../../contracts/Handlers/Attributes';
 import { ZLinkConfigurationException } from '../configuration';
@@ -37,11 +42,15 @@ export interface ZLinkActorPacketDescriptor {
   readonly packetName: string;
   readonly actorType: Type<ZLinkActor>;
   readonly handlerType: Type;
+  readonly messageType?: ZLinkHandlerMessageType;
   readonly methodName?: string;
 }
 
 export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRegistry {
-  private readonly packets = new Map<string, ZLinkActorPacketDescriptor>();
+  private readonly packets = new Map<
+    ZLinkActorPacketKind,
+    Map<string, Map<string, ZLinkActorPacketDescriptor>>
+  >();
 
   addHandler<THandler>(handlerType: Type<THandler>, packetName?: string): this {
     const metadata = readZLinkDecoratorMetadata(handlerType).find(
@@ -54,6 +63,7 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
         `Actor packet handler '${handlerType.name}' must declare a packet name.`
       );
     }
+    const messageType = resolveHandlerMessageType(handlerType);
     return this.addPacket({
       kind:
         metadata.kind === 'spotActorSend'
@@ -62,13 +72,16 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
       packetName: resolvedPacketName,
       actorType: Object as unknown as Type<ZLinkActor>,
       handlerType,
+      ...(messageType === undefined ? {} : { messageType }),
       methodName: metadata.methodName
     });
   }
 
   addPacket(descriptor: ZLinkActorPacketDescriptor): this {
-    const key = packetKey(descriptor.kind, descriptor.actorType, descriptor.packetName);
-    if (this.packets.has(key)) {
+    const actorTypeName = descriptor.actorType.name;
+    let packets = this.packets.get(descriptor.kind);
+    let actors = packets?.get(descriptor.packetName);
+    if (actors?.has(actorTypeName) === true) {
       throw createInternalFrameworkException(
         ZLinkFrameworkInternalErrorKind.InvalidOperation,
         `Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`
@@ -80,7 +93,15 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
           (descriptor.kind === ZLinkActorPacketKind.Send ? 'spotActorSend' : 'spotActorRequest') &&
         entry.packetName === descriptor.packetName
     );
-    this.packets.set(key, {
+    if (packets === undefined) {
+      packets = new Map();
+      this.packets.set(descriptor.kind, packets);
+    }
+    if (actors === undefined) {
+      actors = new Map();
+      packets.set(descriptor.packetName, actors);
+    }
+    actors.set(actorTypeName, {
       ...descriptor,
       methodName: descriptor.methodName ?? metadata?.methodName
     });
@@ -92,24 +113,20 @@ export class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRe
     actor: ZLinkActor,
     packetName: string
   ): ZLinkActorPacketDescriptor | undefined {
+    const actors = this.packets.get(kind)?.get(packetName);
+    if (actors === undefined) return undefined;
     const actorType = actor.constructor as Type<ZLinkActor>;
-    const exact = this.packets.get(packetKey(kind, actorType, packetName));
+    const exact = actors.get(actorType.name);
     if (exact !== undefined) {
       return exact;
     }
-    const wildcard = this.packets.get(
-      packetKey(kind, Object as unknown as Type<ZLinkActor>, packetName)
-    );
+    const wildcard = actors.get(Object.name);
     if (wildcard !== undefined) {
       return wildcard;
     }
 
-    for (const descriptor of this.packets.values()) {
-      if (
-        descriptor.kind === kind &&
-        descriptor.packetName === packetName &&
-        actor instanceof descriptor.actorType
-      ) {
+    for (const descriptor of actors.values()) {
+      if (actor instanceof descriptor.actorType) {
         return descriptor;
       }
     }
@@ -142,7 +159,7 @@ export class ZLinkSpotActorDispatcher {
     actor: ZLinkActor,
     packetName: string,
     message: TMessage,
-    context: Partial<ZLinkMessageContext> = {}
+    context?: Partial<ZLinkMessageContext>
   ): Promise<void> {
     return this.dispatchSendDecoded(actor, packetName, () => message, context);
   }
@@ -150,26 +167,22 @@ export class ZLinkSpotActorDispatcher {
   dispatchSendDecoded<TMessage>(
     actor: ZLinkActor,
     packetName: string,
-    decode: () => TMessage,
-    context: Partial<ZLinkMessageContext> = {}
+    decode: (messageType?: Type) => TMessage,
+    context?: Partial<ZLinkMessageContext>
   ): Promise<void> {
     return this.execute(async () => {
       const descriptor = this.requirePacket(ZLinkActorPacketKind.Send, actor, packetName);
-      const message = decode();
-      this.options.onHandlerStart?.();
+      const message = decode(resolveMessageTypeForDecode(descriptor.messageType));
       await this.invokeHandler<ZLinkSpotActorSendHandler<ZLinkSpot, ZLinkActor, TMessage>, void>(
         actor,
         descriptor,
-        (handler, method) =>
-          runActorHandlerWithDeferredJoins(() =>
-            method.call(
-              handler,
-              this.options.spot,
-              actor,
-              this.createContext(packetName, context),
-              message
-            )
-          )
+        (handler, method) => {
+          const handlerContext = this.createContext(packetName, context);
+          return runActorHandlerWithDeferredJoins(() => {
+            this.options.onHandlerStart?.();
+            return method.call(handler, this.options.spot, actor, handlerContext, message);
+          });
+        }
       );
     });
   }
@@ -178,7 +191,7 @@ export class ZLinkSpotActorDispatcher {
     actor: ZLinkActor,
     packetName: string,
     request: TRequest,
-    context: Partial<ZLinkMessageContext> = {}
+    context?: Partial<ZLinkMessageContext>
   ): Promise<TReply> {
     return this.dispatchRequestThenDecoded<TRequest, TReply, TReply>(
       actor,
@@ -192,8 +205,8 @@ export class ZLinkSpotActorDispatcher {
   dispatchRequestDecoded<TRequest, TReply>(
     actor: ZLinkActor,
     packetName: string,
-    decode: () => TRequest,
-    context: Partial<ZLinkMessageContext> = {}
+    decode: (messageType?: Type) => TRequest,
+    context?: Partial<ZLinkMessageContext>
   ): Promise<TReply> {
     return this.dispatchRequestThenDecoded<TRequest, TReply, TReply>(
       actor,
@@ -208,7 +221,7 @@ export class ZLinkSpotActorDispatcher {
     actor: ZLinkActor,
     packetName: string,
     request: TRequest,
-    context: Partial<ZLinkMessageContext> = {},
+    context: Partial<ZLinkMessageContext> | undefined,
     afterReply: (
       reply: TReply,
       options: ZLinkSpotActorReplyOptionsSnapshot
@@ -231,8 +244,8 @@ export class ZLinkSpotActorDispatcher {
   dispatchRequestThenDecoded<TRequest, TReply, TResult>(
     actor: ZLinkActor,
     packetName: string,
-    decode: () => TRequest,
-    context: Partial<ZLinkMessageContext> = {},
+    decode: (messageType?: Type) => TRequest,
+    context: Partial<ZLinkMessageContext> | undefined,
     afterReply: (
       reply: TReply,
       options: ZLinkSpotActorReplyOptionsSnapshot
@@ -244,35 +257,31 @@ export class ZLinkSpotActorDispatcher {
   ): Promise<TResult> {
     return this.execute(async () => {
       const descriptor = this.requirePacket(ZLinkActorPacketKind.Request, actor, packetName);
-      const request = decode();
-      this.options.onHandlerStart?.();
+      const request = decode(resolveMessageTypeForDecode(descriptor.messageType));
       return await this.invokeHandler<
         ZLinkSpotActorRequestHandler<ZLinkSpot, ZLinkActor, TRequest, TReply>,
         TResult
-      >(actor, descriptor, (handler, method) =>
-        runActorHandlerWithDeferredJoins(
-          () =>
-            method.call(
-              handler,
-              this.options.spot,
-              actor,
-              this.createContext(packetName, context),
-              request
-            ),
+      >(actor, descriptor, (handler, method) => {
+        const handlerContext = this.createContext(packetName, context);
+        return runActorHandlerWithDeferredJoins(
+          () => {
+            this.options.onHandlerStart?.();
+            return method.call(handler, this.options.spot, actor, handlerContext, request);
+          },
           (reply) =>
             afterReply(reply, {
-              metadata: new Map<string, string>(),
+              metadata: ZLinkMessageMetadataEmpty.values,
               compressPayload: false
             }),
           beforeReply === undefined
             ? undefined
             : (reply) =>
                 beforeReply(reply, {
-                  metadata: new Map<string, string>(),
+                  metadata: ZLinkMessageMetadataEmpty.values,
                   compressPayload: false
                 })
-        )
-      );
+        );
+      });
     });
   }
 
@@ -353,7 +362,7 @@ export class ZLinkSpotActorDispatcher {
     );
   }
 
-  private async invokeHandler<THandler, TResult>(
+  invokeHandler<THandler, TResult>(
     actor: ZLinkActor,
     descriptor: Pick<ZLinkActorPacketDescriptor, 'handlerType' | 'methodName'>,
     callback: (
@@ -361,7 +370,7 @@ export class ZLinkSpotActorDispatcher {
       method: THandler extends { handle: infer TMethod } ? TMethod : never
     ) => Promise<TResult>
   ): Promise<TResult> {
-    return await runWithLifecycleHandler(
+    return runWithLifecycleHandler(
       actor,
       descriptor.handlerType,
       this.options.providerResolver,
@@ -389,29 +398,22 @@ export class ZLinkSpotActorDispatcher {
     return pending;
   }
 
-  private createContext(
+  createContext(
     packetName: string,
-    context: Partial<ZLinkMessageContext>
+    context: Partial<ZLinkMessageContext> | undefined
   ): ZLinkMessageContext {
     return {
-      meshName: context.meshName,
-      channelName: context.channelName,
+      meshName: context?.meshName,
+      channelName: context?.channelName,
       packetName,
-      contentType: context.contentType,
-      metadata: context.metadata ?? ZLinkMessageMetadataEmpty,
-      correlationId: context.correlationId
+      contentType: context?.contentType,
+      metadata: context?.metadata ?? ZLinkMessageMetadataEmpty,
+      correlationId: context?.correlationId,
+      receivedAt: context?.receivedAt ?? new Date()
     };
   }
 }
 
-function packetKey(
-  kind: ZLinkActorPacketKind,
-  actorType: Type<ZLinkActor>,
-  packetName: string
-): string {
-  return `${kind}:${actorType.name}:${packetName}`;
-}
-
 function actorDispatchHandlerNotFound(message: string): ZLinkFrameworkException {
   return createInternalFrameworkException(
     ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound,

package/src/runtime/admission.ts

@@ -3,12 +3,15 @@ import {
   createInternalFrameworkException
 } from './framework-errors-internal';
 import { isPromiseLike } from './abort';
+import { ReceiveKind, type ReceiveRecord } from './foundation/service-runtime-contracts';
 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>
+export type ZLinkMeshDispatchAdmission = <TReceiver = void, TContext = void>(
+  dispatch: (this: TReceiver, context: TContext) => void | Promise<void>,
+  onRejected?: (this: TReceiver, error: unknown, context: TContext) => void | Promise<void>,
+  receiver?: TReceiver,
+  context?: TContext
 ) => void | Promise<void>;
 
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
@@ -46,8 +49,8 @@ export class ZLinkRuntimeAdmissionGate {
     }
   }
 
-  accepts(meshName: string): boolean {
-    return this.ownerAdmissionOpen() && !this.requireState(meshName).sealed;
+  accepts(meshName: string, kind?: ReceiveRecord['kind']): boolean {
+    return this.isOpen(this.requireState(meshName), kind);
   }
 
   pending(meshName: string): number {
@@ -70,8 +73,12 @@ export class ZLinkRuntimeAdmissionGate {
     }
   }
 
-  claim(meshName: string, operation: string): ZLinkApplicationWorkClaim {
-    const state = this.enter(meshName, operation);
+  claim(
+    meshName: string,
+    operation: string,
+    kind?: ReceiveRecord['kind']
+  ): ZLinkApplicationWorkClaim {
+    const state = this.enter(meshName, operation, kind);
     let closed = false;
     return {
       close: () => {
@@ -87,22 +94,27 @@ export class ZLinkRuntimeAdmissionGate {
    * admission in the same turn; asynchronous work leaves it from the single
    * continuation on its result.
    */
-  run<T>(
+  run<T, TReceiver = void, TContext = void>(
     meshName: string,
     operation: string,
-    work: () => T | Promise<T>,
-    onRejected?: (error: unknown) => T | Promise<T>
+    work: (this: TReceiver, context: TContext) => T | Promise<T>,
+    kind?: ReceiveRecord['kind'],
+    onRejected?: (this: TReceiver, error: unknown, context: TContext) => T | Promise<T>,
+    receiver?: TReceiver,
+    context?: TContext
   ): T | Promise<T> {
     let state: ZLinkMeshAdmissionState;
     let result: T | Promise<T>;
     try {
-      state = this.enter(meshName, operation);
+      state = this.enter(meshName, operation, kind);
     } catch (error) {
       // The domain owns admission rejection completion, just as it owns handler failure.
-      return onRejected === undefined ? Promise.reject(error) : onRejected(error);
+      return onRejected === undefined
+        ? Promise.reject(error)
+        : onRejected.call(receiver as TReceiver, error, context as TContext);
     }
     try {
-      result = work();
+      result = work.call(receiver as TReceiver, context as TContext);
     } catch (error) {
       exitAdmission(state);
       return Promise.reject(error);
@@ -123,9 +135,24 @@ export class ZLinkRuntimeAdmissionGate {
     );
   }
 
-  private enter(meshName: string, operation: string): ZLinkMeshAdmissionState {
+  private isOpen(state: ZLinkMeshAdmissionState, kind?: ReceiveRecord['kind']): boolean {
+    return (
+      !state.sealed &&
+      (kind === ReceiveKind.NodeSend ||
+        kind === ReceiveKind.NodeRequest ||
+        kind === ReceiveKind.ChannelSend ||
+        kind === ReceiveKind.ChannelRequest ||
+        this.ownerAdmissionOpen())
+    );
+  }
+
+  private enter(
+    meshName: string,
+    operation: string,
+    kind?: ReceiveRecord['kind']
+  ): ZLinkMeshAdmissionState {
     const state = this.requireState(meshName);
-    if (this.ownerAdmissionOpen() && !state.sealed) {
+    if (this.isOpen(state, kind)) {
       state.active += 1;
       return state;
     }

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

@@ -105,6 +105,10 @@ export class ApplicationJobRecordLease implements ApplicationJobPermitPort {
     private permit: ApplicationJobPermitPort | undefined
   ) {}
 
+  reacquire(signal: AbortSignal): Promise<ApplicationJobPermitPort> {
+    return this.shared.acquirePermit(signal);
+  }
+
   get origin(): ApplicationJobOrigin {
     return this.shared.origin;
   }

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

@@ -1,3 +1,5 @@
+import type { PendingOperation } from '../../foundation/operation-registry';
+import type { RequestRuntime } from '../../foundation/request-runtime';
 import type {
   RequestResult,
   SubmitResult,
@@ -72,6 +74,7 @@ export type ZLinkBackendRequestSourceAcceptance = (
   | Promise<import('../../locations/request-source-resolver').ZLinkRequestSourceFence | undefined>;
 
 export interface ZLinkBackendMeshNode {
+  setRequestRuntime?(requests: RequestRuntime): void;
   acceptRelocatedActorTerminal?(
     operation: { readonly high: bigint; readonly low: bigint },
     replyRouteId: bigint,
@@ -146,7 +149,8 @@ export interface ZLinkBackendMeshNode {
     deadlineUnixMs: bigint,
     sourceSpotId?: string,
     metadata?: ReadonlyMap<string, string>,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ): MeshOperationId;
   sendToInstanceSpot(
     route: ServiceInstanceRouteFence,
@@ -162,7 +166,9 @@ export interface ZLinkBackendMeshNode {
     sourceSpotId?: string,
     metadata?: ReadonlyMap<string, string>,
     instanceIntent?: boolean,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>,
+    completion?: ZLinkMeshCompletionHandler
   ): MeshOperationId;
   registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
   requestUserSpotCreate(
@@ -247,6 +253,7 @@ export interface ZLinkBackendMeshNode {
     frames: readonly Uint8Array[],
     options?: {
       readonly timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       readonly signal?: AbortSignal;
       readonly onSubmitted?: (signal: AbortSignal) => Promise<void>;
     }
@@ -257,9 +264,11 @@ export interface ZLinkBackendMeshNode {
     options?: {
       flags?: number;
       timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       applicationMetadata?: Buffer;
       onAdmitted?: () => void;
-    }
+    },
+    completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler
   ): MeshOperationId;
   sendToChannel(
     channelName: string,
@@ -272,9 +281,11 @@ export interface ZLinkBackendMeshNode {
     options?: {
       flags?: number;
       timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       applicationMetadata?: Buffer;
       onAdmitted?: () => void;
-    }
+    },
+    completion?: import('../mesh-completion-table').ZLinkMeshCompletionHandler
   ): MeshOperationId;
   status(): MeshNodeStatus;
   peers(): MeshPeerEntry[];
@@ -407,10 +418,12 @@ export interface ZLinkBackendMeshNode {
     options?: {
       flags?: number;
       timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       applicationMetadata?: Buffer;
       onAdmitted?: () => void;
       routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
-    }
+    },
+    completion?: ZLinkMeshCompletionHandler
   ): MeshOperationId;
   actorSendToActor(
     source: ZLinkBackendActorRef,
@@ -425,6 +438,7 @@ export interface ZLinkBackendMeshNode {
     options?: {
       flags?: number;
       timeoutMs?: number;
+      readonly requestOperation?: PendingOperation<unknown>;
       applicationMetadata?: Buffer;
       onAdmitted?: () => void;
     }
@@ -553,8 +567,16 @@ export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket
   request(
     message: Message | readonly Message[],
     timeoutMs?: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: undefined
   ): Promise<readonly Message[]>;
+  request(
+    message: Message | readonly Message[],
+    timeoutMs: number | undefined,
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+  ): void;
   recv(flags?: ZLinkBackendRecvFlags): Received | undefined;
 }
 
@@ -572,6 +594,11 @@ export interface ZLinkBackendRequestOperation {
   message(message: MessageLike): ZLinkBackendRequestOperation;
   timeout(timeoutMs: number): ZLinkBackendRequestOperation;
   submit(onAdmitted?: () => void): Promise<readonly Message[]>;
+  submit(
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+  ): void;
 }
 
 export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket {
@@ -590,8 +617,17 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     routingId: RoutingId,
     message: Message | readonly Message[],
     timeoutMs?: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: undefined
   ): Promise<readonly Message[]>;
+  request(
+    routingId: RoutingId,
+    message: Message | readonly Message[],
+    timeoutMs: number | undefined,
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+  ): void;
   sendToSpot(
     targetNodeRid: RoutingId,
     targetSpotId: RoutingId,
@@ -603,8 +639,18 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     targetSpotId: RoutingId,
     parts: readonly Message[],
     timeoutMs?: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: undefined
   ): Promise<readonly Message[]>;
+  requestToSpot(
+    targetNodeRid: RoutingId,
+    targetSpotId: RoutingId,
+    parts: readonly Message[],
+    timeoutMs: number | undefined,
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+  ): void;
   disconnectPeer(routingId: RoutingId): void;
   reply(routingId: RoutingId, replyToken: unknown): ZLinkBackendReplyOperation;
   reply(routingId: RoutingId, replyToken: unknown, message: Message | readonly Message[]): void;
@@ -761,8 +807,17 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     channelName: string,
     payload: Message | readonly Message[],
     timeoutMs?: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: undefined
   ): Promise<readonly Message[]>;
+  requestToChannel(
+    channelName: string,
+    payload: Message | readonly Message[],
+    timeoutMs: number | undefined,
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+  ): void;
   sendToChannel(channelName: string, payload: Message | readonly Message[]): Promise<void>;
   publish(
     topic: string,
@@ -779,8 +834,18 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     spotId: RoutingId,
     payload: Message | readonly Message[],
     timeoutMs?: number,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: undefined
   ): Promise<readonly Message[]>;
+  requestToSpot(
+    targetRid: RoutingId,
+    spotId: RoutingId,
+    payload: Message | readonly Message[],
+    timeoutMs: number | undefined,
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown>,
+    receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+  ): void;
   dispose(): Promise<void>;
 }
 
@@ -800,6 +865,8 @@ export interface ZLinkMeshBackendAdapter {
     options: {
       readonly meshName: string;
       readonly routingId?: RoutingId;
+      readonly sendHighWaterMark?: number;
+      readonly receiveHighWaterMark?: number;
       readonly receiveTimeoutMs?: number;
       readonly trustProfile?: string;
       readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;