@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/backend/node/node-socket-backend-adapter.ts

@@ -1,3 +1,6 @@
+import type { OperationObserver } from '../../foundation/operation-registry';
+import { RequestRuntime } from '../../foundation/request-runtime';
+import type { PendingOperation } from '../../foundation/operation-registry';
 import { ZLINK_DEFAULT_PUBLIC_WEIGHT } from '../../../contracts/Configuration/RegistrationBuilderPolicy';
 import type { Socket } from '@zlink-systems/zlink';
 import type { ZLinkBackendObject } from '../contracts';
@@ -7,6 +10,7 @@ import {
   isContextTerminatedError,
   isRouteRecvRetryable,
   submitBindingRequest,
+  closeBindingReply,
   submitBindingPublish,
   submitBindingReply,
   submitBindingAsyncSend,
@@ -49,11 +53,40 @@ export function wrapSocket<T extends { close(): void }>(
     pollCompletion === undefined
       ? undefined
       : new ZLinkNodeEventLoopPoller(nativeInstance as unknown as Socket, pollCompletion, () => {});
+  const requests = new RequestRuntime();
+  const submitSocketRequest = (
+    operation: ZLinkBindingRequestOperation,
+    payload: unknown,
+    timeoutMs: number | undefined,
+    recordReceived: (() => void) | undefined,
+    onAdmitted: (() => void) | undefined,
+    requestOperation: PendingOperation<unknown> | undefined,
+    receiver: OperationObserver<unknown, unknown> | undefined
+  ): Promise<readonly unknown[]> => {
+    const pending = requests.begin(timeoutMs, undefined, requestOperation);
+    submitBindingRequest(
+      operation,
+      payload,
+      timeoutMs,
+      recordReceived,
+      onAdmitted,
+      pending,
+      receiver ?? {
+        operationCompleted: (_id, parts) => {
+          if (!pending.reply(parts))
+            closeBindingReply(parts as readonly import('@zlink-systems/zlink').Message[]);
+        },
+        operationFailed: (_id, error) => pending.replyFailure(error)
+      }
+    );
+    return pending.promise as Promise<readonly unknown[]>;
+  };
   const adapter = {
     nativeInstance,
     receiveAdmission: undefined as
       import('../../foundation/service-liveness-registry').ServiceLivenessConnection | undefined,
     async dispose(): Promise<void> {
+      requests.close();
       eventLoopPoller?.dispose();
       closeBindingHandle(nativeInstance);
     },
@@ -208,34 +241,42 @@ export function wrapSocket<T extends { close(): void }>(
     },
     request(...args: unknown[]): unknown {
       if (hasRoutedPeer) {
-        const [routingId, payload, timeoutMs, onAdmitted] = args as [
+        const [routingId, payload, timeoutMs, onAdmitted, requestOperation, receiver] = args as [
           unknown,
           unknown,
           number | undefined,
-          (() => void) | undefined
+          (() => void) | undefined,
+          PendingOperation<unknown> | undefined,
+          OperationObserver<unknown, unknown> | undefined
         ];
-        return submitBindingRequest(
+        return submitSocketRequest(
           (
             nativeInstance as T & { request(routingId: unknown): ZLinkBindingRequestOperation }
           ).request(toNativeRoutingId(routingId)),
           payload,
           timeoutMs,
           undefined,
-          onAdmitted
+          onAdmitted,
+          requestOperation,
+          receiver
         );
       }
       if (hasRequest) {
-        const [payload, timeoutMs, onAdmitted] = args as [
+        const [payload, timeoutMs, onAdmitted, requestOperation, receiver] = args as [
           unknown,
           number | undefined,
-          (() => void) | undefined
+          (() => void) | undefined,
+          PendingOperation<unknown> | undefined,
+          OperationObserver<unknown, unknown> | undefined
         ];
-        return submitBindingRequest(
+        return submitSocketRequest(
           (nativeInstance as T & { request(): ZLinkBindingRequestOperation }).request(),
           payload,
           timeoutMs,
           adapter.receiveAdmission?.recordReceived,
-          onAdmitted
+          onAdmitted,
+          requestOperation,
+          receiver
         );
       }
       throw new TypeError('Backend request requires a DEALER or ROUTER socket.');
@@ -315,9 +356,11 @@ export function wrapSocket<T extends { close(): void }>(
       targetSpot: unknown,
       payload: unknown,
       timeoutMs?: number,
-      onAdmitted?: () => void
+      onAdmitted?: () => void,
+      requestOperation?: PendingOperation<unknown>,
+      receiver?: OperationObserver<unknown, unknown>
     ): Promise<readonly unknown[]> {
-      return submitBindingRequest(
+      return submitSocketRequest(
         (
           nativeInstance as T & {
             requestToSpot(targetRid: unknown, targetSpot: unknown): ZLinkBindingRequestOperation;
@@ -326,7 +369,9 @@ export function wrapSocket<T extends { close(): void }>(
         payload,
         timeoutMs,
         undefined,
-        onAdmitted
+        onAdmitted,
+        requestOperation,
+        receiver
       );
     },
     disconnectPeer(routingId: unknown): void {

package/src/runtime/backend/raw-binding-port.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 {
@@ -14,7 +16,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;
@@ -33,7 +35,9 @@ export interface ZLinkRawMonitorRecord {
 }
 
 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;
@@ -63,16 +67,20 @@ export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
   setRoutingId(routingId: string): void;
   connectToRoutingId(routingId: string, endpoint: string): void;
   send(targetRid: string, parts: readonly Uint8Array[]): Promise<void>;
-  request(
+  request<T>(
     targetRid: string,
     parts: readonly Uint8Array[],
     timeoutMs: number,
+    onReply: (parts: readonly Buffer[]) => T,
+    onFailed: (error: unknown) => T,
     recordReceived?: () => void,
-    onAdmitted?: () => void
-  ): Promise<readonly Buffer[]>;
+    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 {

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

@@ -1,5 +1,11 @@
 import { DEFAULT_REQUEST_TIMEOUT_MS } from '../../contracts/Configuration/Registration';
-import { createZLinkRequest } from '../messaging/request-result';
+import {
+  createZLinkRequest,
+  mapZLinkRequestReply,
+  prepareZLinkRequestReply,
+  identityRequestReply,
+  type ZLinkRequestResult
+} from '../messaging/request-result';
 import type { ZLinkRequest } from '../../contracts/Handlers/Attributes';
 import type {
   ZLinkChannelClient,
@@ -315,14 +321,23 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
       () => {
         this.requireSpotTransport();
       },
-      (_packetName, timeoutMs, metadata, signal, onAdmitted) =>
-        requestToSpotHandle(this.requireSpotTransport(), spot, request, {
-          timeoutMs,
-          signal,
-          metadata,
-          onAdmitted,
-          spotRouterChannelIdForMesh: this.spotRouterChannelIdForMesh
-        }),
+      <TReply>(
+        _packetName: string | undefined,
+        timeoutMs: number | undefined,
+        metadata: ReadonlyMap<string, string>,
+        signal?: AbortSignal,
+        onAdmitted?: () => void
+      ) =>
+        prepareZLinkRequestReply(
+          requestToSpotHandle<TReply>(this.requireSpotTransport(), spot, request, {
+            timeoutMs,
+            signal,
+            metadata,
+            onAdmitted,
+            spotRouterChannelIdForMesh: this.spotRouterChannelIdForMesh
+          }),
+          identityRequestReply
+        ),
       this.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
     );
   }
@@ -528,7 +543,7 @@ type ZLinkRequestSubmitter = <TReply>(
   signal?: AbortSignal,
   onAdmitted?: () => void,
   message?: unknown
-) => Promise<TReply>;
+) => ZLinkRequestResult<TReply>;
 
 class DefaultZLinkRequestCall implements ZLinkChannelRequestCall {
   private timeoutMs?: number;
@@ -589,7 +604,7 @@ class DefaultZLinkRequestCall implements ZLinkChannelRequestCall {
       undefined,
       this.message
     );
-    return turn.yieldFrameworkPromise(pending);
+    return turn.yieldFrameworkPromise(mapZLinkRequestReply(pending));
   }
 }
 

package/src/runtime/channels/channel-dispatch-pipeline.ts

@@ -1,3 +1,4 @@
+import type { ZLinkHandlerMessageType } from '../../contracts/Common/HandlerMessageType';
 import type { ZLinkMeshDispatchAdmission } from '../admission';
 import {
   ZLinkFrameworkInternalErrorKind,
@@ -35,6 +36,7 @@ import type { ZLinkMalformedChannelHeaderInfo } from './channel-envelope-inspect
 import type { ZLinkDispatchErrorReporter } from './dispatch-error-reporter';
 import { createInboundFlow, runWithFlow } from '../diagnostics/flow-context';
 import { releaseApplicationJobPermitBeforeHandler } from '../application-jobs/application-job-queue-scope';
+import { resolveMessageTypeForDecode } from '../../contracts/Common/HandlerMessageType';
 
 export interface ZLinkChannelDispatchPipelineOptions {
   readonly dispatchErrors: ZLinkDispatchErrorReporter;
@@ -58,11 +60,12 @@ interface ZLinkChannelDispatchHandler<TContext extends ZLinkMessageContext, TRes
   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;
 }
@@ -72,6 +75,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;
@@ -80,10 +84,10 @@ export interface ZLinkRequestDispatch<TContext extends ZLinkMessageContext> {
 }
 
 export class ZLinkChannelDispatchPipeline {
-  private readonly filters: readonly ZLinkHandlerFilter[];
+  readonly filters: readonly ZLinkHandlerFilter[];
   private readonly unhandled: ZLinkUnhandledDispatchOptions;
 
-  constructor(private readonly options: ZLinkChannelDispatchPipelineOptions) {
+  constructor(readonly options: ZLinkChannelDispatchPipelineOptions) {
     this.filters = options.filters ?? [];
     this.unhandled = options.unhandled ?? DEFAULT_UNHANDLED_DISPATCH;
   }
@@ -98,12 +102,7 @@ export class ZLinkChannelDispatchPipeline {
     admit?: ZLinkMeshDispatchAdmission
   ): void | Promise<void> {
     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(ZLinkMessageFlowOutcome.Received, dispatch.fields);
     this.trace(ZLinkMessageFlowOutcome.Admitted, dispatch.fields);
@@ -112,17 +111,22 @@ export class ZLinkChannelDispatchPipeline {
     try {
       invocation = this.invokeInFlow(dispatch, dispatch.handler);
     } catch (error) {
-      this.failOneWay(dispatch.fields, error);
+      this.failOneWay(error, dispatch);
       return;
     }
     if (!isPromiseLike(invocation)) {
       this.completeOneWay(dispatch.fields, invocation);
       return;
     }
-    return Promise.resolve(invocation).then(
-      (value) => this.completeOneWay(dispatch.fields, value),
-      (error: unknown) => 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: unknown) => pipeline.failOneWay(error, record)
+      );
+    }
   }
 
   private async dispatchMissingOneWay(fields: ZLinkChannelDispatchFields): Promise<void> {
@@ -140,7 +144,8 @@ export class ZLinkChannelDispatchPipeline {
     }
   }
 
-  private failOneWay(fields: ZLinkChannelDispatchFields, error: unknown): void {
+  private failOneWay(error: unknown, dispatch: ZLinkOneWayDispatch<ZLinkMessageContext>): void {
+    const fields = dispatch.fields;
     this.report(fields, this.failureReason(error), ZLinkDispatchErrorAction.Drop, error);
   }
 
@@ -154,12 +159,7 @@ export class ZLinkChannelDispatchPipeline {
     admit?: ZLinkMeshDispatchAdmission
   ): void | Promise<void> {
     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(ZLinkMessageFlowOutcome.Received, dispatch.fields);
     this.trace(ZLinkMessageFlowOutcome.Admitted, dispatch.fields);
@@ -168,13 +168,17 @@ export class ZLinkChannelDispatchPipeline {
     try {
       invocation = this.invokeInFlow(dispatch, dispatch.handler);
     } catch (error) {
-      return this.failRequest(dispatch, error);
+      return this.failRequest(error, dispatch);
     }
     if (!isPromiseLike(invocation)) return this.completeRequest(dispatch, invocation);
-    return Promise.resolve(invocation).then(
-      (value) => this.completeRequest(dispatch, value),
-      (error: unknown) => this.failRequest(dispatch, error)
-    );
+    {
+      const pipeline = this;
+      const record = dispatch;
+      return Promise.resolve(invocation).then(
+        (value) => pipeline.completeRequest(record, value),
+        (error: unknown) => pipeline.failRequest(error, record)
+      );
+    }
   }
 
   private async dispatchMissingRequest<TContext extends ZLinkMessageContext>(
@@ -199,7 +203,7 @@ export class ZLinkChannelDispatchPipeline {
     }
   }
 
-  private invokeInFlow<TContext extends ZLinkMessageContext, TResult>(
+  invokeInFlow<TContext extends ZLinkMessageContext, TResult>(
     dispatch: ZLinkOneWayDispatch<TContext> | ZLinkRequestDispatch<TContext>,
     handler: ZLinkChannelDispatchHandler<TContext, TResult>
   ): unknown {
@@ -210,24 +214,8 @@ export class ZLinkChannelDispatchPipeline {
       undefined
     );
     return flow === undefined
-      ? this.invoke(
-          dispatch.envelope,
-          dispatch.codecs,
-          handler,
-          dispatch.context,
-          dispatch.fields,
-          dispatch.signal
-        )
-      : runWithFlow(flow, () =>
-          this.invoke(
-            dispatch.envelope,
-            dispatch.codecs,
-            handler,
-            dispatch.context,
-            dispatch.fields,
-            dispatch.signal
-          )
-        );
+      ? this.invoke(dispatch, handler)
+      : runWithFlow(flow, this.invoke.bind(this, dispatch, handler));
   }
 
   private completeRequest<TContext extends ZLinkMessageContext>(
@@ -236,11 +224,11 @@ export class ZLinkChannelDispatchPipeline {
   ): void | Promise<void> {
     if (invocation === HANDLER_FILTER_REJECTED) {
       return this.failRequest(
-        dispatch,
         createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.RequestRejected,
           `A handler filter rejected '${this.options.channelName}:${dispatch.fields.packetName}'.`
-        )
+        ),
+        dispatch
       );
     }
     let written: void | Promise<void>;
@@ -254,10 +242,14 @@ export class ZLinkChannelDispatchPipeline {
       this.trace(ZLinkMessageFlowOutcome.Replied, dispatch.fields);
       return;
     }
-    return written.then(
-      () => this.trace(ZLinkMessageFlowOutcome.Replied, dispatch.fields),
-      (error: unknown) => this.replyPathMissing(dispatch.fields, error)
-    );
+    {
+      const pipeline = this;
+      const record = dispatch;
+      return written.then(
+        () => pipeline.trace(ZLinkMessageFlowOutcome.Replied, record.fields),
+        (error: unknown) => pipeline.replyPathMissing(record.fields, error)
+      );
+    }
   }
 
   private replyPathMissing(fields: ZLinkChannelDispatchFields, error: unknown): void {
@@ -272,8 +264,8 @@ export class ZLinkChannelDispatchPipeline {
   }
 
   private async failRequest<TContext extends ZLinkMessageContext>(
-    dispatch: ZLinkRequestDispatch<TContext>,
-    error: unknown
+    error: unknown,
+    dispatch: ZLinkRequestDispatch<TContext>
   ): Promise<void> {
     try {
       await dispatch.writeError(error);
@@ -338,27 +330,40 @@ export class ZLinkChannelDispatchPipeline {
     });
   }
 
-  private invoke<TContext extends ZLinkMessageContext, TResult>(
-    envelope: ZLinkChannelEnvelope,
-    codecs: ZLinkChannelEnvelopeCodecRegistry | undefined,
-    handler: ZLinkChannelDispatchHandler<TContext, TResult>,
-    context: TContext,
-    fields: ZLinkChannelDispatchFields,
-    signal?: AbortSignal
+  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> {
-    releaseApplicationJobPermitBeforeHandler();
+    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 = decodeChannelPayload(envelope, codecs);
+      const payload = decodeChannelPayload(
+        envelope,
+        codecs,
+        resolveMessageTypeForDecode(dispatch.messageType)
+      );
       this.trace(ZLinkMessageFlowOutcome.Dispatched, fields);
+      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
+    );
   }
 
   private async invokeFiltered<TContext extends ZLinkMessageContext, TResult>(
@@ -367,6 +372,7 @@ export class ZLinkChannelDispatchPipeline {
     handler: ZLinkChannelDispatchHandler<TContext, TResult>,
     context: TContext,
     fields: ZLinkChannelDispatchFields,
+    messageType?: ZLinkHandlerMessageType,
     signal?: AbortSignal
   ): Promise<TResult | undefined | typeof HANDLER_FILTER_REJECTED> {
     let value: TResult | undefined;
@@ -376,8 +382,13 @@ export class ZLinkChannelDispatchPipeline {
       async () => {
         // Filters are the channel admission gate. Decode only after they have
         // allowed the handler turn to proceed.
-        const payload = decodeChannelPayload(envelope, codecs);
+        const payload = decodeChannelPayload(
+          envelope,
+          codecs,
+          resolveMessageTypeForDecode(messageType)
+        );
         this.trace(ZLinkMessageFlowOutcome.Dispatched, fields);
+        releaseApplicationJobPermitBeforeHandler();
         value = await handler.handle(payload, context);
       },
       signal
@@ -398,6 +409,7 @@ export class ZLinkChannelDispatchPipeline {
       contentType: context.contentType,
       metadata: context.metadata,
       correlationId: context.correlationId,
+      receivedAt: context.receivedAt,
       dispatchKind
     };
   }
@@ -445,7 +457,7 @@ export class ZLinkChannelDispatchPipeline {
     });
   }
 
-  private trace(outcome: ZLinkMessageFlowOutcome, fields: ZLinkChannelDispatchFields): void {
+  trace(outcome: ZLinkMessageFlowOutcome, fields: ZLinkChannelDispatchFields): void {
     if (fields.messageKind === ZLinkDispatchMessageKind.Publish) return;
     const flow = this.options.dispatchErrors.flow;
     const tracePoint = flow.begin(outcome, undefined, fields.flowId);

package/src/runtime/channels/channel-dispatch-services.ts

@@ -24,6 +24,7 @@ import {
   type ZLinkMessageFlowModeCell
 } from '../diagnostics';
 import type { ZLinkRuntimeTaskErrorSink } from '../execution';
+import { openTelemetryLease, type ZLinkTelemetryLease } from '../diagnostics/message-flow-delivery';
 import { ZLinkDispatchErrorReporter } from './dispatch-error-reporter';
 import { invokeZLinkHandlerFilters } from '../handlers';
 import {
@@ -72,7 +73,8 @@ export class ZLinkChannelDispatchServices {
   constructor(
     private readonly registration: ZLinkFrameworkRegistration,
     private readonly providerResolver?: ZLinkProviderResolver,
-    private readonly configuredMessageFlowModeCell?: ZLinkMessageFlowModeCell
+    private readonly configuredMessageFlowModeCell?: ZLinkMessageFlowModeCell,
+    private readonly telemetryLease: ZLinkTelemetryLease = openTelemetryLease()
   ) {
     this.metricsValue = new ZLinkRuntimeMetrics(registration.metrics?.meterProvider);
   }
@@ -90,13 +92,7 @@ export class ZLinkChannelDispatchServices {
     if (existing !== undefined) {
       return existing;
     }
-    const reporter = new ZLinkDispatchErrorReporter(
-      undefined,
-      undefined,
-      errorSink,
-      this.diagnosticsContext(),
-      this.metricsValue
-    );
+    const reporter = new ZLinkDispatchErrorReporter(this.diagnosticsContext(), this.metricsValue);
     this.dispatchErrorReporters.set(errorSink, reporter);
     return reporter;
   }
@@ -290,15 +286,14 @@ export class ZLinkChannelDispatchServices {
     this.diagnosticsContextValue ??= createDiagnosticsContext(
       this.registration.dispatch,
       this.providerResolver,
-      this.messageFlowModeCell()
+      this.messageFlowModeCell(),
+      this.telemetryLease
     );
     return this.diagnosticsContextValue;
   }
 
   private outboundFlow(): ZLinkMessageFlowTracer {
-    this.outboundFlowValue ??= new ZLinkMessageFlowTracer(this.diagnosticsContext(), {
-      reportRuntimeTaskException() {}
-    });
+    this.outboundFlowValue ??= new ZLinkMessageFlowTracer(this.diagnosticsContext());
     return this.outboundFlowValue;
   }
 }