@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/backend/raw-binding-port.d.ts

@@ -1,3 +1,5 @@
+import type { ConnectionAttempt } from '@zlink-systems/zlink';
+import type { OperationHandle } from '../foundation/operation-registry';
 import type { SubmitResult } from './runtime-values';
 export interface ZLinkRawSendSubmission {
     readonly result: typeof SubmitResult.Ok | typeof SubmitResult.Backpressured;
@@ -12,7 +14,7 @@ export interface ZLinkRawReceivedRecord {
      * record (Core ROUTER §10.1); 0n for a non-ROUTER receive. Equality only.
      */
     readonly routeGeneration: bigint;
-    readonly reply?: (parts: readonly Uint8Array[]) => void;
+    readonly reply?: (parts: readonly (Uint8Array | string)[]) => void;
     readonly parts: readonly Buffer[];
     /** Releases the ordinary Framework-owned receive record exactly once. */
     close(): void;
@@ -29,7 +31,7 @@ export interface ZLinkRawMonitorRecord {
     readonly flags?: number;
 }
 export interface ZLinkRawSocketPort {
-    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void;
+    setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void): void;
     bind(endpoint: string): void;
     unbind(endpoint: string): void;
     connect(endpoint: string): void;
@@ -56,10 +58,11 @@ export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
     setRoutingId(routingId: string): void;
     connectToRoutingId(routingId: string, endpoint: string): void;
     send(targetRid: string, parts: readonly Uint8Array[]): Promise<void>;
-    request(targetRid: string, parts: readonly Uint8Array[], timeoutMs: number, recordReceived?: () => void, onAdmitted?: () => void): Promise<readonly Buffer[]>;
+    request<T>(targetRid: string, parts: readonly Uint8Array[], timeoutMs: number, onReply: (parts: readonly Buffer[]) => T, onFailed: (error: unknown) => T, recordReceived?: () => void, onAdmitted?: () => void, existing?: Pick<OperationHandle<unknown>, 'id' | 'deadlineMs'>): Promise<T>;
     receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
     /** The selected route of every RID. The socket's one route observer calls it. */
     routesSnapshot(): readonly ZLinkRawRouterRoute[];
+    connectionAttemptsSnapshot(): readonly ConnectionAttempt[];
 }
 export interface ZLinkRawDealerPort extends ZLinkRawSocketPort {
     setRoutingId(routingId: string): void;

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

@@ -150,13 +150,13 @@ class DefaultZLinkRouteClient {
     requestToSpot(spot, request) {
         return new DefaultZLinkRequestCall(() => {
             this.requireSpotTransport();
-        }, (_packetName, timeoutMs, metadata, signal, onAdmitted) => (0, spot_outbound_1.requestToSpotHandle)(this.requireSpotTransport(), spot, request, {
+        }, (_packetName, timeoutMs, metadata, signal, onAdmitted) => (0, request_result_1.prepareZLinkRequestReply)((0, spot_outbound_1.requestToSpotHandle)(this.requireSpotTransport(), spot, request, {
             timeoutMs,
             signal,
             metadata,
             onAdmitted,
             spotRouterChannelIdForMesh: this.spotRouterChannelIdForMesh
-        }), this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
+        }), request_result_1.identityRequestReply), this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
     }
     defaultRequestTimeout(meshName) {
         return (this.registration.spotNodes.get(meshName)?.requestTimeoutMs ??
@@ -340,7 +340,7 @@ class DefaultZLinkRequestCall {
         (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, undefined, this.message);
-        return turn.yieldFrameworkPromise(pending);
+        return turn.yieldFrameworkPromise((0, request_result_1.mapZLinkRequestReply)(pending));
     }
 }
 class DefaultZLinkPublishCall {

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

@@ -1,7 +1,8 @@
+import type { ZLinkHandlerMessageType } from '../../contracts/Common/HandlerMessageType';
 import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type { ZLinkMessageContext, ZLinkHandlerFilter, ZLinkUnhandledDispatchOptions, ZLinkFlowOrigin } from '../../contracts';
 import { ZLinkFrameworkException } from '../../contracts';
-import { ZLinkDispatchMessageKind, ZLinkDispatchErrorSurface } from '../../contracts/Dispatch/ZLinkDispatchOptions';
+import { ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome, ZLinkDispatchMessageKind, ZLinkDispatchErrorSurface } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { type ZLinkChannelEnvelope, type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 import type { ZLinkMalformedChannelHeaderInfo } from './channel-envelope-inspection';
 import type { ZLinkDispatchErrorReporter } from './dispatch-error-reporter';
@@ -24,11 +25,12 @@ export interface ZLinkChannelDispatchFields {
 interface ZLinkChannelDispatchHandler<TContext extends ZLinkMessageContext, TResult> {
     handle(payload: unknown, context: TContext): Promise<TResult> | TResult;
 }
-interface ZLinkOneWayDispatch<TContext extends ZLinkMessageContext> {
+export interface ZLinkOneWayDispatch<TContext extends ZLinkMessageContext> {
     readonly fields: ZLinkChannelDispatchFields;
     readonly envelope: ZLinkChannelEnvelope;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
     readonly handler?: ZLinkChannelDispatchHandler<TContext, void>;
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly context: TContext;
     readonly signal?: AbortSignal;
 }
@@ -37,6 +39,7 @@ export interface ZLinkRequestDispatch<TContext extends ZLinkMessageContext> {
     readonly envelope: ZLinkChannelEnvelope;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
     readonly handler?: ZLinkChannelDispatchHandler<TContext, unknown>;
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly context: TContext;
     readonly signal?: AbortSignal;
     readonly missingHandlerMessage: string;
@@ -44,8 +47,8 @@ export interface ZLinkRequestDispatch<TContext extends ZLinkMessageContext> {
     readonly writeError: (error: unknown) => void | Promise<void>;
 }
 export declare class ZLinkChannelDispatchPipeline {
-    private readonly options;
-    private readonly filters;
+    readonly options: ZLinkChannelDispatchPipelineOptions;
+    readonly filters: readonly ZLinkHandlerFilter[];
     private readonly unhandled;
     constructor(options: ZLinkChannelDispatchPipelineOptions);
     /**
@@ -64,7 +67,7 @@ export declare class ZLinkChannelDispatchPipeline {
      */
     dispatchRequest<TContext extends ZLinkMessageContext>(dispatch: ZLinkRequestDispatch<TContext>, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
     private dispatchMissingRequest;
-    private invokeInFlow;
+    invokeInFlow<TContext extends ZLinkMessageContext, TResult>(dispatch: ZLinkOneWayDispatch<TContext> | ZLinkRequestDispatch<TContext>, handler: ZLinkChannelDispatchHandler<TContext, TResult>): unknown;
     private completeRequest;
     private replyPathMissing;
     private failRequest;
@@ -84,13 +87,14 @@ export declare class ZLinkChannelDispatchPipeline {
         readonly sourceRid?: string;
         readonly writeProtocolError?: (error: ZLinkFrameworkException) => Promise<void>;
     }): Promise<void>;
-    private invoke;
+    invoke<TContext extends ZLinkMessageContext, TResult>(dispatch: ZLinkOneWayDispatch<TContext> | ZLinkRequestDispatch<TContext>, handler: ZLinkChannelDispatchHandler<TContext, TResult>): TResult | undefined | typeof HANDLER_FILTER_REJECTED | Promise<TResult | undefined | typeof HANDLER_FILTER_REJECTED>;
     private invokeFiltered;
     private createFilterContext;
     private dispatchKind;
     private report;
-    private trace;
+    trace(outcome: ZLinkMessageFlowOutcome, fields: ZLinkChannelDispatchFields): void;
     private failureReason;
     private applyOneWayUnhandled;
 }
+declare const HANDLER_FILTER_REJECTED: unique symbol;
 export {};

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

@@ -9,6 +9,7 @@ const handlers_1 = require("../handlers");
 const channel_envelope_1 = require("./channel-envelope");
 const flow_context_1 = require("../diagnostics/flow-context");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
+const HandlerMessageType_1 = require("../../contracts/Common/HandlerMessageType");
 class ZLinkChannelDispatchPipeline {
     options;
     filters;
@@ -25,9 +26,7 @@ class ZLinkChannelDispatchPipeline {
      */
     dispatchOneWay(dispatch, admit) {
         if (admit !== undefined) {
-            const pipeline = this;
-            const record = dispatch;
-            return admit(() => pipeline.dispatchOneWay(record), (error) => pipeline.failOneWay(record.fields, error));
+            return admit(this.dispatchOneWay, this.failOneWay, this, dispatch);
         }
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received, dispatch.fields);
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Admitted, dispatch.fields);
@@ -38,14 +37,19 @@ class ZLinkChannelDispatchPipeline {
             invocation = this.invokeInFlow(dispatch, dispatch.handler);
         }
         catch (error) {
-            this.failOneWay(dispatch.fields, error);
+            this.failOneWay(error, dispatch);
             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));
+        {
+            // Keep captures block-scoped so synchronous dispatch allocates no V8 context.
+            const pipeline = this;
+            const record = dispatch;
+            return Promise.resolve(invocation).then((value) => pipeline.completeOneWay(record.fields, value), (error) => pipeline.failOneWay(error, record));
+        }
     }
     async dispatchMissingOneWay(fields) {
         const action = fields.messageKind === ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Publish
@@ -59,7 +63,8 @@ class ZLinkChannelDispatchPipeline {
             this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed, fields);
         }
     }
-    failOneWay(fields, error) {
+    failOneWay(error, dispatch) {
+        const fields = dispatch.fields;
         this.report(fields, this.failureReason(error), ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop, error);
     }
     /**
@@ -69,9 +74,7 @@ class ZLinkChannelDispatchPipeline {
      */
     dispatchRequest(dispatch, admit) {
         if (admit !== undefined) {
-            const pipeline = this;
-            const record = dispatch;
-            return admit(() => pipeline.dispatchRequest(record), (error) => pipeline.failRequest(record, error));
+            return admit(this.dispatchRequest, this.failRequest, this, dispatch);
         }
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received, dispatch.fields);
         this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Admitted, dispatch.fields);
@@ -82,11 +85,15 @@ class ZLinkChannelDispatchPipeline {
             invocation = this.invokeInFlow(dispatch, dispatch.handler);
         }
         catch (error) {
-            return this.failRequest(dispatch, error);
+            return this.failRequest(error, dispatch);
         }
         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));
+        {
+            const pipeline = this;
+            const record = dispatch;
+            return Promise.resolve(invocation).then((value) => pipeline.completeRequest(record, value), (error) => pipeline.failRequest(error, record));
+        }
     }
     async dispatchMissingRequest(dispatch) {
         const missing = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.HandlerNotFound, dispatch.missingHandlerMessage);
@@ -103,12 +110,12 @@ class ZLinkChannelDispatchPipeline {
     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));
+            ? this.invoke(dispatch, handler)
+            : (0, flow_context_1.runWithFlow)(flow, this.invoke.bind(this, dispatch, handler));
     }
     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}'.`));
+            return this.failRequest((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `A handler filter rejected '${this.options.channelName}:${dispatch.fields.packetName}'.`), dispatch);
         }
         let written;
         try {
@@ -122,14 +129,18 @@ class ZLinkChannelDispatchPipeline {
             this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, dispatch.fields);
             return;
         }
-        return written.then(() => this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, dispatch.fields), (error) => this.replyPathMissing(dispatch.fields, error));
+        {
+            const pipeline = this;
+            const record = dispatch;
+            return written.then(() => pipeline.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, record.fields), (error) => pipeline.replyPathMissing(record.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) {
+    async failRequest(error, dispatch) {
         try {
             await dispatch.writeError(error);
         }
@@ -177,24 +188,30 @@ class ZLinkChannelDispatchPipeline {
             error: input.error
         });
     }
-    invoke(envelope, codecs, handler, context, fields, signal) {
-        (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
+    invoke(dispatch, handler) {
+        const envelope = dispatch.envelope;
+        const codecs = dispatch.codecs;
+        const context = dispatch.context;
+        const fields = dispatch.fields;
+        const signal = dispatch.signal;
         if (this.filters.length === 0) {
             //  Fast path for the dominant unfiltered dispatch: skip the filter
             //  context object and chain machinery entirely.
-            const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, codecs);
+            const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, codecs, (0, HandlerMessageType_1.resolveMessageTypeForDecode)(dispatch.messageType));
             this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dispatched, fields);
+            (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
             return handler.handle(payload, context);
         }
-        return this.invokeFiltered(envelope, codecs, handler, context, fields, signal);
+        return this.invokeFiltered(envelope, codecs, handler, context, fields, dispatch.messageType, signal);
     }
-    async invokeFiltered(envelope, codecs, handler, context, fields, signal) {
+    async invokeFiltered(envelope, codecs, handler, context, fields, messageType, signal) {
         let value;
         const handlerInvoked = await (0, handlers_1.invokeZLinkHandlerFilters)(this.filters, this.createFilterContext(context, fields), async () => {
             // Filters are the channel admission gate. Decode only after they have
             // allowed the handler turn to proceed.
-            const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, codecs);
+            const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, codecs, (0, HandlerMessageType_1.resolveMessageTypeForDecode)(messageType));
             this.trace(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dispatched, fields);
+            (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
             value = await handler.handle(payload, context);
         }, signal);
         return handlerInvoked ? value : HANDLER_FILTER_REJECTED;
@@ -208,6 +225,7 @@ class ZLinkChannelDispatchPipeline {
             contentType: context.contentType,
             metadata: context.metadata,
             correlationId: context.correlationId,
+            receivedAt: context.receivedAt,
             dispatchKind
         };
     }

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

@@ -5,6 +5,7 @@ import type { ZLinkDispatchErrorSurface, ZLinkDispatchMessageKind } from '../../
 import type { ZLinkFrameworkRegistration } from '../configuration';
 import { ZLinkRuntimeMetrics, type ZLinkMessageFlowModeCell } from '../diagnostics';
 import type { ZLinkRuntimeTaskErrorSink } from '../execution';
+import { type ZLinkTelemetryLease } from '../diagnostics/message-flow-delivery';
 import { ZLinkDispatchErrorReporter } from './dispatch-error-reporter';
 import type { ZLinkChannelRequestHandler, ZLinkChannelSendHandler, ZLinkRouteRuntimeRequestHandler, ZLinkRouteRuntimeSendHandler } from './channel-dispatchers';
 export interface ZLinkChannelOutboundTrace {
@@ -28,13 +29,14 @@ export declare class ZLinkChannelDispatchServices {
     private readonly registration;
     private readonly providerResolver?;
     private readonly configuredMessageFlowModeCell?;
+    private readonly telemetryLease;
     private readonly dispatchErrorReporters;
     private messageFlowModeCellValue?;
     private diagnosticsContextValue?;
     private handlerFiltersValue?;
     private outboundFlowValue?;
     private readonly metricsValue;
-    constructor(registration: ZLinkFrameworkRegistration, providerResolver?: ZLinkProviderResolver | undefined, configuredMessageFlowModeCell?: ZLinkMessageFlowModeCell | undefined);
+    constructor(registration: ZLinkFrameworkRegistration, providerResolver?: ZLinkProviderResolver | undefined, configuredMessageFlowModeCell?: ZLinkMessageFlowModeCell | undefined, telemetryLease?: ZLinkTelemetryLease);
     metrics(): ZLinkRuntimeMetrics;
     flowCreationEnabled(): boolean;
     dispatchErrorReporter(errorSink: ZLinkRuntimeTaskErrorSink): ZLinkDispatchErrorReporter;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelDispatchServices = void 0;
 const diagnostics_1 = require("../diagnostics");
+const message_flow_delivery_1 = require("../diagnostics/message-flow-delivery");
 const dispatch_error_reporter_1 = require("./dispatch-error-reporter");
 const handlers_1 = require("../handlers");
 const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
@@ -10,16 +11,18 @@ class ZLinkChannelDispatchServices {
     registration;
     providerResolver;
     configuredMessageFlowModeCell;
+    telemetryLease;
     dispatchErrorReporters = new WeakMap();
     messageFlowModeCellValue;
     diagnosticsContextValue;
     handlerFiltersValue;
     outboundFlowValue;
     metricsValue;
-    constructor(registration, providerResolver, configuredMessageFlowModeCell) {
+    constructor(registration, providerResolver, configuredMessageFlowModeCell, telemetryLease = (0, message_flow_delivery_1.openTelemetryLease)()) {
         this.registration = registration;
         this.providerResolver = providerResolver;
         this.configuredMessageFlowModeCell = configuredMessageFlowModeCell;
+        this.telemetryLease = telemetryLease;
         this.metricsValue = new diagnostics_1.ZLinkRuntimeMetrics(registration.metrics?.meterProvider);
     }
     metrics() {
@@ -33,7 +36,7 @@ class ZLinkChannelDispatchServices {
         if (existing !== undefined) {
             return existing;
         }
-        const reporter = new dispatch_error_reporter_1.ZLinkDispatchErrorReporter(undefined, undefined, errorSink, this.diagnosticsContext(), this.metricsValue);
+        const reporter = new dispatch_error_reporter_1.ZLinkDispatchErrorReporter(this.diagnosticsContext(), this.metricsValue);
         this.dispatchErrorReporters.set(errorSink, reporter);
         return reporter;
     }
@@ -167,13 +170,11 @@ class ZLinkChannelDispatchServices {
         return this.messageFlowModeCellValue;
     }
     diagnosticsContext() {
-        this.diagnosticsContextValue ??= (0, diagnostics_1.createDiagnosticsContext)(this.registration.dispatch, this.providerResolver, this.messageFlowModeCell());
+        this.diagnosticsContextValue ??= (0, diagnostics_1.createDiagnosticsContext)(this.registration.dispatch, this.providerResolver, this.messageFlowModeCell(), this.telemetryLease);
         return this.diagnosticsContextValue;
     }
     outboundFlow() {
-        this.outboundFlowValue ??= new diagnostics_1.ZLinkMessageFlowTracer(this.diagnosticsContext(), {
-            reportRuntimeTaskException() { }
-        });
+        this.outboundFlowValue ??= new diagnostics_1.ZLinkMessageFlowTracer(this.diagnosticsContext());
         return this.outboundFlowValue;
     }
 }

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

@@ -1,3 +1,4 @@
+import type { ZLinkHandlerMessageType } from '../../contracts/Common/HandlerMessageType';
 import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type { RoutingId, ZLinkMessageContext, ZLinkHandlerFilter, ZLinkPublishMessageContext, ZLinkRouteMessageContext, ZLinkUnhandledDispatchOptions } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
@@ -8,9 +9,11 @@ import type { ZLinkRuntimeMetrics } from '../diagnostics';
 import { type ZLinkChannelEnvelopeCodecRegistry, type ZLinkChannelEnvelopeHeader } from './channel-envelope';
 import { ZLinkDispatchErrorReporter } from './dispatch-error-reporter';
 import { type ZLinkMultipartAsyncSubmitOperation, type ZLinkMultipartOperation, type ZLinkMultipartReplyOperation } from './channel-multipart';
+import { type ZLinkOneWayDispatch, type ZLinkRequestDispatch } from './channel-dispatch-pipeline';
 export interface ZLinkChannelRequestDispatcherOptions {
     readonly meshName?: string;
     readonly channelName: string;
+    readonly receivedAtClock?: () => Date;
     /**
      * Mesh channels use the routed message context so a handler can associate
      * a report with the node that sent it.
@@ -18,8 +21,8 @@ export interface ZLinkChannelRequestDispatcherOptions {
     readonly routeMesh?: boolean;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
     readonly dispatchErrors: ZLinkDispatchErrorReporter;
-    readonly handlers: ReadonlyMap<string, ZLinkChannelRequestHandler>;
-    readonly sendHandlers?: ReadonlyMap<string, ZLinkChannelSendHandler>;
+    readonly handlers: ReadonlyMap<string, Pick<ZLinkRequestDispatch<ZLinkMessageContext>, 'handler' | 'messageType'>>;
+    readonly sendHandlers?: ReadonlyMap<string, Pick<ZLinkOneWayDispatch<ZLinkMessageContext>, 'handler' | 'messageType'>>;
     readonly filters?: readonly ZLinkHandlerFilter[];
     readonly unhandled?: ZLinkUnhandledDispatchOptions;
 }
@@ -30,6 +33,7 @@ export interface ZLinkChannelSendHandler {
     handle(payload: unknown, context: ZLinkMessageContext): Promise<void> | void;
 }
 export interface ZLinkRouteHandlerRegistration {
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly kind: 'send' | 'request';
     readonly packetName: string;
     readonly handler: ZLinkRouteRuntimeSendHandler | ZLinkRouteRuntimeRequestHandler;
@@ -54,7 +58,7 @@ export declare class ZLinkChannelRequestDispatcher {
         send?: () => ZLinkMultipartOperation<ZLinkMultipartAsyncSubmitOperation>;
     }, router: {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<boolean | void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, receivedAt?: Date): Promise<boolean | void>;
     dispatchMesh(record: ReceiveRecord, signal?: AbortSignal, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
     private submitReply;
     private createMeshContext;
@@ -62,9 +66,10 @@ export declare class ZLinkChannelRequestDispatcher {
 export interface ZLinkChannelPublishDispatcherOptions {
     readonly meshName?: string;
     readonly channelName: string;
+    readonly receivedAtClock?: () => Date;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
     readonly dispatchErrors: ZLinkDispatchErrorReporter;
-    readonly handlers: ReadonlyMap<string, ZLinkRuntimePublishHandler>;
+    readonly handlers: ReadonlyMap<string, Pick<ZLinkOneWayDispatch<ZLinkPublishMessageContext>, 'handler' | 'messageType'>>;
     readonly filters?: readonly ZLinkHandlerFilter[];
     readonly unhandled?: ZLinkUnhandledDispatchOptions;
     readonly metrics?: ZLinkRuntimeMetrics;
@@ -79,10 +84,11 @@ export declare class ZLinkChannelPublishDispatcher {
     dispatch(topicMessage: {
         readonly topic: string;
         readonly parts: readonly Message[];
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, receivedAt?: Date): Promise<void>;
 }
 export interface ZLinkRoutePacketDispatcherOptions {
     readonly routerChannelId: string;
+    readonly receivedAtClock?: () => Date;
     readonly codecs?: ZLinkChannelEnvelopeCodecRegistry;
     readonly dispatchErrors: ZLinkDispatchErrorReporter;
     readonly handlers: readonly ZLinkRouteHandlerRegistration[];
@@ -95,6 +101,7 @@ export declare class ZLinkRoutePacketDispatcher {
     private readonly sendHandlers;
     private readonly requestHandlers;
     private readonly codecs?;
+    private readonly receivedAtClock;
     private readonly pipeline;
     constructor(options: ZLinkRoutePacketDispatcherOptions);
     private readonly routerChannelId;
@@ -117,7 +124,7 @@ export declare class ZLinkRoutePacketDispatcher {
         send?: () => ZLinkMultipartOperation<ZLinkMultipartAsyncSubmitOperation>;
     }, router: {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean): Promise<boolean | void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean, receivedAt?: Date): Promise<boolean | void>;
     dispatchMesh(record: ReceiveRecord, signal?: AbortSignal, admit?: ZLinkMeshDispatchAdmission): void | Promise<void>;
     dispatchLocalCommand(parts: readonly Message[], sourceNodeRid: RoutingId, signal?: AbortSignal): Promise<void>;
     private dispatchMeshCommand;