@zlink-systems/framework 0.31.0 → 0.32.1

package/dist/runtime/backend/mesh-completion-table.d.ts

@@ -9,6 +9,7 @@ export interface ZLinkMeshCompletionDiagnostic {
 export interface ZLinkMeshCompletion {
     readonly terminalResult: number;
     readonly failureErrno: number;
+    readonly failureMessage?: string;
     readonly operationKind: number;
     readonly kindData: ReceiveKindData | null;
     readonly parts: Message[];

package/dist/runtime/backend/mesh-completion-table.js

@@ -269,6 +269,7 @@ function retainCompletion(record) {
     return {
         terminalResult: record.terminalResult,
         failureErrno: record.failureErrno,
+        ...(record.failureMessage === undefined ? {} : { failureMessage: record.failureMessage }),
         operationKind: record.operationKind,
         kindData: record.kindData,
         parts

package/dist/runtime/backend/node/node-mesh-backend-adapter.js

@@ -12,7 +12,11 @@ class ZLinkNodeMeshBackendAdapter {
         if (!isBindingContext(bindingContext)) {
             throw new TypeError('Node MeshNode creation requires the Node binding Context owned by the host.');
         }
-        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed, options.infrastructureTaskRunner);
+        return new node_raw_mesh_backend_1.ZLinkNodeRawMeshBackend(options.meshName, options.routingId, new node_raw_binding_port_1.ZLinkNodeRawBindingPort(bindingContext, {
+            sendHighWaterMark: options.sendHighWaterMark,
+            receiveHighWaterMark: options.receiveHighWaterMark,
+            receiveTimeoutMs: options.receiveTimeoutMs
+        }), options.applicationJobQueue, options.applicationJobReceiveFlowFailureSink, options.peerAdmissionSealed, options.infrastructureTaskRunner);
     }
 }
 exports.ZLinkNodeMeshBackendAdapter = ZLinkNodeMeshBackendAdapter;

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

@@ -1,9 +1,14 @@
 import { type Context } from '@zlink-systems/zlink';
 import type { ZLinkRawBindingPort, ZLinkRawHostPort } from '../raw-binding-port';
+interface ZLinkNodeRawRouterSocketOptions {
+    readonly sendHighWaterMark?: number;
+    readonly receiveHighWaterMark?: number;
+    readonly receiveTimeoutMs?: number;
+}
 export type { ZLinkRawBindingPort, ZLinkRawDealerPort, ZLinkRawHostPort, ZLinkRawMonitorPort, ZLinkRawMonitorRecord, ZLinkRawReceivedRecord, ZLinkRawRouterPort, ZLinkRawRouterRoute, ZLinkRawSocketPort } from '../raw-binding-port';
 export declare class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
     private readonly sharedContext?;
-    private readonly routerReceiveTimeoutMs?;
-    constructor(sharedContext?: Context | undefined, routerReceiveTimeoutMs?: number | undefined);
+    private readonly routerSocketOptions?;
+    constructor(sharedContext?: Context | undefined, routerSocketOptions?: ZLinkNodeRawRouterSocketOptions | undefined);
     createHost(): ZLinkRawHostPort;
 }

package/dist/runtime/backend/node/node-raw-binding-port.js

@@ -11,30 +11,30 @@ const node_event_loop_poller_1 = require("./node-event-loop-poller");
 const runtime_message_1 = require("../runtime-message");
 class ZLinkNodeRawBindingPort {
     sharedContext;
-    routerReceiveTimeoutMs;
-    constructor(sharedContext, routerReceiveTimeoutMs) {
+    routerSocketOptions;
+    constructor(sharedContext, routerSocketOptions) {
         this.sharedContext = sharedContext;
-        this.routerReceiveTimeoutMs = routerReceiveTimeoutMs;
+        this.routerSocketOptions = routerSocketOptions;
     }
     createHost() {
-        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined, this.routerReceiveTimeoutMs);
+        return new NodeRawHostPort(this.sharedContext ?? (0, zlink_1.createContext)(), this.sharedContext === undefined, this.routerSocketOptions);
     }
 }
 exports.ZLinkNodeRawBindingPort = ZLinkNodeRawBindingPort;
 class NodeRawHostPort {
     context;
     ownsContext;
-    routerReceiveTimeoutMs;
+    routerSocketOptions;
     resources = [];
     state = 'open';
-    constructor(context, ownsContext, routerReceiveTimeoutMs) {
+    constructor(context, ownsContext, routerSocketOptions) {
         this.context = context;
         this.ownsContext = ownsContext;
-        this.routerReceiveTimeoutMs = routerReceiveTimeoutMs;
+        this.routerSocketOptions = routerSocketOptions;
     }
     createRouter() {
         this.requireOpen();
-        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context), this.routerReceiveTimeoutMs));
+        return this.own(new NodeRawRouterPort((0, zlink_1.createRouterSocket)(this.context), this.routerSocketOptions));
     }
     createDealer() {
         this.requireOpen();
@@ -218,13 +218,19 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         this.requireOpen();
         (0, node_socket_backend_adapter_1.disconnectSocketPeer)(this.socket, this.preparedRoutingId(routingId));
     }
-    constructor(socket, receiveTimeoutMs) {
+    constructor(socket, options) {
         super(socket, true);
         socket.options.handover = true;
         socket.options.mandatory = true;
         socket.options.probe = true;
-        if (receiveTimeoutMs !== undefined) {
-            socket.options.recvTimeout = receiveTimeoutMs;
+        if (options?.sendHighWaterMark !== undefined) {
+            socket.options.sendHwm = BigInt(options.sendHighWaterMark);
+        }
+        if (options?.receiveHighWaterMark !== undefined) {
+            socket.options.recvHwm = BigInt(options.receiveHighWaterMark);
+        }
+        if (options?.receiveTimeoutMs !== undefined) {
+            socket.options.recvTimeout = options.receiveTimeoutMs;
         }
     }
     localEndpoint() {

package/dist/runtime/backend/node/node-raw-mesh-backend.d.ts

@@ -36,7 +36,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private readonly lifecycleGeneration;
     private bindEndpoint?;
     private advertiseHost?;
-    private runtime?;
+    runtime?: RawServiceMeshRuntime;
     private stateful?;
     private readyHandler?;
     private maintenanceTimer?;
@@ -277,7 +277,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     setSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;
     unsetSpotSubscription(state: ServiceSpotState, channelName: string, topicFilter: string): void;
     clearSpotSubscriptions(state: ServiceSpotState): void;
-    private createDescriptor;
+    createDescriptor(): ServiceNodeDescriptor;
     private resolveAdvertisedEndpoint;
     /**
      * Arms the one maintenance timer for the nearest management deadline

package/dist/runtime/backend/node/node-raw-mesh-backend.js

@@ -369,6 +369,7 @@ class ZLinkNodeRawMeshBackend {
     }
     expectPeer(peer) {
         this.requireRuntime().expectPeerByRoutingId(peer.endpoint, peer.nodeRoutingId, peer.securityIdentity, peer.lifecycleGeneration);
+        this.scheduleMaintenance();
     }
     removePeerConnection(intentId) {
         const intent = this.peerIntents.get(intentId);
@@ -1447,6 +1448,9 @@ function completionRecord(operationId, operationKind, result) {
         kindData: 'kindData' in result ? (result.kindData ?? null) : null,
         terminalResult: result.terminalResult,
         failureErrno: result.failureCode,
+        ...('failureMessage' in result && result.failureMessage !== undefined
+            ? { failureMessage: result.failureMessage }
+            : {}),
         parts: payload === undefined
             ? []
             : payload.contentType === MULTIPART_CONTENT_TYPE
@@ -1667,10 +1671,10 @@ function decodeStatefulRecord(record, stateful) {
             });
             return accepted ? zlink_1.SubmitResult.Ok : zlink_1.SubmitResult.InvalidState;
         },
-        replyFailure(terminalResult, failureCode) {
+        replyFailure(terminalResult, failureCode, tail) {
             if (stateful.reply === undefined)
                 return zlink_1.SubmitResult.InvalidState;
-            return stateful.reply(terminalResult, failureCode)
+            return stateful.reply(terminalResult, failureCode, undefined, tail)
                 ? zlink_1.SubmitResult.Ok
                 : zlink_1.SubmitResult.InvalidState;
         }
@@ -1678,12 +1682,15 @@ function decodeStatefulRecord(record, stateful) {
 }
 function receiveIngressLifecycle(record) {
     const applicationJob = record.applicationJob;
-    return applicationJob === undefined
-        ? {}
-        : {
-            applicationJobPermit: applicationJob,
-            releaseRetainedIngress: () => applicationJob.close()
-        };
+    return {
+        ...(record.receivedAt === undefined ? {} : { receivedAt: record.receivedAt }),
+        ...(applicationJob === undefined
+            ? {}
+            : {
+                applicationJobPermit: applicationJob,
+                releaseRetainedIngress: () => applicationJob.close()
+            })
+    };
 }
 function prepareStatefulMailboxDispatch(signal) {
     const mailboxRecord = this.statefulMailboxRecord;

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

@@ -2,7 +2,7 @@ import type { ZLinkHandlerMessageType } from '../../contracts/Common/HandlerMess
 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';
@@ -47,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);
     /**
@@ -67,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;
@@ -87,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

@@ -225,6 +225,7 @@ class ZLinkChannelDispatchPipeline {
             contentType: context.contentType,
             metadata: context.metadata,
             correlationId: context.correlationId,
+            receivedAt: context.receivedAt,
             dispatchKind
         };
     }

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

@@ -13,6 +13,7 @@ import { type ZLinkOneWayDispatch, type ZLinkRequestDispatch } from './channel-d
 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.
@@ -57,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;
@@ -65,6 +66,7 @@ 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, Pick<ZLinkOneWayDispatch<ZLinkPublishMessageContext>, 'handler' | 'messageType'>>;
@@ -82,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[];
@@ -98,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;
@@ -120,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;

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

@@ -30,7 +30,7 @@ class ZLinkChannelRequestDispatcher {
     flowEnabled() {
         return this.options.dispatchErrors.flow.flowCreationEnabled();
     }
-    async dispatch(received, router, signal, decodedHeader) {
+    async dispatch(received, router, signal, decodedHeader, receivedAt = this.options.receivedAtClock?.() ?? new Date()) {
         if (received.spotId !== null && received.spotId !== undefined) {
             if (received.send === undefined) {
                 throw new configuration_1.ZLinkConfigurationException('Routed SPOT packet is missing a local SPOT delivery context.');
@@ -78,7 +78,8 @@ class ZLinkChannelRequestDispatcher {
                 contentType: envelope.header.contentType,
                 packetName,
                 metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-                correlationId
+                correlationId,
+                receivedAt
             };
             await this.pipeline.dispatchOneWay({
                 fields,
@@ -113,7 +114,8 @@ class ZLinkChannelRequestDispatcher {
             contentType: envelope.header.contentType,
             packetName,
             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-            correlationId
+            correlationId,
+            receivedAt
         };
         await this.pipeline.dispatchRequest({
             fields: requestFields,
@@ -167,7 +169,7 @@ class ZLinkChannelRequestDispatcher {
                 codecs: this.options.codecs,
                 handler: handler?.handler,
                 messageType: handler?.messageType,
-                context: this.createMeshContext(envelope, record.sourceNodeRid),
+                context: this.createMeshContext(envelope, record.sourceNodeRid, record.receivedAt),
                 signal
             }, admit);
         }
@@ -181,7 +183,7 @@ class ZLinkChannelRequestDispatcher {
             flowId: envelope.header.flowId,
             flowOrigin: envelope.header.flowOrigin
         };
-        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);
+        return this.pipeline.dispatchRequest(new ZLinkMeshRequestDispatch(fields, envelope, this.options.codecs, this.options.handlers.get(packetName), this.createMeshContext(envelope, record.sourceNodeRid, record.receivedAt), signal, record, 'channel', this.options.channelName), admit);
     }
     submitReply(operation, signal) {
         void signal;
@@ -190,14 +192,15 @@ class ZLinkChannelRequestDispatcher {
         }
         return completedChannelReply;
     }
-    createMeshContext(envelope, sourceNodeRid) {
+    createMeshContext(envelope, sourceNodeRid, receivedAt) {
         const base = {
             meshName: this.options.meshName,
             channelName: this.options.channelName,
             contentType: envelope.header.contentType,
             packetName: envelope.packetName,
             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-            correlationId: envelope.header.correlationId ?? undefined
+            correlationId: envelope.header.correlationId ?? undefined,
+            receivedAt: receivedAt ?? this.options.receivedAtClock?.() ?? new Date()
         };
         if (this.options.routeMesh !== true) {
             return base;
@@ -270,7 +273,7 @@ class ZLinkChannelPublishDispatcher {
             unhandled: options.unhandled
         });
     }
-    async dispatch(topicMessage, signal, decodedHeader) {
+    async dispatch(topicMessage, signal, decodedHeader, receivedAt = this.options.receivedAtClock?.() ?? new Date()) {
         if (topicMessage.parts.length === 0 || topicMessage.parts[0].data().length === 0) {
             return;
         }
@@ -315,7 +318,8 @@ class ZLinkChannelPublishDispatcher {
             topic: publishTopic,
             source: publishSource,
             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-            correlationId: publishCorr
+            correlationId: publishCorr,
+            receivedAt
         };
         await this.pipeline.dispatchOneWay({
             fields,
@@ -346,10 +350,12 @@ class ZLinkRoutePacketDispatcher {
     sendHandlers = new Map();
     requestHandlers = new Map();
     codecs;
+    receivedAtClock;
     pipeline;
     constructor(options) {
         this.routerChannelId = options.routerChannelId;
         this.codecs = options.codecs;
+        this.receivedAtClock = options.receivedAtClock ?? (() => new Date());
         this.dispatchErrors = options.dispatchErrors;
         this.pipeline = new channel_dispatch_pipeline_1.ZLinkChannelDispatchPipeline({
             dispatchErrors: options.dispatchErrors,
@@ -389,7 +395,7 @@ class ZLinkRoutePacketDispatcher {
         }
         return false;
     }
-    async dispatch(received, router, signal, decodedHeader, infrastructureChecked = false) {
+    async dispatch(received, router, signal, decodedHeader, infrastructureChecked = false, receivedAt = this.receivedAtClock()) {
         const channelHeader = decodedHeader ?? (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(received.parts, this.flowEnabled());
         if (!infrastructureChecked) {
             const infrastructure = this.dispatchInfrastructure(received);
@@ -442,7 +448,7 @@ class ZLinkRoutePacketDispatcher {
                 codecs: (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.codecs),
                 handler: handler?.handler,
                 messageType: handler?.messageType,
-                context: this.createRouteContext(envelope, received.routingId),
+                context: this.createRouteContext(envelope, received.routingId, receivedAt),
                 signal
             });
             return;
@@ -478,7 +484,7 @@ class ZLinkRoutePacketDispatcher {
             codecs,
             handler: handler?.handler,
             messageType: handler?.messageType,
-            context: this.createRouteContext(envelope, received.routingId),
+            context: this.createRouteContext(envelope, received.routingId, receivedAt),
             signal,
             missingHandlerMessage: `No routed request handler is registered for '${this.routerChannelId}:${packetName}'.`,
             writeReply: (reply) => this.submitReply((0, channel_multipart_1.appendParts)(router.reply(received.routingId, replyToken), (0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, reply, codecs))),
@@ -512,7 +518,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, admit);
+            return this.dispatchMeshCommand(envelope, packetName, sourceNodeRid, record.sourceNodeRid, signal, admit, record.receivedAt ?? this.receivedAtClock());
         }
         if (envelope.header.kind !== 1 /* ZLinkChannelMessageKind.Request */) {
             return completedChannelReply;
@@ -525,9 +531,10 @@ class ZLinkRoutePacketDispatcher {
             flowId: envelope.header.flowId,
             flowOrigin: envelope.header.flowOrigin
         };
-        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);
+        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, record.receivedAt), signal, record, 'routed', this.routerChannelId), admit);
     }
     async dispatchLocalCommand(parts, sourceNodeRid, signal) {
+        const receivedAt = this.receivedAtClock();
         if (parts.length === 0 || parts[0].data().length === 0)
             return;
         let envelope;
@@ -551,9 +558,9 @@ class ZLinkRoutePacketDispatcher {
         if (packetName === undefined) {
             throw new configuration_1.ZLinkConfigurationException('Route packet is missing packetName.');
         }
-        await this.dispatchMeshCommand(envelope, packetName, String(sourceNodeRid), sourceNodeRid, signal);
+        await this.dispatchMeshCommand(envelope, packetName, String(sourceNodeRid), sourceNodeRid, signal, undefined, receivedAt);
     }
-    dispatchMeshCommand(envelope, packetName, sourceRid, sourceNodeRid, signal, admit) {
+    dispatchMeshCommand(envelope, packetName, sourceRid, sourceNodeRid, signal, admit, receivedAt = this.receivedAtClock()) {
         const handler = this.sendHandlers.get(packetName);
         return this.pipeline.dispatchOneWay({
             fields: {
@@ -568,7 +575,7 @@ class ZLinkRoutePacketDispatcher {
             codecs: (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.codecs),
             handler: handler?.handler,
             messageType: handler?.messageType,
-            context: this.createRouteContext(envelope, sourceNodeRid),
+            context: this.createRouteContext(envelope, sourceNodeRid, receivedAt),
             signal
         }, admit);
     }
@@ -578,7 +585,7 @@ class ZLinkRoutePacketDispatcher {
         }
         return completedChannelReply;
     }
-    createRouteContext(envelope, sourceRid) {
+    createRouteContext(envelope, sourceRid, receivedAt = this.receivedAtClock()) {
         const sourceNodeRid = String(sourceRid ?? '');
         return {
             meshName: this.routerChannelId,
@@ -586,7 +593,8 @@ class ZLinkRoutePacketDispatcher {
             contentType: envelope.header.contentType,
             sourceNodeRid,
             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-            correlationId: envelope.header.correlationId ?? undefined
+            correlationId: envelope.header.correlationId ?? undefined,
+            receivedAt
         };
     }
 }