@zlink-systems/framework 0.30.1 → 0.30.2

package/dist/runtime/channels/channel-clients.js

@@ -81,6 +81,7 @@ class DefaultZLinkRouteClient {
     spotRouterChannelIdForMesh;
     channelTransport;
     nodeSends = new Map();
+    nodeRequests = new Map();
     constructor(registration, transport, spotRouterChannelIdForMesh = (meshName) => meshName, channelTransport) {
         this.registration = registration;
         this.transport = transport;
@@ -104,7 +105,18 @@ class DefaultZLinkRouteClient {
         return new DefaultZLinkSendCall(prepared.validate, prepared.submit, message);
     }
     requestToNode(meshName, targetNodeRid, request) {
-        return new DefaultZLinkRequestCall(() => this.requireMesh(meshName), (packetName, timeoutMs, metadata, signal, onAdmitted) => this.requireTransport().request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted), this.defaultRequestTimeout(meshName));
+        let targets = this.nodeRequests.get(meshName);
+        if (targets === undefined)
+            this.nodeRequests.set(meshName, (targets = new Map()));
+        let prepared = targets.get(targetNodeRid);
+        if (prepared === undefined) {
+            prepared = {
+                validate: () => this.requireMesh(meshName),
+                submit: (packetName, timeoutMs, metadata, signal, onAdmitted, message) => this.requireTransport().request(meshName, targetNodeRid, packetName, message, timeoutMs, signal, metadata, onAdmitted)
+            };
+            targets.set(targetNodeRid, prepared);
+        }
+        return new DefaultZLinkRequestCall(prepared.validate, prepared.submit, this.defaultRequestTimeout(meshName), request);
     }
     sendToChannel(channelName, message) {
         return new DefaultZLinkSendCall(() => this.requireChannelRoute(channelName), async (packetName, metadata) => {
@@ -289,13 +301,16 @@ class DefaultZLinkRequestCall {
     validate;
     submitter;
     defaultRequestTimeoutMs;
+    message;
     timeoutMs;
     selectedMetadata;
     turn = (0, execution_1.captureZLinkSpotSerialTurn)();
-    constructor(validate, submitter, defaultRequestTimeoutMs) {
+    /** `message` is the request payload a prepared submitter receives per call. */
+    constructor(validate, submitter, defaultRequestTimeoutMs, message) {
         this.validate = validate;
         this.submitter = submitter;
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
+        this.message = message;
     }
     metadata(keyOrMetadata, value) {
         this.selectedMetadata ??= new Map();
@@ -317,15 +332,15 @@ class DefaultZLinkRequestCall {
         return (0, request_result_1.createZLinkRequest)((onAdmitted) => {
             (0, abort_1.throwIfAborted)(signal);
             this.validate();
-            return this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata === undefined ? EMPTY_CALL_METADATA : new Map(this.selectedMetadata), signal, onAdmitted);
+            return this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata === undefined ? EMPTY_CALL_METADATA : new Map(this.selectedMetadata), signal, onAdmitted, this.message);
         });
     }
     async yield(signal) {
         const turn = (0, execution_1.requireZLinkYieldTurn)(this.turn);
         (0, abort_1.throwIfAborted)(signal);
         this.validate();
-        const pending = this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata === undefined ? EMPTY_CALL_METADATA : new Map(this.selectedMetadata), signal);
-        return turn.yieldPromise(pending);
+        const pending = this.submitter(undefined, this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata === undefined ? EMPTY_CALL_METADATA : new Map(this.selectedMetadata), signal, undefined, this.message);
+        return turn.yieldFrameworkPromise(pending);
     }
 }
 class DefaultZLinkPublishCall {

package/dist/runtime/channels/channel-dispatch-pipeline.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type { ZLinkMessageContext, ZLinkHandlerFilter, ZLinkUnhandledDispatchOptions, ZLinkFlowOrigin } from '../../contracts';
 import { ZLinkFrameworkException } from '../../contracts';
 import { ZLinkDispatchMessageKind, ZLinkDispatchErrorSurface } from '../../contracts/Dispatch/ZLinkDispatchOptions';
@@ -31,7 +32,7 @@ interface ZLinkOneWayDispatch<TContext extends ZLinkMessageContext> {
     readonly context: TContext;
     readonly signal?: AbortSignal;
 }
-interface ZLinkRequestDispatch<TContext extends ZLinkMessageContext> {
+export interface ZLinkRequestDispatch<TContext extends ZLinkMessageContext> {
     readonly fields: ZLinkChannelDispatchFields;
     readonly envelope: ZLinkChannelEnvelope;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
@@ -47,8 +48,26 @@ export declare class ZLinkChannelDispatchPipeline {
     private readonly filters;
     private readonly unhandled;
     constructor(options: ZLinkChannelDispatchPipelineOptions);
-    dispatchOneWay<TContext extends ZLinkMessageContext>(dispatch: ZLinkOneWayDispatch<TContext>): Promise<void>;
-    dispatchRequest<TContext extends ZLinkMessageContext>(dispatch: ZLinkRequestDispatch<TContext>): Promise<void>;
+    /**
+     * Runs the handler in the caller's execution turn. A synchronous handler
+     * completes here; an asynchronous handler adds exactly one continuation
+     * for its terminal trace or error record.
+     */
+    dispatchOneWay<TContext extends ZLinkMessageContext>(dispatch: ZLinkOneWayDispatch<TContext>, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
+    private dispatchMissingOneWay;
+    private completeOneWay;
+    private failOneWay;
+    /**
+     * Runs the handler in the caller's execution turn and writes its reply in
+     * the same turn when the handler completes synchronously. An asynchronous
+     * handler adds exactly one continuation that writes the reply.
+     */
+    dispatchRequest<TContext extends ZLinkMessageContext>(dispatch: ZLinkRequestDispatch<TContext>, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
+    private dispatchMissingRequest;
+    private invokeInFlow;
+    private completeRequest;
+    private replyPathMissing;
+    private failRequest;
     dropMissingReplyPath(fields: ZLinkChannelDispatchFields): void;
     /**
      * Terminal handling for an envelope that failed structural decoding.

package/dist/runtime/channels/channel-dispatch-pipeline.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelDispatchPipeline = void 0;
 const framework_errors_internal_1 = require("../framework-errors-internal");
+const abort_1 = require("../abort");
 const contracts_1 = require("../../contracts");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const handlers_1 = require("../handlers");
@@ -17,81 +18,126 @@ class ZLinkChannelDispatchPipeline {
         this.filters = options.filters ?? [];
         this.unhandled = options.unhandled ?? DEFAULT_UNHANDLED_DISPATCH;
     }
-    async dispatchOneWay(dispatch) {
+    /**
+     * Runs the handler in the caller's execution turn. A synchronous handler
+     * completes here; an asynchronous handler adds exactly one continuation
+     * for its terminal trace or error record.
+     */
+    dispatchOneWay(dispatch, admit) {
+        if (admit !== undefined) {
+            const pipeline = this;
+            const record = dispatch;
+            return admit(() => pipeline.dispatchOneWay(record), (error) => pipeline.failOneWay(record.fields, error));
+        }
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received, dispatch.fields);
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Admitted, dispatch.fields);
-        if (dispatch.handler === undefined) {
-            const action = dispatch.fields.messageKind === ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Publish
-                ? this.unhandled.publish
-                : this.unhandled.send;
-            this.report(dispatch.fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerMissing, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop);
-            this.applyOneWayUnhandled(action, dispatch.fields);
-            return;
-        }
+        if (dispatch.handler === undefined)
+            return this.dispatchMissingOneWay(dispatch.fields);
+        let invocation;
         try {
-            const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled(), undefined);
-            const invocation = await (flow === undefined
-                ? this.invoke(dispatch.envelope, dispatch.codecs, dispatch.handler, dispatch.context, dispatch.fields, dispatch.signal)
-                : (0, flow_context_1.runWithFlow)(flow, () => this.invoke(dispatch.envelope, dispatch.codecs, dispatch.handler, dispatch.context, dispatch.fields, dispatch.signal)));
-            if (invocation !== HANDLER_FILTER_REJECTED) {
-                this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed, dispatch.fields);
-            }
+            invocation = this.invokeInFlow(dispatch, dispatch.handler);
         }
         catch (error) {
-            this.report(dispatch.fields, this.failureReason(error), ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop, error);
+            this.failOneWay(dispatch.fields, error);
+            return;
+        }
+        if (!(0, abort_1.isPromiseLike)(invocation)) {
+            this.completeOneWay(dispatch.fields, invocation);
+            return;
+        }
+        return Promise.resolve(invocation).then((value) => this.completeOneWay(dispatch.fields, value), (error) => this.failOneWay(dispatch.fields, error));
+    }
+    async dispatchMissingOneWay(fields) {
+        const action = fields.messageKind === ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Publish
+            ? this.unhandled.publish
+            : this.unhandled.send;
+        this.report(fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerMissing, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop);
+        this.applyOneWayUnhandled(action, fields);
+    }
+    completeOneWay(fields, invocation) {
+        if (invocation !== HANDLER_FILTER_REJECTED) {
+            this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed, fields);
         }
     }
-    async dispatchRequest(dispatch) {
+    failOneWay(fields, error) {
+        this.report(fields, this.failureReason(error), ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop, error);
+    }
+    /**
+     * Runs the handler in the caller's execution turn and writes its reply in
+     * the same turn when the handler completes synchronously. An asynchronous
+     * handler adds exactly one continuation that writes the reply.
+     */
+    dispatchRequest(dispatch, admit) {
+        if (admit !== undefined) {
+            const pipeline = this;
+            const record = dispatch;
+            return admit(() => pipeline.dispatchRequest(record), (error) => pipeline.failRequest(record, error));
+        }
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received, dispatch.fields);
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Admitted, dispatch.fields);
-        if (dispatch.handler === undefined) {
-            const missing = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.HandlerNotFound, dispatch.missingHandlerMessage);
-            if (this.unhandled.request === contracts_1.ZLinkUnhandledDispatchAction.ReplyError) {
-                await dispatch.writeError(missing);
-            }
-            this.report(dispatch.fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerMissing, this.unhandled.request === contracts_1.ZLinkUnhandledDispatchAction.ReplyError
-                ? ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError
-                : ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop);
-            if (this.unhandled.request === contracts_1.ZLinkUnhandledDispatchAction.Throw) {
-                throw missing;
-            }
-            return;
+        if (dispatch.handler === undefined)
+            return this.dispatchMissingRequest(dispatch);
+        let invocation;
+        try {
+            invocation = this.invokeInFlow(dispatch, dispatch.handler);
         }
-        let reply;
+        catch (error) {
+            return this.failRequest(dispatch, error);
+        }
+        if (!(0, abort_1.isPromiseLike)(invocation))
+            return this.completeRequest(dispatch, invocation);
+        return Promise.resolve(invocation).then((value) => this.completeRequest(dispatch, value), (error) => this.failRequest(dispatch, error));
+    }
+    async dispatchMissingRequest(dispatch) {
+        const missing = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.HandlerNotFound, dispatch.missingHandlerMessage);
+        if (this.unhandled.request === contracts_1.ZLinkUnhandledDispatchAction.ReplyError) {
+            await dispatch.writeError(missing);
+        }
+        this.report(dispatch.fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerMissing, this.unhandled.request === contracts_1.ZLinkUnhandledDispatchAction.ReplyError
+            ? ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError
+            : ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop);
+        if (this.unhandled.request === contracts_1.ZLinkUnhandledDispatchAction.Throw) {
+            throw missing;
+        }
+    }
+    invokeInFlow(dispatch, handler) {
+        const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled(), undefined);
+        return flow === undefined
+            ? this.invoke(dispatch.envelope, dispatch.codecs, handler, dispatch.context, dispatch.fields, dispatch.signal)
+            : (0, flow_context_1.runWithFlow)(flow, () => this.invoke(dispatch.envelope, dispatch.codecs, handler, dispatch.context, dispatch.fields, dispatch.signal));
+    }
+    completeRequest(dispatch, invocation) {
+        if (invocation === HANDLER_FILTER_REJECTED) {
+            return this.failRequest(dispatch, (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `A handler filter rejected '${this.options.channelName}:${dispatch.fields.packetName}'.`));
+        }
+        let written;
         try {
-            const flow = (0, flow_context_1.createInboundFlow)(dispatch.fields.flowId, dispatch.fields.flowOrigin, this.options.dispatchErrors.flow.flowCreationEnabled(), undefined);
-            const invocation = await (flow === undefined
-                ? this.invoke(dispatch.envelope, dispatch.codecs, dispatch.handler, dispatch.context, dispatch.fields, dispatch.signal)
-                : (0, flow_context_1.runWithFlow)(flow, () => this.invoke(dispatch.envelope, dispatch.codecs, dispatch.handler, dispatch.context, dispatch.fields, dispatch.signal)));
-            if (invocation === HANDLER_FILTER_REJECTED) {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `A handler filter rejected '${this.options.channelName}:${dispatch.fields.packetName}'.`);
-            }
-            reply = invocation;
+            written = dispatch.writeReply(invocation);
         }
         catch (error) {
-            try {
-                await dispatch.writeError(error);
-            }
-            catch (replyError) {
-                // Spec 26 §3.1: a failed reply write means the reply delivery path is
-                // gone; `unexpected_reply` names a surplus/late reply instead.
-                this.report(dispatch.fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.ReplyPathMissing, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop, replyError);
-                return;
-            }
-            this.report(dispatch.fields, this.failureReason(error), ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError, error);
+            this.replyPathMissing(dispatch.fields, error);
             return;
         }
-        try {
-            const written = dispatch.writeReply(reply);
-            if (written !== undefined)
-                await written;
+        if (written === undefined) {
             this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, dispatch.fields);
+            return;
         }
-        catch (error) {
-            // Spec 26 §3.1: a failed reply write means the reply delivery path is
-            // gone; `unexpected_reply` names a surplus/late reply instead.
-            this.report(dispatch.fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.ReplyPathMissing, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop, error);
+        return written.then(() => this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, dispatch.fields), (error) => this.replyPathMissing(dispatch.fields, error));
+    }
+    replyPathMissing(fields, error) {
+        // Spec 26 §3.1: a failed reply write means the reply delivery path is
+        // gone; `unexpected_reply` names a surplus/late reply instead.
+        this.report(fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.ReplyPathMissing, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop, error);
+    }
+    async failRequest(dispatch, error) {
+        try {
+            await dispatch.writeError(error);
+        }
+        catch (replyError) {
+            this.replyPathMissing(dispatch.fields, replyError);
+            return;
         }
+        this.report(dispatch.fields, this.failureReason(error), ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError, error);
     }
     dropMissingReplyPath(fields) {
         this.report(fields, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.ReplyPathMissing, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop);

package/dist/runtime/channels/channel-dispatchers.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type { RoutingId, ZLinkMessageContext, ZLinkHandlerFilter, ZLinkPublishMessageContext, ZLinkRouteMessageContext, ZLinkUnhandledDispatchOptions } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import { type ReceiveRecord } from '../foundation/service-runtime-contracts';
@@ -54,7 +55,7 @@ export declare class ZLinkChannelRequestDispatcher {
     }, router: {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
     }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<boolean | void>;
-    dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void>;
+    dispatchMesh(record: ReceiveRecord, signal?: AbortSignal, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
     private submitReply;
     private createMeshContext;
 }
@@ -117,7 +118,7 @@ export declare class ZLinkRoutePacketDispatcher {
     }, router: {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
     }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean): Promise<boolean | void>;
-    dispatchMesh(record: ReceiveRecord, signal?: AbortSignal): Promise<void>;
+    dispatchMesh(record: ReceiveRecord, signal?: AbortSignal, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
     dispatchLocalCommand(parts: readonly Message[], sourceNodeRid: RoutingId, signal?: AbortSignal): Promise<void>;
     private dispatchMeshCommand;
     private submitReply;

package/dist/runtime/channels/channel-dispatchers.js

@@ -126,7 +126,7 @@ class ZLinkChannelRequestDispatcher {
             writeError: (error) => this.submitReply((0, channel_multipart_1.appendParts)(router.reply(received.routingId, replyToken), (0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error)), signal)
         });
     }
-    dispatchMesh(record, signal) {
+    dispatchMesh(record, signal, admit) {
         if (record.parts.length === 0 || record.parts[0].data().length === 0) {
             return completedChannelReply;
         }
@@ -165,7 +165,7 @@ class ZLinkChannelRequestDispatcher {
                 handler: this.options.sendHandlers?.get(packetName),
                 context: this.createMeshContext(envelope, record.sourceNodeRid),
                 signal
-            });
+            }, admit);
         }
         if (envelope.header.kind !== 1 /* ZLinkChannelMessageKind.Request */) {
             return completedChannelReply;
@@ -177,21 +177,7 @@ 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((0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, reply, this.options.codecs)));
-            },
-            writeError: (error) => {
-                requireMeshReplyAccepted(record.reply((0, channel_envelope_1.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);
     }
     submitReply(operation, signal) {
         void signal;
@@ -220,6 +206,42 @@ class ZLinkChannelRequestDispatcher {
     }
 }
 exports.ZLinkChannelRequestDispatcher = 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 {
+    fields;
+    envelope;
+    codecs;
+    handler;
+    context;
+    signal;
+    record;
+    handlerSurface;
+    channelName;
+    constructor(fields, envelope, codecs, handler, context, signal, record, handlerSurface, channelName) {
+        this.fields = fields;
+        this.envelope = envelope;
+        this.codecs = codecs;
+        this.handler = handler;
+        this.context = context;
+        this.signal = signal;
+        this.record = record;
+        this.handlerSurface = handlerSurface;
+        this.channelName = channelName;
+    }
+    get missingHandlerMessage() {
+        return `No ${this.handlerSurface} request handler is registered for '${this.channelName}:${this.fields.packetName}'.`;
+    }
+    writeReply(reply) {
+        requireMeshReplyAccepted(this.record.reply((0, channel_envelope_1.encodeChannelReplyParts)(this.envelope.header, reply, this.codecs)));
+    }
+    writeError(error) {
+        requireMeshReplyAccepted(this.record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(this.envelope.header, error)));
+    }
+}
 function requireMeshReplyAccepted(result) {
     if (result !== runtime_values_1.SubmitResult.Ok) {
         throw new configuration_1.ZLinkConfigurationException(`MeshNode channel reply was not accepted (submit result ${result}).`);
@@ -452,7 +474,7 @@ class ZLinkRoutePacketDispatcher {
             writeError: (error) => this.submitReply((0, channel_multipart_1.appendParts)(router.reply(received.routingId, replyToken), (0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error)))
         });
     }
-    dispatchMesh(record, signal) {
+    dispatchMesh(record, signal, admit) {
         if (record.parts.length === 0 || record.parts[0].data().length === 0) {
             return completedChannelReply;
         }
@@ -479,7 +501,7 @@ class ZLinkRoutePacketDispatcher {
         const sourceNodeRid = String(record.sourceNodeRid ?? '');
         const correlationId = envelope.header.correlationId ?? undefined;
         if (envelope.header.kind === 3 /* ZLinkChannelMessageKind.Command */) {
-            return this.dispatchMeshCommand(envelope, packetName, sourceNodeRid, record.sourceNodeRid, signal);
+            return this.dispatchMeshCommand(envelope, packetName, sourceNodeRid, record.sourceNodeRid, signal, admit);
         }
         if (envelope.header.kind !== 1 /* ZLinkChannelMessageKind.Request */) {
             return completedChannelReply;
@@ -492,22 +514,7 @@ class ZLinkRoutePacketDispatcher {
             flowId: envelope.header.flowId,
             flowOrigin: envelope.header.flowOrigin
         };
-        const codecs = (0, channel_framework_packets_1.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((0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, reply, codecs)));
-            },
-            writeError: (error) => {
-                requireMeshReplyAccepted(record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error)));
-            }
-        });
+        return this.pipeline.dispatchRequest(new ZLinkMeshRequestDispatch(fields, envelope, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.codecs), this.requestHandlers.get(packetName), this.createRouteContext(envelope, record.sourceNodeRid), signal, record, 'routed', this.routerChannelId), admit);
     }
     async dispatchLocalCommand(parts, sourceNodeRid, signal) {
         if (parts.length === 0 || parts[0].data().length === 0)
@@ -535,7 +542,7 @@ class ZLinkRoutePacketDispatcher {
         }
         await this.dispatchMeshCommand(envelope, packetName, String(sourceNodeRid), sourceNodeRid, signal);
     }
-    dispatchMeshCommand(envelope, packetName, sourceRid, sourceNodeRid, signal) {
+    dispatchMeshCommand(envelope, packetName, sourceRid, sourceNodeRid, signal, admit) {
         return this.pipeline.dispatchOneWay({
             fields: {
                 messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
@@ -550,7 +557,7 @@ class ZLinkRoutePacketDispatcher {
             handler: this.sendHandlers.get(packetName),
             context: this.createRouteContext(envelope, sourceNodeRid),
             signal
-        });
+        }, admit);
     }
     submitReply(operation) {
         if (operation.submit() === false) {

package/dist/runtime/channels/channel-envelope.d.ts

@@ -54,6 +54,7 @@ export declare function encodeChannelReplyParts(request: ZLinkChannelEnvelopeHea
  */
 export declare const ZLINK_FRAMEWORK_ORIGIN_METADATA_KEY = "zlink.origin";
 export declare const ZLINK_FRAMEWORK_ORIGIN_METADATA_VALUE = "framework";
+export declare function channelErrorKindFromCode(code: string): ZLinkFrameworkErrorKind | undefined;
 export declare function channelErrorCodeName(kind: ZLinkFrameworkErrorKind): string;
 /**
  * A channel error decoded from an Error reply envelope. `origin` carries the