@zlink-systems/framework 0.29.1 → 0.30.1

package/src/runtime/channels/channel-dispatch-services.ts

@@ -26,7 +26,11 @@ import {
 import type { ZLinkRuntimeTaskErrorSink } from '../execution';
 import { ZLinkDispatchErrorReporter } from './dispatch-error-reporter';
 import { invokeZLinkHandlerFilters } from '../handlers';
-import { runInHandlerInstanceScope } from '../handlers/handler-instance-scope';
+import {
+  runInHandlerInstanceScope,
+  prepareHandlerInstance,
+  handlerInstanceCleanup
+} from '../handlers/handler-instance-scope';
 import { handlerFilterScope } from './handler-filter-scope';
 import type {
   ZLinkChannelRequestHandler,
@@ -109,6 +113,17 @@ export class ZLinkChannelDispatchServices {
   }
 
   channelRequestHandler(handlerType: Type): ZLinkChannelRequestHandler {
+    const activate =
+      this.registration.filterTypes.length === 0
+        ? prepareHandlerInstance(
+            this.providerResolver,
+            handlerType as Type<ZLinkChannelRequestHandler>
+          )
+        : undefined;
+    if (activate !== undefined)
+      return {
+        handle: (payload, context) => this.invokeScopeFreeHandler(activate, payload, context)
+      };
     return {
       handle: (payload, context) =>
         this.withHandlerScope(context, async (scope) => {
@@ -119,6 +134,17 @@ export class ZLinkChannelDispatchServices {
   }
 
   channelSendHandler(handlerType: Type): ZLinkChannelSendHandler {
+    const activate =
+      this.registration.filterTypes.length === 0
+        ? prepareHandlerInstance(
+            this.providerResolver,
+            handlerType as Type<ZLinkChannelSendHandler>
+          )
+        : undefined;
+    if (activate !== undefined)
+      return {
+        handle: (payload, context) => this.invokeScopeFreeHandler(activate, payload, context)
+      };
     return {
       handle: (payload, context) =>
         this.withHandlerScope(context, async (scope) => {
@@ -129,6 +155,17 @@ export class ZLinkChannelDispatchServices {
   }
 
   routeRequestHandler(handlerType: Type): ZLinkRouteRuntimeRequestHandler {
+    const activate =
+      this.registration.filterTypes.length === 0
+        ? prepareHandlerInstance(
+            this.providerResolver,
+            handlerType as Type<ZLinkRouteRuntimeRequestHandler>
+          )
+        : undefined;
+    if (activate !== undefined)
+      return {
+        handle: (payload, context) => this.invokeScopeFreeHandler(activate, payload, context)
+      };
     return {
       handle: (payload, context) =>
         this.withHandlerScope(context, async (scope) => {
@@ -139,6 +176,17 @@ export class ZLinkChannelDispatchServices {
   }
 
   routeSendHandler(handlerType: Type): ZLinkRouteRuntimeSendHandler {
+    const activate =
+      this.registration.filterTypes.length === 0
+        ? prepareHandlerInstance(
+            this.providerResolver,
+            handlerType as Type<ZLinkRouteRuntimeSendHandler>
+          )
+        : undefined;
+    if (activate !== undefined)
+      return {
+        handle: (payload, context) => this.invokeScopeFreeHandler(activate, payload, context)
+      };
     return {
       handle: (payload, context) =>
         this.withHandlerScope(context, async (scope) => {
@@ -148,6 +196,26 @@ export class ZLinkChannelDispatchServices {
     };
   }
 
+  private invokeScopeFreeHandler<TContext extends ZLinkMessageContext, TResult>(
+    activate: () => { handle(payload: unknown, context: TContext): TResult | Promise<TResult> },
+    payload: unknown,
+    context: TContext
+  ): TResult | Promise<TResult> {
+    const handler = activate();
+    const cleanup = handlerInstanceCleanup(handler);
+    if (cleanup === undefined) return handler.handle(payload, context);
+    let result: TResult | Promise<TResult>;
+    try {
+      result = handler.handle(payload, context);
+    } catch (error) {
+      const disposed = cleanup.call(handler);
+      return Promise.resolve(disposed).then(() => {
+        throw error;
+      });
+    }
+    return Promise.resolve(result).finally(() => cleanup.call(handler));
+  }
+
   private async invokeHandlerFilters(
     context: ZLinkHandlerFilterContext,
     next: () => Promise<void>,

package/src/runtime/channels/channel-dispatchers.ts

@@ -13,7 +13,7 @@ import {
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import type { Message } from '../../contracts/Common/Message';
 import { SubmitResult } from '../backend/runtime-values';
-import type { ReceiveRecord } from '../foundation/service-runtime-contracts';
+import { ReceiveKind, type ReceiveRecord } from '../foundation/service-runtime-contracts';
 import { ZLinkConfigurationException, type ZLinkRouteChannelOptions } from '../configuration';
 import type { ZLinkBackendSpotRouteBridge } from '../backend/contracts';
 import type { ZLinkRuntimeMetrics } from '../diagnostics';
@@ -59,6 +59,8 @@ export interface ZLinkChannelRequestDispatcherOptions {
   readonly unhandled?: ZLinkUnhandledDispatchOptions;
 }
 
+const completedChannelReply = Promise.resolve();
+
 export interface ZLinkChannelRequestHandler {
   handle(payload: unknown, context: ZLinkMessageContext): Promise<unknown> | unknown;
 }
@@ -134,7 +136,7 @@ export class ZLinkChannelRequestDispatcher {
       await this.pipeline.dispatchMalformed({
         info,
         error,
-        transportRequest: replyToken !== null,
+        transportRequest: replyToken != null,
         writeProtocolError:
           replyToken === null
             ? undefined
@@ -236,19 +238,19 @@ export class ZLinkChannelRequestDispatcher {
     });
   }
 
-  async dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
+  dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
     if (record.parts.length === 0 || record.parts[0].data().length === 0) {
-      return;
+      return completedChannelReply;
     }
     let envelope: ReturnType<typeof decodeChannelEnvelope>;
     try {
       envelope = decodeChannelEnvelope(record.parts, undefined, this.flowEnabled());
     } catch (error) {
       const info = inspectMalformedChannelHeader(record.parts, this.flowEnabled());
-      await this.pipeline.dispatchMalformed({
+      return this.pipeline.dispatchMalformed({
         info,
         error,
-        transportRequest: false,
+        transportRequest: isMeshRequest(record),
         sourceRid: record.sourceNodeRid == null ? undefined : String(record.sourceNodeRid),
         writeProtocolError: async (protocolError) => {
           requireMeshReplyAccepted(
@@ -261,7 +263,6 @@ export class ZLinkChannelRequestDispatcher {
           );
         }
       });
-      return;
     }
     const packetName = envelope.packetName;
     if (packetName === undefined) {
@@ -269,7 +270,7 @@ export class ZLinkChannelRequestDispatcher {
     }
     const correlationId = envelope.header.correlationId ?? undefined;
     if (envelope.header.kind === ZLinkChannelMessageKind.Command) {
-      await this.pipeline.dispatchOneWay({
+      return this.pipeline.dispatchOneWay({
         fields: {
           messageKind: ZLinkDispatchMessageKind.Send,
           packetName,
@@ -283,10 +284,9 @@ export class ZLinkChannelRequestDispatcher {
         context: this.createMeshContext(envelope, record.sourceNodeRid),
         signal
       });
-      return;
     }
     if (envelope.header.kind !== ZLinkChannelMessageKind.Request) {
-      return;
+      return completedChannelReply;
     }
     const fields: ZLinkChannelDispatchFields = {
       messageKind: ZLinkDispatchMessageKind.Request,
@@ -295,7 +295,7 @@ export class ZLinkChannelRequestDispatcher {
       flowId: envelope.header.flowId,
       flowOrigin: envelope.header.flowOrigin
     };
-    await this.pipeline.dispatchRequest({
+    return this.pipeline.dispatchRequest({
       fields,
       envelope,
       codecs: this.options.codecs,
@@ -303,12 +303,12 @@ export class ZLinkChannelRequestDispatcher {
       context: this.createMeshContext(envelope, record.sourceNodeRid),
       signal,
       missingHandlerMessage: `No channel request handler is registered for '${this.options.channelName}:${packetName}'.`,
-      writeReply: async (reply) => {
+      writeReply: (reply) => {
         requireMeshReplyAccepted(
           record.reply(encodeChannelReplyParts(envelope.header, reply, this.options.codecs))
         );
       },
-      writeError: async (error) => {
+      writeError: (error) => {
         requireMeshReplyAccepted(
           record.reply(encodeChannelErrorReplyParts(envelope.header, error))
         );
@@ -324,7 +324,7 @@ export class ZLinkChannelRequestDispatcher {
     if (operation.submit() === false) {
       throw new ZLinkConfigurationException('Channel reply was not accepted by Core.');
     }
-    return Promise.resolve();
+    return completedChannelReply;
   }
 
   private createMeshContext(
@@ -587,7 +587,7 @@ export class ZLinkRoutePacketDispatcher {
       await this.pipeline.dispatchMalformed({
         info,
         error,
-        transportRequest: replyToken !== null,
+        transportRequest: replyToken != null,
         sourceRid: String(received.routingId),
         writeProtocolError:
           replyToken === null
@@ -685,19 +685,19 @@ export class ZLinkRoutePacketDispatcher {
     });
   }
 
-  async dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
+  dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
     if (record.parts.length === 0 || record.parts[0].data().length === 0) {
-      return;
+      return completedChannelReply;
     }
     let envelope: ReturnType<typeof decodeChannelEnvelope>;
     try {
       envelope = decodeChannelEnvelope(record.parts, undefined, this.flowEnabled());
     } catch (error) {
       const info = inspectMalformedChannelHeader(record.parts, this.flowEnabled());
-      await this.pipeline.dispatchMalformed({
+      return this.pipeline.dispatchMalformed({
         info,
         error,
-        transportRequest: false,
+        transportRequest: isMeshRequest(record),
         sourceRid: record.sourceNodeRid == null ? undefined : String(record.sourceNodeRid),
         writeProtocolError: async (protocolError) => {
           requireMeshReplyAccepted(
@@ -710,7 +710,6 @@ export class ZLinkRoutePacketDispatcher {
           );
         }
       });
-      return;
     }
     const packetName = envelope.packetName;
     if (packetName === undefined) {
@@ -719,17 +718,16 @@ export class ZLinkRoutePacketDispatcher {
     const sourceNodeRid = String(record.sourceNodeRid ?? '');
     const correlationId = envelope.header.correlationId ?? undefined;
     if (envelope.header.kind === ZLinkChannelMessageKind.Command) {
-      await this.dispatchMeshCommand(
+      return this.dispatchMeshCommand(
         envelope,
         packetName,
         sourceNodeRid,
         record.sourceNodeRid,
         signal
       );
-      return;
     }
     if (envelope.header.kind !== ZLinkChannelMessageKind.Request) {
-      return;
+      return completedChannelReply;
     }
     const fields: ZLinkChannelDispatchFields = {
       messageKind: ZLinkDispatchMessageKind.Request,
@@ -740,7 +738,7 @@ export class ZLinkRoutePacketDispatcher {
       flowOrigin: envelope.header.flowOrigin
     };
     const codecs = codecsForFrameworkPacket(packetName, this.codecs);
-    await this.pipeline.dispatchRequest({
+    return this.pipeline.dispatchRequest({
       fields,
       envelope,
       codecs,
@@ -748,12 +746,12 @@ export class ZLinkRoutePacketDispatcher {
       context: this.createRouteContext(envelope, record.sourceNodeRid),
       signal,
       missingHandlerMessage: `No routed request handler is registered for '${this.routerChannelId}:${packetName}'.`,
-      writeReply: async (reply) => {
+      writeReply: (reply) => {
         requireMeshReplyAccepted(
           record.reply(encodeChannelReplyParts(envelope.header, reply, codecs))
         );
       },
-      writeError: async (error) => {
+      writeError: (error) => {
         requireMeshReplyAccepted(
           record.reply(encodeChannelErrorReplyParts(envelope.header, error))
         );
@@ -826,7 +824,7 @@ export class ZLinkRoutePacketDispatcher {
     if (operation.submit() === false) {
       throw new ZLinkConfigurationException('Route reply was not accepted by Core.');
     }
-    return Promise.resolve();
+    return completedChannelReply;
   }
 
   private createRouteContext(
@@ -844,3 +842,7 @@ export class ZLinkRoutePacketDispatcher {
     };
   }
 }
+
+function isMeshRequest(record: ReceiveRecord): boolean {
+  return record.kind === ReceiveKind.NodeRequest || record.kind === ReceiveKind.ChannelRequest;
+}

package/src/runtime/channels/channel-envelope-inspection.ts

@@ -3,6 +3,7 @@ import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkFlowOrigin } from '../../contracts';
 import {
   decodeChannelHeader,
+  isValidChannelCorrelationId,
   ZLINK_CHANNEL_FORMAT_MARKER,
   ZLinkChannelMessageKind,
   type ZLinkChannelEnvelopeHeader
@@ -29,7 +30,6 @@ export function tryDecodeChannelHeader(
  * present only when it is individually well-formed.
  */
 export interface ZLinkMalformedChannelHeaderInfo {
-  readonly kind?: ZLinkChannelMessageKind;
   readonly channelName?: string;
   readonly messageName?: string;
   readonly correlationId?: string;
@@ -50,7 +50,6 @@ export function inspectMalformedChannelHeader(
   } catch {
     return {};
   }
-  if (header.formatMarker !== ZLINK_CHANNEL_FORMAT_MARKER) return {};
   const flowId =
     typeof header.flowId === 'string' && CHANNEL_FLOW_ID_PATTERN.test(header.flowId)
       ? header.flowId
@@ -58,7 +57,6 @@ export function inspectMalformedChannelHeader(
   const flowOrigin = salvageFlowOrigin(header.flowOrigin);
   const flowPairValid = flowEnabled && flowId !== undefined && flowOrigin !== undefined;
   return {
-    kind: salvageChannelKind(header.kind),
     channelName: salvageString(header.channelName),
     messageName: salvageString(header.messageName),
     correlationId: salvageCorrelationId(header.correlationId),
@@ -94,24 +92,12 @@ export function malformedProtocolErrorRequestHeader(
 const CHANNEL_FLOW_ID_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 
-function salvageChannelKind(value: unknown): ZLinkChannelMessageKind | undefined {
-  return value === ZLinkChannelMessageKind.Request ||
-    value === ZLinkChannelMessageKind.Response ||
-    value === ZLinkChannelMessageKind.Command ||
-    value === ZLinkChannelMessageKind.Publish ||
-    value === ZLinkChannelMessageKind.Error
-    ? value
-    : undefined;
-}
-
 function salvageString(value: unknown): string | undefined {
   return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
 
 function salvageCorrelationId(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const byteLength = Buffer.byteLength(value, 'utf8');
-  return byteLength >= 1 && byteLength <= 64 && /^[\x00-\x7f]*$/.test(value) ? value : undefined;
+  return typeof value === 'string' && isValidChannelCorrelationId(value) ? value : undefined;
 }
 
 function salvageFlowOrigin(value: unknown): ZLinkFlowOrigin | undefined {

package/src/runtime/channels/channel-envelope.ts

@@ -1,4 +1,5 @@
 import type { Message } from '../../contracts/Common/Message';
+import { ZLinkBufferMessage } from '../backend/runtime-message';
 import type { ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-values';
 import { randomUUID } from 'node:crypto';
 import { isUtf8 } from 'node:buffer';
@@ -70,6 +71,24 @@ export interface ZLinkChannelEnvelopeCodecRegistry {
   readonly serializers: ReadonlyMap<string, ZLinkMessageSerializer>;
 }
 
+interface PreparedChannelHeader {
+  readonly bytes: Buffer;
+  readonly correlationOffset: number;
+  readonly deadlineOffset: number;
+}
+
+type PreparedHeaderVariants = Map<ZLinkChannelMessageKind, Map<boolean, PreparedChannelHeader>>;
+const preparedChannelHeaders = new WeakMap<
+  ReadonlyMap<string, ZLinkMessageSerializer>,
+  Map<string, Map<string, Map<string, PreparedHeaderVariants>>>
+>();
+const CHANNEL_CORRELATION_FIELD = ',"correlationId":';
+const CHANNEL_DEADLINE_FIELD = ',"deadline":';
+const CHANNEL_CORRELATION_TEXT_LENGTH = 32;
+const PREPARED_CHANNEL_CORRELATION = '0'.repeat(CHANNEL_CORRELATION_TEXT_LENGTH);
+const PREPARED_CHANNEL_DEADLINE = '2000-01-01T00:00:00.000Z';
+const CHANNEL_CORRELATION_TEXT = /^[0-9a-f]{32}$/;
+
 export function newChannelCorrelationId(): string {
   return randomUUID().replaceAll('-', '');
 }
@@ -147,7 +166,8 @@ export function encodeChannelEnvelopePartsAtDeadline(
       undefined,
       applicationMetadataRecord(metadata),
       flow?.flowId,
-      flow?.flowOrigin
+      flow?.flowOrigin,
+      codecs
     ),
     encoded.message
   ];
@@ -215,7 +235,8 @@ export function encodeChannelReplyParts(
       undefined,
       EMPTY_APPLICATION_METADATA,
       request.flowId,
-      request.flowOrigin
+      request.flowOrigin,
+      codecs
     ),
     encoded.message
   ];
@@ -325,7 +346,7 @@ export function decodeChannelReply<TReply>(
     return undefined as TReply;
   }
   if (header.contentType === BINARY_CONTENT_TYPE) {
-    return Buffer.from(parts[1].data()) as TReply;
+    return ZLinkBufferMessage.retainPayload(parts[1]) as TReply;
   }
   if (serializer !== undefined) {
     return serializer.deserialize<TReply>(
@@ -517,8 +538,47 @@ function encodeChannelHeader(
   source: string | null | undefined,
   metadata: Readonly<Record<string, string>>,
   flowId: string | undefined,
-  flowOrigin: ZLinkFlowOrigin | undefined
+  flowOrigin: ZLinkFlowOrigin | undefined,
+  codecs?: ZLinkChannelEnvelopeCodecRegistry
 ): Buffer {
+  if (
+    codecs !== undefined &&
+    metadata === EMPTY_APPLICATION_METADATA &&
+    flowId === undefined &&
+    flowOrigin === undefined &&
+    topic === null &&
+    source === undefined &&
+    ((kind === ZLinkChannelMessageKind.Command &&
+      correlationId === null &&
+      deadline === null &&
+      errorCode === null &&
+      errorMessage === null) ||
+      (kind === ZLinkChannelMessageKind.Request &&
+        correlationId !== null &&
+        CHANNEL_CORRELATION_TEXT.test(correlationId) &&
+        deadline !== null &&
+        deadline.length === PREPARED_CHANNEL_DEADLINE.length &&
+        errorCode === null &&
+        errorMessage === null) ||
+      (kind === ZLinkChannelMessageKind.Response &&
+        correlationId !== null &&
+        CHANNEL_CORRELATION_TEXT.test(correlationId) &&
+        deadline === null &&
+        errorCode === undefined &&
+        errorMessage === undefined))
+  ) {
+    return preparedChannelHeader(
+      codecs,
+      kind,
+      channelName,
+      messageName,
+      contentType,
+      correlationId,
+      deadline,
+      errorCode,
+      errorMessage
+    );
+  }
   // The wire has a fixed field order. Measure escaped UTF-8 first, then write
   // each field once into the only header Buffer: no header object, whole JSON
   // string, or post-encode byte copy exists on the outbound path.
@@ -560,6 +620,63 @@ function encodeChannelHeader(
   return result;
 }
 
+function preparedChannelHeader(
+  codecs: ZLinkChannelEnvelopeCodecRegistry,
+  kind: ZLinkChannelMessageKind,
+  channelName: string,
+  messageName: string,
+  contentType: string,
+  correlationId: string | null,
+  deadline: string | null,
+  errorCode: string | null | undefined,
+  errorMessage: string | null | undefined
+): Buffer {
+  let channels = preparedChannelHeaders.get(codecs.serializers);
+  if (channels === undefined)
+    preparedChannelHeaders.set(codecs.serializers, (channels = new Map()));
+  let packets = channels.get(channelName);
+  if (packets === undefined) channels.set(channelName, (packets = new Map()));
+  let contentTypes = packets.get(messageName);
+  if (contentTypes === undefined) packets.set(messageName, (contentTypes = new Map()));
+  let kinds = contentTypes.get(contentType);
+  if (kinds === undefined) contentTypes.set(contentType, (kinds = new Map()));
+  let deadlines = kinds.get(kind);
+  if (deadlines === undefined) kinds.set(kind, (deadlines = new Map()));
+  const hasDeadline = deadline !== null;
+  let prepared = deadlines.get(hasDeadline);
+  if (prepared === undefined) {
+    const bytes = encodeChannelHeader(
+      kind,
+      channelName,
+      messageName,
+      contentType,
+      correlationId === null ? null : PREPARED_CHANNEL_CORRELATION,
+      hasDeadline ? PREPARED_CHANNEL_DEADLINE : null,
+      null,
+      errorCode,
+      errorMessage,
+      undefined,
+      EMPTY_APPLICATION_METADATA,
+      undefined,
+      undefined
+    );
+    prepared = {
+      bytes,
+      correlationOffset:
+        bytes.indexOf(CHANNEL_CORRELATION_FIELD) + CHANNEL_CORRELATION_FIELD.length + 1,
+      deadlineOffset: bytes.indexOf(CHANNEL_DEADLINE_FIELD) + CHANNEL_DEADLINE_FIELD.length + 1
+    };
+    deadlines.set(hasDeadline, prepared);
+  }
+  if (correlationId === null) return prepared.bytes;
+  const bytes = Buffer.alloc(prepared.bytes.byteLength);
+  prepared.bytes.copy(bytes);
+  bytes.write(correlationId, prepared.correlationOffset, CHANNEL_CORRELATION_TEXT_LENGTH, 'ascii');
+  if (deadline !== null)
+    bytes.write(deadline, prepared.deadlineOffset, PREPARED_CHANNEL_DEADLINE.length, 'ascii');
+  return bytes;
+}
+
 function writeChannelHeader(
   writer: ChannelHeaderWriter,
   kind: ZLinkChannelMessageKind,
@@ -586,9 +703,9 @@ function writeChannelHeader(
   writer.string(messageName);
   writer.append(',"contentType":');
   writer.string(contentType);
-  writer.append(',"correlationId":');
+  writer.append(CHANNEL_CORRELATION_FIELD);
   writer.nullableString(correlationId);
-  writer.append(',"deadline":');
+  writer.append(CHANNEL_DEADLINE_FIELD);
   writer.nullableString(deadline);
   writer.append(',"topic":');
   writer.nullableString(topic);
@@ -994,9 +1111,17 @@ function validateCorrelationForKind(
   }
 }
 
+const MAXIMUM_CORRELATION_ID_BYTES = 64;
+
+export function isValidChannelCorrelationId(value: string): boolean {
+  const byteLength = Buffer.byteLength(value, 'utf8');
+  return (
+    byteLength >= 1 && byteLength <= MAXIMUM_CORRELATION_ID_BYTES && /^[\x00-\x7f]*$/.test(value)
+  );
+}
+
 function validateCorrelationValue(correlationId: string): void {
-  const byteLength = Buffer.byteLength(correlationId, 'utf8');
-  if (byteLength < 1 || byteLength > 64 || !/^[\x00-\x7f]*$/.test(correlationId)) {
+  if (!isValidChannelCorrelationId(correlationId)) {
     throw new ZLinkConfigurationException(
       'Channel envelope correlationId must be a non-empty ASCII value of at most 64 bytes.'
     );

package/src/runtime/channels/channel-outbound-operations.ts

@@ -128,11 +128,20 @@ export class ZLinkChannelOutboundOperations {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     return keepChannelRequestAlive(
       runWithOutboundFlow(this.dispatchServices.flowCreationEnabled(), () =>
-        this.requestScoped<TReply>(channelName, packetName, request, timeoutMs, signal, metadata)
+        this.requestScoped<TReply>(
+          channelName,
+          packetName,
+          request,
+          timeoutMs,
+          signal,
+          metadata,
+          onAdmitted
+        )
       )
     );
   }
@@ -143,7 +152,8 @@ export class ZLinkChannelOutboundOperations {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     const deadlineUnixMs = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
@@ -213,7 +223,8 @@ export class ZLinkChannelOutboundOperations {
             replyParts = await awaitWithAbort(
               dealer.request(
                 parts,
-                remainingRequestTimeout(`Channel request '${channelName}'`, deadlineMs)
+                remainingRequestTimeout(`Channel request '${channelName}'`, deadlineMs),
+                onAdmitted
               ),
               signal
             );
@@ -397,7 +408,8 @@ export class ZLinkChannelOutboundOperations {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     return runWithOutboundFlow(this.dispatchServices.flowCreationEnabled(), () =>
       this.routeRequestScoped<TReply>(
@@ -407,7 +419,8 @@ export class ZLinkChannelOutboundOperations {
         request,
         timeoutMs,
         signal,
-        metadata
+        metadata,
+        onAdmitted
       )
     );
   }
@@ -419,7 +432,8 @@ export class ZLinkChannelOutboundOperations {
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     let correlationId: string | undefined;
     let router: ReturnType<ZLinkChannelSocketRegistry['routeRouter']> | undefined;
@@ -471,7 +485,7 @@ export class ZLinkChannelOutboundOperations {
       });
       const reply = await this.measureRequest(routerChannelId, async () => {
         const replyParts = await awaitWithAbort(
-          router!.request(targetNodeRid, parts, timeoutMs),
+          router!.request(targetNodeRid, parts, timeoutMs, onAdmitted),
           signal
         );
         try {

package/src/runtime/channels/channel-receive-loops.ts

@@ -359,7 +359,7 @@ export class ZLinkChannelReceiveLoop {
 
   private async acquirePermit(signal: AbortSignal): Promise<ApplicationJobQueuePermit | undefined> {
     try {
-      return await this.applicationJobQueue.acquire(signal);
+      return await this.applicationJobQueue.acquire(signal, 'remote');
     } catch (error) {
       if (this.isStopped() || signal.aborted) return undefined;
       throw error;
@@ -585,7 +585,7 @@ export class ZLinkSubscriberReceiveLoop {
 
   private async acquirePermit(signal: AbortSignal): Promise<ApplicationJobQueuePermit | undefined> {
     try {
-      return await this.applicationJobQueue.acquire(signal);
+      return await this.applicationJobQueue.acquire(signal, 'remote');
     } catch (error) {
       if (this.isStopped() || signal.aborted) return undefined;
       throw error;
@@ -795,7 +795,7 @@ export class ZLinkRouteReceiveLoop {
 
   private async acquirePermit(signal: AbortSignal): Promise<ApplicationJobQueuePermit | undefined> {
     try {
-      return await this.applicationJobQueue.acquire(signal);
+      return await this.applicationJobQueue.acquire(signal, 'remote');
     } catch (error) {
       if (this.isStopped() || signal.aborted) return undefined;
       throw error;