@zlink-systems/framework 0.30.1 → 0.30.2

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

@@ -1,3 +1,4 @@
+import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type {
   RoutingId,
   ZLinkMessageContext,
@@ -40,7 +41,8 @@ import {
 import { codecsForFrameworkPacket } from './channel-framework-packets';
 import {
   ZLinkChannelDispatchPipeline,
-  type ZLinkChannelDispatchFields
+  type ZLinkChannelDispatchFields,
+  type ZLinkRequestDispatch
 } from './channel-dispatch-pipeline';
 
 export interface ZLinkChannelRequestDispatcherOptions {
@@ -238,7 +240,11 @@ export class ZLinkChannelRequestDispatcher {
     });
   }
 
-  dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
+  dispatchMesh(
+    record: ReceiveRecord,
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
     if (record.parts.length === 0 || record.parts[0].data().length === 0) {
       return completedChannelReply;
     }
@@ -270,20 +276,23 @@ export class ZLinkChannelRequestDispatcher {
     }
     const correlationId = envelope.header.correlationId ?? undefined;
     if (envelope.header.kind === ZLinkChannelMessageKind.Command) {
-      return this.pipeline.dispatchOneWay({
-        fields: {
-          messageKind: ZLinkDispatchMessageKind.Send,
-          packetName,
-          correlationId,
-          flowId: envelope.header.flowId,
-          flowOrigin: envelope.header.flowOrigin
+      return this.pipeline.dispatchOneWay(
+        {
+          fields: {
+            messageKind: ZLinkDispatchMessageKind.Send,
+            packetName,
+            correlationId,
+            flowId: envelope.header.flowId,
+            flowOrigin: envelope.header.flowOrigin
+          },
+          envelope,
+          codecs: this.options.codecs,
+          handler: this.options.sendHandlers?.get(packetName),
+          context: this.createMeshContext(envelope, record.sourceNodeRid),
+          signal
         },
-        envelope,
-        codecs: this.options.codecs,
-        handler: this.options.sendHandlers?.get(packetName),
-        context: this.createMeshContext(envelope, record.sourceNodeRid),
-        signal
-      });
+        admit
+      );
     }
     if (envelope.header.kind !== ZLinkChannelMessageKind.Request) {
       return completedChannelReply;
@@ -295,25 +304,20 @@ export class ZLinkChannelRequestDispatcher {
       flowId: envelope.header.flowId,
       flowOrigin: envelope.header.flowOrigin
     };
-    return this.pipeline.dispatchRequest({
-      fields,
-      envelope,
-      codecs: this.options.codecs,
-      handler: this.options.handlers.get(packetName),
-      context: this.createMeshContext(envelope, record.sourceNodeRid),
-      signal,
-      missingHandlerMessage: `No channel request handler is registered for '${this.options.channelName}:${packetName}'.`,
-      writeReply: (reply) => {
-        requireMeshReplyAccepted(
-          record.reply(encodeChannelReplyParts(envelope.header, reply, this.options.codecs))
-        );
-      },
-      writeError: (error) => {
-        requireMeshReplyAccepted(
-          record.reply(encodeChannelErrorReplyParts(envelope.header, error))
-        );
-      }
-    });
+    return this.pipeline.dispatchRequest(
+      new ZLinkMeshRequestDispatch(
+        fields,
+        envelope,
+        this.options.codecs,
+        this.options.handlers.get(packetName),
+        this.createMeshContext(envelope, record.sourceNodeRid),
+        signal,
+        record,
+        'channel',
+        this.options.channelName
+      ),
+      admit
+    );
   }
 
   private submitReply(
@@ -350,6 +354,43 @@ export class ZLinkChannelRequestDispatcher {
   }
 }
 
+/**
+ * One mesh request handed to the dispatch pipeline. The reply writers are
+ * methods over the received record instead of per-message closures, and the
+ * missing-handler text is built only when no handler exists.
+ */
+class ZLinkMeshRequestDispatch<
+  TContext extends ZLinkMessageContext
+> implements ZLinkRequestDispatch<TContext> {
+  constructor(
+    readonly fields: ZLinkChannelDispatchFields,
+    readonly envelope: ReturnType<typeof decodeChannelEnvelope>,
+    readonly codecs: ZLinkChannelEnvelopeCodecRegistry | undefined,
+    readonly handler: ZLinkRequestDispatch<TContext>['handler'],
+    readonly context: TContext,
+    readonly signal: AbortSignal | undefined,
+    private readonly record: ReceiveRecord,
+    private readonly handlerSurface: 'channel' | 'routed',
+    private readonly channelName: string
+  ) {}
+
+  get missingHandlerMessage(): string {
+    return `No ${this.handlerSurface} request handler is registered for '${this.channelName}:${this.fields.packetName}'.`;
+  }
+
+  writeReply(reply: unknown): void {
+    requireMeshReplyAccepted(
+      this.record.reply(encodeChannelReplyParts(this.envelope.header, reply, this.codecs))
+    );
+  }
+
+  writeError(error: unknown): void {
+    requireMeshReplyAccepted(
+      this.record.reply(encodeChannelErrorReplyParts(this.envelope.header, error))
+    );
+  }
+}
+
 function requireMeshReplyAccepted(result: number): void {
   if (result !== SubmitResult.Ok) {
     throw new ZLinkConfigurationException(
@@ -685,7 +726,11 @@ export class ZLinkRoutePacketDispatcher {
     });
   }
 
-  dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
+  dispatchMesh(
+    record: ReceiveRecord,
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
     if (record.parts.length === 0 || record.parts[0].data().length === 0) {
       return completedChannelReply;
     }
@@ -723,7 +768,8 @@ export class ZLinkRoutePacketDispatcher {
         packetName,
         sourceNodeRid,
         record.sourceNodeRid,
-        signal
+        signal,
+        admit
       );
     }
     if (envelope.header.kind !== ZLinkChannelMessageKind.Request) {
@@ -737,26 +783,20 @@ export class ZLinkRoutePacketDispatcher {
       flowId: envelope.header.flowId,
       flowOrigin: envelope.header.flowOrigin
     };
-    const codecs = codecsForFrameworkPacket(packetName, this.codecs);
-    return this.pipeline.dispatchRequest({
-      fields,
-      envelope,
-      codecs,
-      handler: this.requestHandlers.get(packetName),
-      context: this.createRouteContext(envelope, record.sourceNodeRid),
-      signal,
-      missingHandlerMessage: `No routed request handler is registered for '${this.routerChannelId}:${packetName}'.`,
-      writeReply: (reply) => {
-        requireMeshReplyAccepted(
-          record.reply(encodeChannelReplyParts(envelope.header, reply, codecs))
-        );
-      },
-      writeError: (error) => {
-        requireMeshReplyAccepted(
-          record.reply(encodeChannelErrorReplyParts(envelope.header, error))
-        );
-      }
-    });
+    return this.pipeline.dispatchRequest(
+      new ZLinkMeshRequestDispatch(
+        fields,
+        envelope,
+        codecsForFrameworkPacket(packetName, this.codecs),
+        this.requestHandlers.get(packetName),
+        this.createRouteContext(envelope, record.sourceNodeRid),
+        signal,
+        record,
+        'routed',
+        this.routerChannelId
+      ),
+      admit
+    );
   }
 
   async dispatchLocalCommand(
@@ -801,23 +841,27 @@ export class ZLinkRoutePacketDispatcher {
     packetName: string,
     sourceRid: string,
     sourceNodeRid: unknown,
-    signal?: AbortSignal
-  ): Promise<void> {
-    return this.pipeline.dispatchOneWay({
-      fields: {
-        messageKind: ZLinkDispatchMessageKind.Send,
-        packetName,
-        sourceRid,
-        correlationId: envelope.header.correlationId ?? undefined,
-        flowId: envelope.header.flowId,
-        flowOrigin: envelope.header.flowOrigin
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
+    return this.pipeline.dispatchOneWay(
+      {
+        fields: {
+          messageKind: ZLinkDispatchMessageKind.Send,
+          packetName,
+          sourceRid,
+          correlationId: envelope.header.correlationId ?? undefined,
+          flowId: envelope.header.flowId,
+          flowOrigin: envelope.header.flowOrigin
+        },
+        envelope,
+        codecs: codecsForFrameworkPacket(packetName, this.codecs),
+        handler: this.sendHandlers.get(packetName),
+        context: this.createRouteContext(envelope, sourceNodeRid),
+        signal
       },
-      envelope,
-      codecs: codecsForFrameworkPacket(packetName, this.codecs),
-      handler: this.sendHandlers.get(packetName),
-      context: this.createRouteContext(envelope, sourceNodeRid),
-      signal
-    });
+      admit
+    );
   }
 
   private submitReply(operation: ZLinkMultipartReplyOperation): Promise<void> {

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

@@ -1,12 +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';
@@ -18,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';
@@ -75,9 +77,14 @@ interface PreparedChannelHeader {
   readonly bytes: Buffer;
   readonly correlationOffset: number;
   readonly deadlineOffset: number;
+  readonly flowOffset: number;
 }
 
-type PreparedHeaderVariants = Map<ZLinkChannelMessageKind, Map<boolean, PreparedChannelHeader>>;
+/** 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>>>
@@ -88,9 +95,24 @@ 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(
@@ -276,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';
 }
@@ -350,7 +376,7 @@ export function decodeChannelReply<TReply>(
   }
   if (serializer !== undefined) {
     return serializer.deserialize<TReply>(
-      ZLinkEncodedPayload.from(parts[1].data()),
+      encodedPayloadFromOwned(parts[1].data()),
       Object as never
     );
   }
@@ -373,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 /
@@ -424,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
@@ -544,8 +570,9 @@ function encodeChannelHeader(
   if (
     codecs !== undefined &&
     metadata === EMPTY_APPLICATION_METADATA &&
-    flowId === undefined &&
-    flowOrigin === undefined &&
+    (flowId === undefined
+      ? flowOrigin === undefined
+      : flowOrigin !== undefined && CHANNEL_FLOW_TEXT.test(flowId)) &&
     topic === null &&
     source === undefined &&
     ((kind === ZLinkChannelMessageKind.Command &&
@@ -576,7 +603,9 @@ function encodeChannelHeader(
       correlationId,
       deadline,
       errorCode,
-      errorMessage
+      errorMessage,
+      flowId,
+      flowOrigin
     );
   }
   // The wire has a fixed field order. Measure escaped UTF-8 first, then write
@@ -629,7 +658,9 @@ function preparedChannelHeader(
   correlationId: string | null,
   deadline: string | null,
   errorCode: string | null | undefined,
-  errorMessage: string | null | undefined
+  errorMessage: string | null | undefined,
+  flowId: string | undefined,
+  flowOrigin: ZLinkFlowOrigin | undefined
 ): Buffer {
   let channels = preparedChannelHeaders.get(codecs.serializers);
   if (channels === undefined)
@@ -643,7 +674,9 @@ function preparedChannelHeader(
   let deadlines = kinds.get(kind);
   if (deadlines === undefined) kinds.set(kind, (deadlines = new Map()));
   const hasDeadline = deadline !== null;
-  let prepared = deadlines.get(hasDeadline);
+  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,
@@ -657,23 +690,32 @@ function preparedChannelHeader(
       errorMessage,
       undefined,
       EMPTY_APPLICATION_METADATA,
-      undefined,
-      undefined
+      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
+      deadlineOffset: bytes.indexOf(CHANNEL_DEADLINE_FIELD) + CHANNEL_DEADLINE_FIELD.length + 1,
+      flowOffset: bytes.indexOf(CHANNEL_FLOW_FIELD) + CHANNEL_FLOW_FIELD.length + 1
     };
-    deadlines.set(hasDeadline, prepared);
+    flows.set(flowOrigin, prepared);
   }
-  if (correlationId === null) return prepared.bytes;
-  const bytes = Buffer.alloc(prepared.bytes.byteLength);
+  if (correlationId === null && flowId === undefined) return prepared.bytes;
+  const bytes = Buffer.allocUnsafe(prepared.bytes.byteLength);
   prepared.bytes.copy(bytes);
-  bytes.write(correlationId, prepared.correlationOffset, CHANNEL_CORRELATION_TEXT_LENGTH, 'ascii');
+  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;
 }
 
@@ -859,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());
 }
 
 /**
@@ -874,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;
@@ -902,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) {}
 
@@ -944,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) {
@@ -980,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;

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);
-}

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

@@ -1,3 +1,4 @@
+import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { RoutingId } from '../../contracts';
@@ -207,13 +208,19 @@ export class ZLinkChannelRuntimeManager {
   dispatchMeshChannel(
     meshName: string,
     record: ReceiveRecord,
-    signal?: AbortSignal
-  ): Promise<void> {
-    return this.lifecycle.dispatchMeshChannel(meshName, record, signal);
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
+    return this.lifecycle.dispatchMeshChannel(meshName, record, signal, admit);
   }
 
-  dispatchMeshRoute(meshName: string, record: ReceiveRecord, signal?: AbortSignal): Promise<void> {
-    return this.lifecycle.dispatchMeshRoute(meshName, record, signal);
+  dispatchMeshRoute(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
+    return this.lifecycle.dispatchMeshRoute(meshName, record, signal, admit);
   }
 
   dispatchLocalMeshRoute(