@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/spots/spot-routed-spot-packet-dispatch.ts

@@ -9,6 +9,7 @@ import type {
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkApplicationWorkClaim } from '../admission';
 import { zlinkMessageMetadata } from '../../contracts';
+import { resolveMessageTypeForDecode } from '../../contracts/Common/HandlerMessageType';
 import {
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
   ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
@@ -77,7 +78,7 @@ export class ZLinkRoutedSpotPacketDispatch {
   async sendEncoded(
     spotId: RoutingId,
     packetName: string | undefined,
-    decodePayload: () => unknown,
+    decodePayload: (messageType?: Type) => unknown,
     context: ZLinkRoutedSpotPacketContext
   ): Promise<void> {
     await this.dispatch(spotId, packetName, decodePayload, context, false);
@@ -95,7 +96,7 @@ export class ZLinkRoutedSpotPacketDispatch {
   async requestEncoded<TReply>(
     spotId: RoutingId,
     packetName: string | undefined,
-    decodePayload: () => unknown,
+    decodePayload: (messageType?: Type) => unknown,
     context: ZLinkRoutedSpotPacketContext
   ): Promise<TReply> {
     return (await this.dispatch(spotId, packetName, decodePayload, context, true)) as TReply;
@@ -104,10 +105,11 @@ export class ZLinkRoutedSpotPacketDispatch {
   private async dispatch(
     spotId: RoutingId,
     packetName: string | undefined,
-    decodePayload: () => unknown,
+    decodePayload: (messageType?: Type) => unknown,
     context: ZLinkRoutedSpotPacketContext,
     returnResponse: boolean
   ): Promise<unknown> {
+    const receivedAt = new Date();
     const activation = this.options.resolveActivation(spotId);
     if (activation === undefined) {
       this.reportMissing(spotId, packetName, context, returnResponse);
@@ -190,7 +192,9 @@ export class ZLinkRoutedSpotPacketDispatch {
                 );
         // Decode only after the Spot has acquired both application admission
         // and its execution authority.
-        const payload = decodePayload();
+        const payload = decodePayload(
+          resolveMessageTypeForDecode(currentRegistrations[0]?.messageType)
+        );
         for (const registration of currentRegistrations) {
           const handler = await resolveLifecycleHandler(
             current.spot,
@@ -203,13 +207,15 @@ export class ZLinkRoutedSpotPacketDispatch {
           resolveFirstHandlerTurn?.();
           resolveFirstHandlerTurn = undefined;
           context.activationRecord?.onHandlerTurnStarted?.();
-          releaseApplicationJobPermitBeforeHandler();
-          response = await handler.handle(current.spot, payload, {
+          const handlerContext = {
             channelName: context.channelName,
             contentType: context.contentType,
             packetName: packetName!,
-            metadata: zlinkMessageMetadata({})
-          });
+            metadata: zlinkMessageMetadata({}),
+            receivedAt
+          };
+          releaseApplicationJobPermitBeforeHandler();
+          response = await handler.handle(current.spot, payload, handlerContext);
         }
       } catch (error) {
         rejectFirstHandlerTurn?.(error);

package/src/runtime/spots/spot-runtime-ports.ts

@@ -36,8 +36,11 @@ export interface ZLinkEntryActorRuntime {
     parts: readonly Message[],
     returnResponse?: boolean,
     remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget,
-    fallbackActorRef?: ActorRef
-  ): Promise<{ readonly handled: boolean; readonly response?: unknown }>;
+    fallbackActorRef?: ActorRef,
+    origin?: ApplicationJobOrigin,
+    requestTerminal?: import('./spot-actor-packet-dispatch').ZLinkActorRequestTerminal,
+    messageFollowOrigin?: ZLinkMessageFollowOrigin
+  ): { readonly handled: boolean; readonly response?: unknown };
 }
 
 export interface ZLinkSpotActorTransferRuntime {

package/src/runtime/spots/spot-serial-executor.ts

@@ -28,7 +28,7 @@ export type ZLinkActorPacketTurnDispatch = (
 export class ZLinkSpotSerialExecutor {
   private readonly actorSerials = new Map<string, ZLinkSpotSerialTurnExecutor>();
   private readonly timerSerials = new Map<string, ZLinkSpotSerialTurnExecutor>();
-  private readonly actorExecutors = new Map<string, ZLinkActorSerialExecutor>();
+  readonly actorExecutors = new Map<string, ZLinkActorSerialExecutor>();
   private executionBarrier: ZLinkExecutionBarrier | undefined;
   private closing = false;
   private closePromise: Promise<void> | undefined;

package/src/runtime/spots/spot-serial-turn-executor.ts

@@ -163,10 +163,10 @@ export class ZLinkSpotSerialTurnExecutor {
   async postOneWay(
     operation: () => Promise<unknown> | unknown,
     onError: (error: unknown) => void,
-    workOptions: ZLinkSerialWorkOptions = {},
-    admission: {
+    workOptions?: ZLinkSerialWorkOptions,
+    admission?: {
       readonly signal?: AbortSignal;
-    } = {},
+    },
     replay?: (failure?: unknown) => Promise<unknown>
   ): Promise<void> {
     this.lastActivityAtMs = performance.now();
@@ -179,17 +179,13 @@ export class ZLinkSpotSerialTurnExecutor {
       if (barrierClaim !== undefined && replay !== undefined) {
         Object.assign(barrierClaim, { replay: bindApplicationJobPermit(replay) });
       }
-      if (admission.signal?.aborted === true) {
+      if (admission?.signal?.aborted === true) {
         throw new DOMException('The operation was aborted.', 'AbortError');
       }
-      const options = {
-        ...workOptions,
-        lane: workOptions.lane ?? 'application'
-      };
       const boundOperation = bindApplicationJobPermit(operation);
       const submitted = hasApplicationJobPermit()
-        ? this.scheduler.submitPreAdmitted(boundOperation, options, barrierClaim)
-        : this.scheduler.submit(boundOperation, options, barrierClaim);
+        ? this.scheduler.submitPreAdmitted(boundOperation, workOptions, barrierClaim)
+        : this.scheduler.submit(boundOperation, workOptions, barrierClaim);
       void submitted.catch((error) => {
         barrierClaim?.release();
         onError(error);
@@ -265,7 +261,7 @@ export class ZLinkSpotSerialTurnExecutor {
 
   private async enqueueApplicationTurn<T>(
     operation: () => Promise<T> | T,
-    workOptions: ZLinkSerialWorkOptions = {},
+    workOptions?: ZLinkSerialWorkOptions,
     replay?: (failure?: unknown) => Promise<T>,
     retainWhilePreparing = false
   ): Promise<T> {
@@ -300,7 +296,7 @@ export class ZLinkSpotSerialTurnExecutor {
 
   private async enqueueFrameworkTurn<T>(
     operation: () => Promise<T> | T,
-    workOptions: ZLinkSerialWorkOptions = {}
+    workOptions?: ZLinkSerialWorkOptions
   ): Promise<T> {
     this.lastActivityAtMs = performance.now();
     // Application admission crosses the async barrier boundary before it
@@ -318,43 +314,39 @@ export class ZLinkSpotSerialTurnExecutor {
 
   private submitQueuedTurn<T>(
     operation: () => Promise<T> | T,
-    workOptions: ZLinkSerialWorkOptions,
+    workOptions: ZLinkSerialWorkOptions | undefined,
     barrierClaim?: ZLinkExecutionBarrierClaim | Promise<ZLinkExecutionBarrierClaim>
   ): Promise<T> {
-    const options = {
-      ...workOptions,
-      lane: workOptions.lane ?? 'application'
-    };
     const boundOperation = bindApplicationJobPermit(operation);
     return hasApplicationJobPermit()
-      ? this.scheduler.submitPreAdmitted(boundOperation, options, barrierClaim)
-      : this.scheduler.submit(boundOperation, options, barrierClaim);
+      ? this.scheduler.submitPreAdmitted(boundOperation, workOptions, barrierClaim)
+      : this.scheduler.submit(boundOperation, workOptions, barrierClaim);
   }
 
   private runQueuedRecord(record: ZLinkSerialWorkRecord<unknown>): Promise<void> {
     if (record.context instanceof Promise) {
-      return record.context.then((claim: ZLinkExecutionBarrierClaim) => {
-        Object.assign(record, { context: claim });
-        return this.runQueuedRecord(record);
+      // Branch-local captures keep the synchronous path free of a V8 function context.
+      const executor = this;
+      const work = record;
+      const pending = record.context;
+      return pending.then((claim: ZLinkExecutionBarrierClaim) => {
+        Object.assign(work, { context: claim });
+        return executor.runQueuedRecord(work);
       });
     }
     const context = record.context as ZLinkSpotApplicationTurnContext | undefined;
     if (context?.replay !== undefined && record.operation === context.replay) {
       context.release();
-      return Promise.resolve(this.executionBarrier?.enter()).then((claim) =>
-        this.runTurn(
-          record.operation,
-          (value) => record.resolve(value),
-          (error) => record.reject(error),
-          claim,
-          record.release
-        )
+      const executor = this;
+      const work = record;
+      return Promise.resolve(executor.executionBarrier?.enter()).then((claim) =>
+        executor.runTurn(work.operation, work.resolve, work.reject, claim, work.release)
       );
     }
     return this.runTurn(
       record.operation,
-      (value) => record.resolve(value),
-      (error) => record.reject(error),
+      record.resolve,
+      record.reject,
       record.context as ZLinkExecutionBarrierClaim | undefined,
       record.release
     );
@@ -405,14 +397,7 @@ export class ZLinkSpotSerialTurnExecutor {
         release?.();
       }
     );
-    owner.then(resolve, reject);
-    return Promise.race([
-      owner.then(
-        () => undefined,
-        () => undefined
-      ),
-      turn.suspended
-    ]);
+    return Promise.race([owner.then(resolve, reject), turn.suspended]);
   }
 
   private postResume(

package/src/runtime/spots/spot-subscription-dispatch.ts

@@ -25,6 +25,7 @@ import {
 import { createInboundFlow, runWithFlow } from '../diagnostics/flow-context';
 import { resolveLifecycleHandler } from '../handlers/handler-instance-scope';
 import type { ZLinkSpotHandlerRegistration } from './spot-handler-registry';
+import { resolveMessageTypeForDecode } from '../../contracts/Common/HandlerMessageType';
 import { ZLINK_RECV_DONT_WAIT } from './spot-native-flags';
 import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
 import { zlinkMetadataByteLength, zlinkSerialWorkOptions } from '../execution/serial-work-size';
@@ -132,6 +133,7 @@ export class ZLinkSpotSubscriptionDispatch {
     readonly parts: readonly Message[];
     readonly routingId: RoutingId | unknown | null;
   }): Promise<void> {
+    const receivedAt = new Date();
     if (message.parts.length === 0) {
       this.options.dispatchErrors?.report({
         surface: ZLinkDispatchErrorSurface.SpotSubscription,
@@ -193,8 +195,12 @@ export class ZLinkSpotSubscriptionDispatch {
           runWithFlow(inboundFlow, async () => {
             // Payload deserialization belongs to the Spot serial turn. Queue
             // admission and execution authority therefore precede this work.
-            const event = decodeChannelPayload(envelope, this.channelCodecs());
             for (const registration of registrations) {
+              const event = decodeChannelPayload(
+                envelope,
+                this.channelCodecs(),
+                resolveMessageTypeForDecode(registration.messageType)
+              );
               const handler = await resolveLifecycleHandler(
                 spot,
                 registration.handlerType as Type<ZLinkSpotSubscriptionHandler<ZLinkSpot, unknown>>,
@@ -208,7 +214,8 @@ export class ZLinkSpotSubscriptionDispatch {
                   topic: message.topic,
                   source: subSource,
                   metadata: zlinkMessageMetadata(envelope.header.metadata),
-                  correlationId: envelope.header.correlationId ?? undefined
+                  correlationId: envelope.header.correlationId ?? undefined,
+                  receivedAt
                 });
               } catch (error) {
                 this.options.dispatchErrors?.report({

package/src/runtime/spots/spot-timer.ts

@@ -522,7 +522,7 @@ export class ZLinkManagedTimer implements ZLinkTimer {
   private pendingScheduledIndex: bigint | undefined;
   private timeout: unknown;
   /** The dispatch in flight, from its timer callback until `completeFireCore`. */
-  private running: Promise<void> | undefined;
+  running: Promise<void> | undefined;
   private dispatchFailure: { readonly cause: unknown } | undefined;
   private finalization: ZLinkTimerFinalization | undefined;
 

package/src/runtime/streams/actor-session-binding-registry.ts

@@ -1,3 +1,4 @@
+import { ZLinkStreamHeaderFlags, type ZLinkStreamFrameHeader } from './protocol';
 import {
   ZLinkFrameworkErrorKind,
   ZLinkFrameworkException
@@ -153,9 +154,9 @@ export class ZLinkActorSessionBindingRegistry<
   TContext extends ZLinkActorSessionBindingContext<TActor>,
   TActor extends ZLinkActorSessionBindingActor
 > {
-  private readonly lane = new ZLinkStateLane();
+  readonly lane = new ZLinkStateLane();
   private readonly routes = new Map<string, ZLinkActorSessionRoute<TContext, TActor>>();
-  private readonly nextActorSlots = new WeakMap<TContext, number>();
+  readonly nextActorSlots = new WeakMap<TContext, number>();
   private readonly sealWaiters = new Map<
     string,
     Set<{
@@ -166,7 +167,7 @@ export class ZLinkActorSessionBindingRegistry<
   >();
   private readonly activeFrameWaiters = new Map<string, Set<ZLinkActorSessionActiveFrameWaiter>>();
   private readonly relocations = new Map<string, ZLinkActorSessionRelocationQueue>();
-  private readonly absentSessionRelocationResults = new Map<
+  readonly absentSessionRelocationResults = new Map<
     string,
     {
       readonly result: SessionRelocationResult;
@@ -409,6 +410,48 @@ export class ZLinkActorSessionBindingRegistry<
     return await this.lane.run(() => this.routeCore(actorId));
   }
 
+  async submitReply<T>(
+    context: TContext,
+    header: ZLinkStreamFrameHeader,
+    submit: (header: ZLinkStreamFrameHeader) => Promise<T>
+  ): Promise<T> {
+    const { submission } = await this.lane.run(() => {
+      const current =
+        header.actorSlot === undefined ||
+        [...this.routes.values()].some(
+          (route) => route.context === context && route.actorSlot === header.actorSlot
+        );
+      return {
+        submission: submit(
+          current
+            ? header
+            : {
+                ...header,
+                actorSlot: undefined,
+                flags: header.flags & ~ZLinkStreamHeaderFlags.HasActorSlot
+              }
+        )
+      };
+    });
+    return await submission;
+  }
+
+  /** Registers a current binding's frame in the same turn that can retire its slot. */
+  async submitCurrent<T>(
+    actorId: string,
+    bindingToken: string,
+    submit: (route: ZLinkActorSessionRoute<TContext, TActor>) => Promise<T>
+  ): Promise<T | undefined> {
+    const { submission } = await this.lane.run(() => {
+      const route = this.routeCore(actorId);
+      return {
+        submission: route?.bindingToken === bindingToken ? submit(route) : undefined
+      };
+    });
+    // Transport completion must not hold the registry lane.
+    return await submission;
+  }
+
   /** Selects the route only when it is the exact Session binding (§8.1 validation values). */
   async routeForSessionBinding(
     actorId: string,

package/src/runtime/streams/bound-actor-relay-sender.ts

@@ -10,6 +10,7 @@ import { flowIfEnabled } from '../diagnostics';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
 import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
 import {
+  type ZLinkActorSessionAuthorityFence,
   ZLinkActorSessionBindingRegistry,
   ZLinkActorSessionBindingTermination
 } from './actor-session-binding-registry';
@@ -38,7 +39,8 @@ export interface ZLinkBoundActorRelaySenderOptions {
   readonly notifyDisconnected?: (
     actor: ZLinkSessionActor,
     signal?: AbortSignal,
-    binding?: ServiceStreamSessionBinding
+    binding?: ServiceStreamSessionBinding,
+    authorityFence?: ZLinkActorSessionAuthorityFence
   ) => Promise<void>;
 }
 
@@ -269,7 +271,12 @@ export class ZLinkBoundActorRelaySender {
         signal
       );
     }
-    await this.options.notifyDisconnected?.(actor, signal, detached.binding);
+    await this.options.notifyDisconnected?.(
+      actor,
+      signal,
+      detached.binding,
+      detached.route.authorityFence
+    );
   }
 
   async notifyPhysicalDisconnect(context: DefaultZLinkSessionContext): Promise<void> {
@@ -300,15 +307,19 @@ export class ZLinkBoundActorRelaySender {
             actor.bindingToken,
             ZLinkActorSessionBindingTermination.PhysicalDisconnect
           );
-          return { binding };
+          return { binding, authorityFence: route.authorityFence };
         });
         if (detached === false) return;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
         try {
           await Promise.race([
-            this.options.notifyDisconnected?.(actor, controller.signal, detached.binding) ??
-              Promise.resolve(),
+            this.options.notifyDisconnected?.(
+              actor,
+              controller.signal,
+              detached.binding,
+              detached.authorityFence
+            ) ?? Promise.resolve(),
             new Promise<never>((_, reject) => {
               controller.signal.addEventListener(
                 'abort',

package/src/runtime/streams/bound-session-service.ts

@@ -125,11 +125,12 @@ export class ZLinkBoundSessionService {
       this.actorSlot(route)
     );
     try {
-      throwIfAborted(signal);
-      if ((await this.routes.route(actorId))?.bindingToken !== route.bindingToken) {
-        return { status: ZLinkSubmitStatus.TargetNotFound };
-      }
-      return await route.context.stream.submitRaw(frame);
+      return (
+        (await this.routes.submitCurrent(actorId, route.bindingToken, (current) => {
+          throwIfAborted(signal);
+          return current.context.stream.submitRaw(frame);
+        })) ?? { status: ZLinkSubmitStatus.TargetNotFound }
+      );
     } finally {
       frame.close();
     }
@@ -370,10 +371,12 @@ export class ZLinkBoundSessionService {
       this.actorSlot(route)
     );
     try {
-      if ((await this.routes.route(actorId))?.bindingToken !== route.bindingToken) {
+      const result = await this.routes.submitCurrent(actorId, route.bindingToken, (current) =>
+        current.context.stream.submitRaw(frame)
+      );
+      if (result === undefined) {
         return false;
       }
-      const result = await route.context.stream.submitRaw(frame);
       if (result.status !== ZLinkSubmitStatus.Submitted) {
         throw new Error(`Actor '${actorId}' local bound session ${operationName} failed.`);
       }

package/src/runtime/streams/index.ts

@@ -60,6 +60,9 @@ import { ZLinkBoundSessionService, type ZLinkBoundSessionTransport } from './bou
 import { ZLinkManagedStream } from './managed-stream';
 import {
   messageToBytes,
+  decodeStreamFrame,
+  decodeStreamHeader,
+  encodeStreamFrame,
   ZLinkStreamCodec,
   ZLinkStreamMessageKind,
   type ZLinkStreamFrameHeader,
@@ -417,7 +420,7 @@ export class ZLinkStreamSessionNodeRuntime extends ZLinkStreamSessionNodeRuntime
 }
 
 export class ZLinkStreamBindingRuntime {
-  private readonly routes: ZLinkActorSessionBindingRegistry<
+  readonly routes: ZLinkActorSessionBindingRegistry<
     DefaultZLinkSessionContext,
     DefaultZLinkSessionActor
   >;
@@ -808,19 +811,42 @@ export class ZLinkStreamBindingRuntime {
     );
   }
 
-  createJsonReplyFrameMessage(
+  async submitReply(
+    context: DefaultZLinkSessionContext,
     requestHeader: ZLinkStreamFrameHeader,
     kind: ZLinkStreamReplyMessageKind,
     metadata: ReadonlyMap<string, string>,
     compressed: boolean,
     payload: unknown
-  ): Message {
-    return this.frameMessages.createJsonReplyFrameMessage(
+  ): Promise<ZLinkSubmitResult> {
+    const frame = this.frameMessages.createJsonReplyFrameMessage(
       requestHeader,
       kind,
       metadata,
       compressed,
       payload
     );
+    try {
+      return await this.routes.submitReply(context, requestHeader, async (header) => {
+        if (header === requestHeader) return await context.stream.submitRaw(frame);
+        const encoded = decodeStreamFrame(messageToBytes(frame));
+        const normalized = this.createBinaryMessage(
+          encodeStreamFrame(
+            {
+              ...decodeStreamHeader(encoded.header),
+              actorSlot: header.actorSlot
+            },
+            encoded.payload
+          )
+        );
+        try {
+          return await context.stream.submitRaw(normalized);
+        } finally {
+          normalized.close();
+        }
+      });
+    } finally {
+      frame.close();
+    }
   }
 }

package/src/runtime/streams/managed-stream.ts

@@ -478,7 +478,8 @@ export class ZLinkManagedStream implements ZLinkStream {
         throw wireReplyFailureException(
           completion.terminalResult,
           completion.failureErrno,
-          `${operationName} failed with result ${completion.terminalResult} (errno ${completion.failureErrno}).`
+          completion.failureMessage ??
+            `${operationName} failed with result ${completion.terminalResult} (errno ${completion.failureErrno}).`
         );
       }
     } finally {

package/src/runtime/streams/session-calls.ts

@@ -39,13 +39,13 @@ export interface ZLinkSessionCallContext {
     payload: unknown,
     correlationId?: string
   ): Message;
-  createJsonReplyFrameMessage(
+  submitReply(
     requestHeader: ZLinkStreamFrameHeader,
     kind: ZLinkStreamReplyMessageKind,
     metadata: ReadonlyMap<string, string>,
     compressed: boolean,
     payload: unknown
-  ): Message;
+  ): Promise<ZLinkSubmitResult>;
   claimReply(requestHeader: ZLinkStreamFrameHeader): void;
   /**
    * Spec 26 §2.2: the STREAM surface records session-connected sends and the
@@ -168,23 +168,18 @@ export class DefaultZLinkSessionReplyCall implements ZLinkSessionReplyCall {
       throw new Error('Reply is only available while handling a request packet.');
     }
     this.context.claimReply(requestHeader);
-    const message = this.context.createJsonReplyFrameMessage(
+    const result = await this.context.submitReply(
       requestHeader,
       ZLinkStreamMessageKind.Response,
       new Map<string, string>(),
       this.compressionEnabled,
       this.message
     );
-    try {
-      const result = await this.context.stream.submitRaw(message);
-      requireOneWayCompletion(result, 'STREAM session reply');
-      this.context.traceFrameWritten?.(
-        ZLinkStreamMessageKind.Response,
-        requestHeader.name,
-        requestHeader.correlationId
-      );
-    } finally {
-      message.close();
-    }
+    requireOneWayCompletion(result, 'STREAM session reply');
+    this.context.traceFrameWritten?.(
+      ZLinkStreamMessageKind.Response,
+      requestHeader.name,
+      requestHeader.correlationId
+    );
   }
 }

package/src/runtime/streams/session-context.ts

@@ -65,13 +65,14 @@ interface ZLinkSessionContextRuntime {
     payload: unknown,
     correlationId?: string
   ): Message;
-  createJsonReplyFrameMessage(
+  submitReply(
+    context: DefaultZLinkSessionContext,
     requestHeader: ZLinkStreamFrameHeader,
     kind: ZLinkStreamReplyMessageKind,
     metadata: ReadonlyMap<string, string>,
     compressed: boolean,
     payload: unknown
-  ): Message;
+  ): Promise<ZLinkSubmitResult>;
   decompressPayload(payload: Message): Message;
   bind(
     context: DefaultZLinkSessionContext,
@@ -267,20 +268,14 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
     );
   }
 
-  createJsonReplyFrameMessage(
+  submitReply(
     requestHeader: ZLinkStreamFrameHeader,
     kind: ZLinkStreamReplyMessageKind,
     metadata: ReadonlyMap<string, string>,
     compressed: boolean,
     payload: unknown
-  ): Message {
-    return this.runtime.createJsonReplyFrameMessage(
-      requestHeader,
-      kind,
-      metadata,
-      compressed,
-      payload
-    );
+  ): Promise<ZLinkSubmitResult> {
+    return this.runtime.submitReply(this, requestHeader, kind, metadata, compressed, payload);
   }
 
   enterDispatch(header: ZLinkStreamFrameHeader): void {