@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -1,11 +1,11 @@
 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 { randomBytes } from 'node:crypto';
 import { isUtf8 } from 'node:buffer';
 import {
   ZLinkFrameworkErrorKind,
   ZLinkFrameworkException,
-  ZLinkEncodedPayload,
   type ZLinkMessageSerializer,
   type ZLinkFlowOrigin
 } from '../../contracts';
@@ -17,7 +17,10 @@ import {
   createInternalFrameworkException
 } from '../framework-errors-internal';
 import { resolveFrameworkPacketName } from '../messaging/packet-name';
-import { selectSerializerWithContentType } from '../messaging/payload-codec';
+import {
+  encodedPayloadFromOwned,
+  selectSerializerWithContentType
+} from '../messaging/payload-codec';
 import { isCanonicalCodecContentType } from '../../contracts/Configuration/CodecContentType';
 import { parseFrameworkJsonV1, stringifyFrameworkJsonV1 } from '../messaging/framework-json-v1';
 import { currentOrCreateFlow } from '../diagnostics/flow-context';
@@ -70,8 +73,46 @@ export interface ZLinkChannelEnvelopeCodecRegistry {
   readonly serializers: ReadonlyMap<string, ZLinkMessageSerializer>;
 }
 
+interface PreparedChannelHeader {
+  readonly bytes: Buffer;
+  readonly correlationOffset: number;
+  readonly deadlineOffset: number;
+  readonly flowOffset: number;
+}
+
+/** Per kind, deadline presence and flow origin (`undefined` when the header carries no flow). */
+type PreparedHeaderVariants = Map<
+  ZLinkChannelMessageKind,
+  Map<boolean, Map<ZLinkFlowOrigin | undefined, 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}$/;
+const CHANNEL_FLOW_FIELD = ',"flowId":';
+// A flow id is a lowercase UUIDv7 (spec 27 §3): fixed 36 JSON-safe ASCII bytes.
+const PREPARED_CHANNEL_FLOW = '00000000-0000-7000-8000-000000000000';
+const CHANNEL_FLOW_TEXT = /^[0-9a-f-]{36}$/;
+
+// A per-process random 64-bit prefix followed by a per-process counter, both
+// as lowercase hex: unique among the runtime's pending requests (spec 06-obs/04
+// §3) without drawing random bytes for every request — the shape Java
+// ZLinkServiceOperationIds uses.
+const CHANNEL_CORRELATION_PREFIX = randomBytes(CHANNEL_CORRELATION_TEXT_LENGTH / 4).toString('hex');
+let channelCorrelationCounter = 0;
+
 export function newChannelCorrelationId(): string {
-  return randomUUID().replaceAll('-', '');
+  channelCorrelationCounter += 1;
+  return (
+    CHANNEL_CORRELATION_PREFIX +
+    channelCorrelationCounter.toString(16).padStart(CHANNEL_CORRELATION_TEXT_LENGTH / 2, '0')
+  );
 }
 
 export function encodeChannelEnvelopeParts(
@@ -147,7 +188,8 @@ export function encodeChannelEnvelopePartsAtDeadline(
       undefined,
       applicationMetadataRecord(metadata),
       flow?.flowId,
-      flow?.flowOrigin
+      flow?.flowOrigin,
+      codecs
     ),
     encoded.message
   ];
@@ -215,7 +257,8 @@ export function encodeChannelReplyParts(
       undefined,
       EMPTY_APPLICATION_METADATA,
       request.flowId,
-      request.flowOrigin
+      request.flowOrigin,
+      codecs
     ),
     encoded.message
   ];
@@ -255,6 +298,10 @@ const ERROR_KIND_BY_WIRE_NAME: ReadonlyMap<string, ZLinkFrameworkErrorKind> = ne
   ERROR_KIND_WIRE_NAMES.map((name, kind) => [name, kind as ZLinkFrameworkErrorKind])
 );
 
+export function channelErrorKindFromCode(code: string): ZLinkFrameworkErrorKind | undefined {
+  return ERROR_KIND_BY_WIRE_NAME.get(code);
+}
+
 export function channelErrorCodeName(kind: ZLinkFrameworkErrorKind): string {
   return ERROR_KIND_WIRE_NAMES[kind] ?? 'internal_failure';
 }
@@ -325,11 +372,11 @@ 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>(
-      ZLinkEncodedPayload.from(parts[1].data()),
+      encodedPayloadFromOwned(parts[1].data()),
       Object as never
     );
   }
@@ -352,7 +399,7 @@ function decodeChannelError(header: ZLinkChannelEnvelopeHeader): ZLinkChannelDec
     //  Cross-language contract: errorCode carries the snake_case wire name.
     //  An unknown name degrades to InternalFailure, matching the C++
     //  request_failure_mapper fallback for unrecognized codes.
-    const publicKind = ERROR_KIND_BY_WIRE_NAME.get(code) ?? ZLinkFrameworkErrorKind.InternalFailure;
+    const publicKind = channelErrorKindFromCode(code) ?? ZLinkFrameworkErrorKind.InternalFailure;
     failure = new ZLinkFrameworkException(publicKind, message);
   }
   //  Cross-language contract (.NET ZLinkErrorOriginWire.RemoteReplyOrigin /
@@ -403,7 +450,7 @@ export function decodeChannelPayload(
     }
     const serializer = codecs?.serializers.get(envelope.header.contentType);
     if (serializer !== undefined) {
-      return serializer.deserialize(ZLinkEncodedPayload.from(envelope.payload), Object as never);
+      return serializer.deserialize(encodedPayloadFromOwned(envelope.payload), Object as never);
     }
     if (envelope.header.contentType === BINARY_CONTENT_TYPE) {
       // The receive loop owns the Message for the duration of dispatch, so
@@ -517,8 +564,50 @@ 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
+      : flowOrigin !== undefined && CHANNEL_FLOW_TEXT.test(flowId)) &&
+    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,
+      flowId,
+      flowOrigin
+    );
+  }
   // 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 +649,76 @@ 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,
+  flowId: string | undefined,
+  flowOrigin: ZLinkFlowOrigin | 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 flows = deadlines.get(hasDeadline);
+  if (flows === undefined) deadlines.set(hasDeadline, (flows = new Map()));
+  let prepared = flows.get(flowOrigin);
+  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,
+      flowOrigin === undefined ? undefined : PREPARED_CHANNEL_FLOW,
+      flowOrigin
+    );
+    prepared = {
+      bytes,
+      correlationOffset:
+        bytes.indexOf(CHANNEL_CORRELATION_FIELD) + CHANNEL_CORRELATION_FIELD.length + 1,
+      deadlineOffset: bytes.indexOf(CHANNEL_DEADLINE_FIELD) + CHANNEL_DEADLINE_FIELD.length + 1,
+      flowOffset: bytes.indexOf(CHANNEL_FLOW_FIELD) + CHANNEL_FLOW_FIELD.length + 1
+    };
+    flows.set(flowOrigin, prepared);
+  }
+  if (correlationId === null && flowId === undefined) return prepared.bytes;
+  const bytes = Buffer.allocUnsafe(prepared.bytes.byteLength);
+  prepared.bytes.copy(bytes);
+  if (correlationId !== null)
+    bytes.write(
+      correlationId,
+      prepared.correlationOffset,
+      CHANNEL_CORRELATION_TEXT_LENGTH,
+      'ascii'
+    );
+  if (deadline !== null)
+    bytes.write(deadline, prepared.deadlineOffset, PREPARED_CHANNEL_DEADLINE.length, 'ascii');
+  if (flowId !== undefined)
+    bytes.write(flowId, prepared.flowOffset, PREPARED_CHANNEL_FLOW.length, 'ascii');
+  return bytes;
+}
+
 function writeChannelHeader(
   writer: ChannelHeaderWriter,
   kind: ZLinkChannelMessageKind,
@@ -586,9 +745,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);
@@ -742,13 +901,18 @@ function parseWireJson(payload: string, schema?: ZLinkJsonSchema): unknown {
 }
 
 function parseChannelHeaderBytes(payload: Buffer): unknown {
+  const reader = new CanonicalChannelHeaderReader(payload);
+  const canonical = tryParseCanonicalChannelHeader(reader);
+  // An all-ASCII canonical header is valid UTF-8 by construction; any other
+  // header is checked before it is decoded.
+  if (canonical !== undefined && !reader.sawNonAscii) return canonical;
   if (!isUtf8(payload)) {
     throw new ZLinkFrameworkException(
       ZLinkFrameworkErrorKind.ProtocolError,
       'Channel envelope header must contain valid UTF-8.'
     );
   }
-  return tryParseCanonicalChannelHeader(payload) ?? parseFrameworkJsonV1(payload.toString());
+  return canonical ?? parseFrameworkJsonV1(payload.toString());
 }
 
 /**
@@ -757,8 +921,9 @@ function parseChannelHeaderBytes(payload: Buffer): unknown {
  * framework-json-v1 parser, which remains the sole authority for JSON
  * failures and unknown properties. Header metadata accepts every valid string key.
  */
-function tryParseCanonicalChannelHeader(payload: Buffer): Record<string, unknown> | undefined {
-  const reader = new CanonicalChannelHeaderReader(payload);
+function tryParseCanonicalChannelHeader(
+  reader: CanonicalChannelHeaderReader
+): Record<string, unknown> | undefined {
   if (!reader.consume('{"formatMarker":242,"kind":')) return undefined;
   const kind = reader.readSingleDigit();
   if (kind === undefined || !reader.consume(',"channelName":')) return undefined;
@@ -785,20 +950,31 @@ function tryParseCanonicalChannelHeader(payload: Buffer): Record<string, unknown
     deadline: deadline === NULL_JSON_STRING ? null : deadline,
     topic: topic === NULL_JSON_STRING ? null : topic
   };
-  if (!reader.readOptionalNullableString('errorCode', header)) return undefined;
-  if (!reader.readOptionalNullableString('errorMessage', header)) return undefined;
-  if (!reader.readOptionalNullableString('source', header)) return undefined;
+  if (!reader.readOptionalNullableString(CANONICAL_ERROR_CODE, 'errorCode', header))
+    return undefined;
+  if (!reader.readOptionalNullableString(CANONICAL_ERROR_MESSAGE, 'errorMessage', header))
+    return undefined;
+  if (!reader.readOptionalNullableString(CANONICAL_SOURCE, 'source', header)) return undefined;
+  // Empty metadata validates to the shared empty record.
   if (!reader.consume(',"metadata":{}')) return undefined;
-  header.metadata = {};
-  if (!reader.readOptionalString('flowId', header)) return undefined;
-  if (!reader.readOptionalSingleDigit('flowOrigin', header)) return undefined;
+  if (!reader.readOptionalString(CANONICAL_FLOW_ID, 'flowId', header)) return undefined;
+  if (!reader.readOptionalSingleDigit(CANONICAL_FLOW_ORIGIN, 'flowOrigin', header))
+    return undefined;
   return reader.consume('}') && reader.atEnd() ? header : undefined;
 }
 
+const CANONICAL_ERROR_CODE = ',"errorCode":';
+const CANONICAL_ERROR_MESSAGE = ',"errorMessage":';
+const CANONICAL_SOURCE = ',"source":';
+const CANONICAL_FLOW_ID = ',"flowId":';
+const CANONICAL_FLOW_ORIGIN = ',"flowOrigin":';
+
 const NULL_JSON_STRING = Symbol('null JSON string');
 
 class CanonicalChannelHeaderReader {
   private index = 0;
+  /** A string held a byte outside ASCII, so the caller must still check UTF-8. */
+  sawNonAscii = false;
 
   constructor(private readonly bytes: Buffer) {}
 
@@ -827,13 +1003,19 @@ class CanonicalChannelHeaderReader {
     if (this.bytes[this.index] !== 0x22) return undefined;
     const start = this.index;
     this.index += 1;
+    let hasEscape = false;
     while (this.index < this.bytes.length) {
       const value = this.bytes[this.index++]!;
       if (value === 0x22) {
-        return JSON.parse(this.bytes.toString('utf8', start, this.index)) as string;
+        // Without escapes the JSON string is its own bytes; decode them once.
+        return hasEscape
+          ? (JSON.parse(this.bytes.toString('utf8', start, this.index)) as string)
+          : this.bytes.toString(this.sawNonAscii ? 'utf8' : 'latin1', start + 1, this.index - 1);
       }
       if (value < 0x20) return undefined;
+      if (value >= 0x80) this.sawNonAscii = true;
       if (value !== 0x5c) continue;
+      hasEscape = true;
       if (this.index === this.bytes.length) return undefined;
       const escaped = this.bytes[this.index++]!;
       if (escaped === 0x75) {
@@ -863,24 +1045,28 @@ class CanonicalChannelHeaderReader {
     return this.readString();
   }
 
-  readOptionalNullableString(name: string, target: Record<string, unknown>): boolean {
-    if (!this.consume(`,\"${name}\":`)) return true;
+  readOptionalNullableString(
+    token: string,
+    name: string,
+    target: Record<string, unknown>
+  ): boolean {
+    if (!this.consume(token)) return true;
     const value = this.readNullableString();
     if (value === undefined) return false;
     target[name] = value === NULL_JSON_STRING ? null : value;
     return true;
   }
 
-  readOptionalString(name: string, target: Record<string, unknown>): boolean {
-    if (!this.consume(`,\"${name}\":`)) return true;
+  readOptionalString(token: string, name: string, target: Record<string, unknown>): boolean {
+    if (!this.consume(token)) return true;
     const value = this.readString();
     if (value === undefined) return false;
     target[name] = value;
     return true;
   }
 
-  readOptionalSingleDigit(name: string, target: Record<string, unknown>): boolean {
-    if (!this.consume(`,\"${name}\":`)) return true;
+  readOptionalSingleDigit(token: string, name: string, target: Record<string, unknown>): boolean {
+    if (!this.consume(token)) return true;
     const value = this.readSingleDigit();
     if (value === undefined) return false;
     target[name] = value;
@@ -994,9 +1180,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-runtime-lifecycle.ts

@@ -1,3 +1,4 @@
+import type { ZLinkMeshDispatchAdmission } from '../admission';
 import { RuntimeDisposal } from '../disposal';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { ZLinkRequestHandler, ZLinkSendHandler } from '../../contracts/Handlers';
@@ -50,12 +51,9 @@ import {
   endpointConnections
 } from '../../contracts/Configuration/RuntimeEndpointConnections';
 import type { ApplicationJobQueue } from '../host/application-job-queue';
-import { AsyncResource } from 'node:async_hooks';
-import { ZLinkStateLane } from '../execution/state-lane';
+import { startOutsideStateLane, ZLinkStateLane } from '../execution/state-lane';
 import { ZLinkSerialExecutionQueue } from '../execution/serial-execution-queue';
 
-const detachedStateLaneResource = new AsyncResource('zlink:channel-runtime-lifecycle');
-
 interface ManualFanoutSubscriberState {
   readonly channelName: string;
   readonly endpoint: string;
@@ -349,8 +347,9 @@ export class ZLinkChannelRuntimeLifecycle {
   dispatchMeshChannel(
     meshName: string,
     record: ReceiveRecord,
-    signal?: AbortSignal
-  ): Promise<void> {
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
     const channelName = record.channelName;
     if (channelName === null) {
       throw new ZLinkConfigurationException('MeshNode channel record is missing channelName.');
@@ -361,17 +360,22 @@ export class ZLinkChannelRuntimeLifecycle {
         `RouteMesh '${meshName}' channel '${channelName}' has no registered handlers.`
       );
     }
-    return dispatcher.dispatchMesh(record, signal);
+    return dispatcher.dispatchMesh(record, signal, admit);
   }
 
-  dispatchMeshRoute(meshName: string, record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
+  dispatchMeshRoute(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
     const dispatcher = this.meshRouteDispatchers.get(meshName);
     if (dispatcher === undefined) {
       throw new ZLinkConfigurationException(
         `RouteMesh '${meshName}' has no registered node-direct handlers.`
       );
     }
-    return dispatcher.dispatchMesh(record, signal);
+    return dispatcher.dispatchMesh(record, signal, admit);
   }
 
   dispatchLocalMeshRoute(
@@ -1060,7 +1064,3 @@ function hasFanoutLocationTopology(registration: ZLinkFrameworkRegistration): bo
   }
   return false;
 }
-
-function startOutsideStateLane<T>(work: () => T): T {
-  return detachedStateLaneResource.runInAsyncScope(work);
-}