@zlink-systems/framework 0.21.0 → 0.22.0

package/src/runtime/foundation/service-wire-m6a-codec.ts

@@ -60,7 +60,11 @@ export function encodeNodeRequestHeader(correlation: bigint): Buffer {
 
 export function decodeNodeRequestHeader(frame: Uint8Array): bigint {
   const header = decodeHeader(frame);
-  if (header.command !== M6aServiceWireCommand.nodeRequest || header.flags !== 0 || frame.byteLength !== 13) {
+  if (
+    header.command !== M6aServiceWireCommand.nodeRequest ||
+    header.flags !== 0 ||
+    frame.byteLength !== 13
+  ) {
     fail('Invalid nodeRequest header.');
   }
   return readNonZeroU64(asBuffer(frame), PREFIX_SIZE, 'correlation');
@@ -88,9 +92,10 @@ export function encodeChannelRequestHeader(correlation: bigint, channelName: str
   );
 }
 
-export function decodeChannelRequestHeader(
-  frame: Uint8Array
-): { readonly correlation: bigint; readonly channelName: string } {
+export function decodeChannelRequestHeader(frame: Uint8Array): {
+  readonly correlation: bigint;
+  readonly channelName: string;
+} {
   const header = decodeHeader(frame);
   if (header.command !== M6aServiceWireCommand.channelRequest || header.flags !== 0) {
     fail('Invalid channelRequest header.');
@@ -126,7 +131,11 @@ export function encodeReplyHeader(
 
 export function decodeReplyHeader(frame: Uint8Array): ServiceReplyHeader {
   const header = decodeHeader(frame);
-  if (header.command !== M6aServiceWireCommand.reply || header.flags !== 0 || frame.byteLength < 21) {
+  if (
+    header.command !== M6aServiceWireCommand.reply ||
+    header.flags !== 0 ||
+    frame.byteLength < 21
+  ) {
     fail('Invalid reply header.');
   }
   const bytes = asBuffer(frame);
@@ -147,10 +156,8 @@ export function encodeApplicationPayload(payload: ServiceApplicationPayload): Bu
   const packetName = encodeText8(payload.packetName, 'packetName');
   const contentType = encodeText8(payload.contentType, 'contentType');
   if (payload.payload.byteLength > MAX_U32) fail('Application payload exceeds u32.');
-  const bodyLength = packetName.byteLength
-    + contentType.byteLength
-    + 4
-    + payload.payload.byteLength;
+  const bodyLength =
+    packetName.byteLength + contentType.byteLength + 4 + payload.payload.byteLength;
   if (bodyLength > MAX_U32) fail('Application payload body exceeds u32.');
   const result = Buffer.alloc(5 + bodyLength);
   result[0] = 1;
@@ -160,11 +167,10 @@ export function encodeApplicationPayload(payload: ServiceApplicationPayload): Bu
   offset += contentType.copy(result, offset);
   result.writeUInt32BE(payload.payload.byteLength, offset);
   offset += 4;
-  Buffer.from(
-    payload.payload.buffer,
-    payload.payload.byteOffset,
-    payload.payload.byteLength
-  ).copy(result, offset);
+  Buffer.from(payload.payload.buffer, payload.payload.byteOffset, payload.payload.byteLength).copy(
+    result,
+    offset
+  );
   return result;
 }
 
@@ -188,10 +194,7 @@ export function encodeMultipartApplicationPayload(
     multipartLength += 4 + part.byteLength;
     if (multipartLength > MAX_U32) fail('Multipart payload exceeds u32.');
   }
-  const bodyLength = packetNameBytes.byteLength
-    + contentTypeBytes.byteLength
-    + 4
-    + multipartLength;
+  const bodyLength = packetNameBytes.byteLength + contentTypeBytes.byteLength + 4 + multipartLength;
   if (bodyLength > MAX_U32) fail('Application payload body exceeds u32.');
   const result = Buffer.alloc(5 + bodyLength);
   result[0] = 1;
@@ -277,10 +280,13 @@ export function encodeRouteMeshAdmission(
   const extension = concat(
     tlv(1, Buffer.of(stateToWire(descriptor.state))),
     tlv(2, encodeU64(descriptor.applicationVersion)),
-    tlv(6, concat(
-      encodeU16(descriptor.protocolCapabilities.length),
-      ...descriptor.protocolCapabilities.map(value => encodeText8(value, 'protocolCapability'))
-    )),
+    tlv(
+      6,
+      concat(
+        encodeU16(descriptor.protocolCapabilities.length),
+        ...descriptor.protocolCapabilities.map((value) => encodeText8(value, 'protocolCapability'))
+      )
+    ),
     tlv(7, Buffer.of(roleToWire(descriptor.objectRole))),
     tlv(8, encodeU32(descriptor.placementWeight)),
     tlv(9, encodeU32(descriptor.activeCapacityLimit)),
@@ -302,7 +308,8 @@ export function decodeRouteMeshAdmission(
 ): ServiceNodeDescriptor {
   validateAdmissionCommand(expectedCommand);
   const header = decodeHeader(frame);
-  if (header.command !== expectedCommand || header.flags !== 0) fail('Unexpected admission header.');
+  if (header.command !== expectedCommand || header.flags !== 0)
+    fail('Unexpected admission header.');
   const reader = new Reader(frame, PREFIX_SIZE);
   if (reader.u8('topologyKind') !== 1) fail('Admission is not RouteMesh topology.');
   const routeLength = reader.u32('routeLength');
@@ -370,11 +377,11 @@ export function decodeRouteMeshAdmission(
   }
   reader.end();
   if (
-    state === undefined
-    || applicationVersion === undefined
-    || protocolCapabilities === undefined
-    || objectRole === undefined
-    || ![8, 9, 10, 11, 12].every(id => capacities.has(id))
+    state === undefined ||
+    applicationVersion === undefined ||
+    protocolCapabilities === undefined ||
+    objectRole === undefined ||
+    ![8, 9, 10, 11, 12].every((id) => capacities.has(id))
   ) {
     fail('Descriptor extension omits a required field.');
   }
@@ -408,7 +415,11 @@ export function encodeReject(reason: number): Buffer {
 
 export function decodeReject(frame: Uint8Array): number {
   const header = decodeHeader(frame);
-  if (header.command !== M6aServiceWireCommand.reject || header.flags !== 0 || frame.byteLength !== 9) {
+  if (
+    header.command !== M6aServiceWireCommand.reject ||
+    header.flags !== 0 ||
+    frame.byteLength !== 9
+  ) {
     fail('Invalid reject record.');
   }
   const reason = asBuffer(frame).readUInt32BE(PREFIX_SIZE);
@@ -476,7 +487,7 @@ function tlv(id: number, value: Buffer): Buffer {
 }
 
 function concat(...parts: readonly Uint8Array[]): Buffer {
-  return Buffer.concat(parts.map(part => Buffer.from(part)));
+  return Buffer.concat(parts.map((part) => Buffer.from(part)));
 }
 
 function readNonZeroU64(bytes: Buffer, offset: number, field: string): bigint {
@@ -491,9 +502,9 @@ function asBuffer(value: Uint8Array): Buffer {
 
 function validateAdmissionCommand(command: number): void {
   if (
-    command !== M6aServiceWireCommand.hello
-    && command !== M6aServiceWireCommand.admit
-    && command !== M6aServiceWireCommand.update
+    command !== M6aServiceWireCommand.hello &&
+    command !== M6aServiceWireCommand.admit &&
+    command !== M6aServiceWireCommand.update
   ) {
     fail('Command is not an admission record.');
   }
@@ -507,9 +518,9 @@ function validateReplyFields(correlation: bigint, terminal: number, failure: num
   //  generated predicate replaces the old broad-category check, which
   //  accepted any typed pairing and wrongly rejected defined codes 33/34.
   if (
-    correlation <= 0n
-    || correlation > MAX_U64
-    || !isValidServiceWireTerminalFailure(terminal, failure)
+    correlation <= 0n ||
+    correlation > MAX_U64 ||
+    !isValidServiceWireTerminalFailure(terminal, failure)
   ) {
     fail('Invalid reply terminal fields.');
   }
@@ -520,23 +531,34 @@ function stateToWire(value: ServiceNodeState): number {
   // is a host-internal transition and has the same remote admission meaning
   // as `draining`; the service wire does not expose a separate retiring value.
   switch (value) {
-    case 'preparing': return 0;
-    case 'serving': return 1;
+    case 'preparing':
+      return 0;
+    case 'serving':
+      return 1;
     case 'retiring':
-    case 'draining': return 2;
-    case 'stopped': return 3;
-    case 'error': return 4;
+    case 'draining':
+      return 2;
+    case 'stopped':
+      return 3;
+    case 'error':
+      return 4;
   }
 }
 
 function stateFromWire(value: number): ServiceNodeState {
   switch (value) {
-    case 0: return 'preparing';
-    case 1: return 'serving';
-    case 2: return 'draining';
-    case 3: return 'stopped';
-    case 4: return 'error';
-    default: fail('Invalid runtime state.');
+    case 0:
+      return 'preparing';
+    case 1:
+      return 'serving';
+    case 2:
+      return 'draining';
+    case 3:
+      return 'stopped';
+    case 4:
+      return 'error';
+    default:
+      fail('Invalid runtime state.');
   }
 }
 

package/src/runtime/framework-errors-internal.ts

@@ -51,7 +51,9 @@ export enum ZLinkFrameworkInternalErrorKind {
   ActorRouteUnavailable = 'actorRouteUnavailable'
 }
 
-const INTERNAL_TO_PUBLIC: Readonly<Record<ZLinkFrameworkInternalErrorKind, ZLinkFrameworkErrorKind>> = Object.freeze({
+const INTERNAL_TO_PUBLIC: Readonly<
+  Record<ZLinkFrameworkInternalErrorKind, ZLinkFrameworkErrorKind>
+> = Object.freeze({
   [ZLinkFrameworkInternalErrorKind.ActorRouteNotFound]: ZLinkFrameworkErrorKind.NotFound,
   [ZLinkFrameworkInternalErrorKind.ActorCreateFailed]: ZLinkFrameworkErrorKind.InternalFailure,
   [ZLinkFrameworkInternalErrorKind.ActorAlreadyExists]: ZLinkFrameworkErrorKind.AlreadyExists,
@@ -74,7 +76,8 @@ const INTERNAL_TO_PUBLIC: Readonly<Record<ZLinkFrameworkInternalErrorKind, ZLink
   [ZLinkFrameworkInternalErrorKind.WorkerFailed]: ZLinkFrameworkErrorKind.InternalFailure,
   [ZLinkFrameworkInternalErrorKind.ActorLocationStale]: ZLinkFrameworkErrorKind.Unavailable,
   [ZLinkFrameworkInternalErrorKind.ActorCreateRejected]: ZLinkFrameworkErrorKind.Rejected,
-  [ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured]: ZLinkFrameworkErrorKind.NotConfigured,
+  [ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured]:
+    ZLinkFrameworkErrorKind.NotConfigured,
   [ZLinkFrameworkInternalErrorKind.MeshSelectionRequired]: ZLinkFrameworkErrorKind.NotConfigured,
   [ZLinkFrameworkInternalErrorKind.MeshNotFound]: ZLinkFrameworkErrorKind.NotFound,
   [ZLinkFrameworkInternalErrorKind.InvalidConfiguration]: ZLinkFrameworkErrorKind.NotConfigured,
@@ -90,13 +93,16 @@ const INTERNAL_TO_PUBLIC: Readonly<Record<ZLinkFrameworkInternalErrorKind, ZLink
   [ZLinkFrameworkInternalErrorKind.SpotIdConflict]: ZLinkFrameworkErrorKind.AlreadyExists,
   [ZLinkFrameworkInternalErrorKind.RuntimeShutdown]: ZLinkFrameworkErrorKind.ShuttingDown,
   [ZLinkFrameworkInternalErrorKind.RelocationDisabled]: ZLinkFrameworkErrorKind.Rejected,
-  [ZLinkFrameworkInternalErrorKind.RelocationTargetUnavailable]: ZLinkFrameworkErrorKind.Unavailable,
+  [ZLinkFrameworkInternalErrorKind.RelocationTargetUnavailable]:
+    ZLinkFrameworkErrorKind.Unavailable,
   [ZLinkFrameworkInternalErrorKind.RelocationFailed]: ZLinkFrameworkErrorKind.InternalFailure,
   [ZLinkFrameworkInternalErrorKind.InvalidOperation]: ZLinkFrameworkErrorKind.InvalidOperation,
   [ZLinkFrameworkInternalErrorKind.ActorRouteUnavailable]: ZLinkFrameworkErrorKind.Unavailable
 });
 
-export const ZLINK_FRAMEWORK_INTERNAL_ERROR_KIND_VALUES: Readonly<Record<ZLinkFrameworkInternalErrorKind, number>> = Object.freeze({
+export const ZLINK_FRAMEWORK_INTERNAL_ERROR_KIND_VALUES: Readonly<
+  Record<ZLinkFrameworkInternalErrorKind, number>
+> = Object.freeze({
   [ZLinkFrameworkInternalErrorKind.ActorRouteNotFound]: 0,
   [ZLinkFrameworkInternalErrorKind.ActorCreateFailed]: 1,
   [ZLinkFrameworkInternalErrorKind.ActorAlreadyExists]: 2,
@@ -141,20 +147,22 @@ export const ZLINK_FRAMEWORK_INTERNAL_ERROR_KIND_VALUES: Readonly<Record<ZLinkFr
   [ZLinkFrameworkInternalErrorKind.ActorRouteUnavailable]: 41
 });
 
-const INTERNAL_KIND_BY_WIRE_FAILURE_CODE: ReadonlyMap<number, ZLinkFrameworkInternalErrorKind> = new Map<number, ZLinkFrameworkInternalErrorKind>([
-  ...Object.entries(ZLINK_FRAMEWORK_INTERNAL_ERROR_KIND_VALUES)
-    .map(([kind, code]) => [code + 1, kind as ZLinkFrameworkInternalErrorKind] as const),
-  //  Spec 32-framework-error-model:99-103 — a workerQueueFull(18) received in a
-  //  remote reply is the target's queue state and maps to Unavailable.
-  [18, ZLinkFrameworkInternalErrorKind.RouteNotConnected]
-]);
+const INTERNAL_KIND_BY_WIRE_FAILURE_CODE: ReadonlyMap<number, ZLinkFrameworkInternalErrorKind> =
+  new Map<number, ZLinkFrameworkInternalErrorKind>([
+    ...Object.entries(ZLINK_FRAMEWORK_INTERNAL_ERROR_KIND_VALUES).map(
+      ([kind, code]) => [code + 1, kind as ZLinkFrameworkInternalErrorKind] as const
+    ),
+    //  Spec 32-framework-error-model:99-103 — a workerQueueFull(18) received in a
+    //  remote reply is the target's queue state and maps to Unavailable.
+    [18, ZLinkFrameworkInternalErrorKind.RouteNotConnected]
+  ]);
 
 const WIRE_TERMINAL_RESULT_BY_FAILURE_CODE: ReadonlyMap<number, number> = new Map([
-  ...[1, 6, 8, 9, 10, 11, 14].map(code => [code, 102] as const),
-  ...[2, 5, 13, 17, 19, 20, 35, 42].map(code => [code, 105] as const),
-  ...[3, 4, 7, 21, 33, 34].map(code => [code, 107] as const),
-  ...[12, 16].map(code => [code, 104] as const),
-  ...[15, 18, 22].map(code => [code, 106] as const)
+  ...[1, 6, 8, 9, 10, 11, 14].map((code) => [code, 102] as const),
+  ...[2, 5, 13, 17, 19, 20, 35, 42].map((code) => [code, 105] as const),
+  ...[3, 4, 7, 21, 33, 34].map((code) => [code, 107] as const),
+  ...[12, 16].map((code) => [code, 104] as const),
+  ...[15, 18, 22].map((code) => [code, 106] as const)
 ]);
 
 const INTERNAL_KIND = new WeakMap<ZLinkFrameworkException, ZLinkFrameworkInternalErrorKind>();
@@ -249,10 +257,7 @@ export function wireReplyFailureException(
       message
     );
   }
-  return new ZLinkFrameworkException(
-    requestResultToPublicErrorKind(terminalResult),
-    message
-  );
+  return new ZLinkFrameworkException(requestResultToPublicErrorKind(terminalResult), message);
 }
 
 /**
@@ -280,9 +285,10 @@ export function internalFrameworkErrorCode(error: ZLinkFrameworkException): numb
 }
 
 /** Produces the canonical stateful wire terminal without leaking internal kinds. */
-export function internalFrameworkWireReply(
-  error: ZLinkFrameworkException
-): { readonly terminalResult: number; readonly failureCode: number } {
+export function internalFrameworkWireReply(error: ZLinkFrameworkException): {
+  readonly terminalResult: number;
+  readonly failureCode: number;
+} {
   const kind = INTERNAL_KIND.get(error);
   if (kind === ZLinkFrameworkInternalErrorKind.DeadlineExceeded) {
     return { terminalResult: 101, failureCode: 0 };
@@ -321,15 +327,10 @@ export function internalFrameworkErrorKindFromWireReply(
   return expectedTerminalResult === terminalResult ? kind : undefined;
 }
 
-const BOUNDARY_WIRE_TERMINAL_RESULTS = new Set([
-  101, 103, 108, 109, 110, 111, 112, 113
-]);
+const BOUNDARY_WIRE_TERMINAL_RESULTS = new Set([101, 103, 108, 109, 110, 111, 112, 113]);
 
 /** Checks the terminal and failure-code pair before a transport maps it. */
-export function isCanonicalWireReplyTerminal(
-  terminalResult: number,
-  failureCode: number
-): boolean {
+export function isCanonicalWireReplyTerminal(terminalResult: number, failureCode: number): boolean {
   if (terminalResult === 0) return failureCode === 0;
   if (BOUNDARY_WIRE_TERMINAL_RESULTS.has(terminalResult)) return failureCode === 0;
   return internalFrameworkErrorKindFromWireReply(terminalResult, failureCode) !== undefined;

package/src/runtime/handlers/handler-instance-scope.ts

@@ -38,12 +38,9 @@ interface LifecycleScopeDisposal {
   readonly idle: Promise<void> | undefined;
 }
 
-const HANDLER_SCOPE_FACTORY = Symbol.for(
-  '@zlink-systems/framework.handler-instance-scope-factory'
-);
+const HANDLER_SCOPE_FACTORY = Symbol.for('@zlink-systems/framework.handler-instance-scope-factory');
 const activeHandlerScope = new AsyncLocalStorage<ActiveHandlerScope>();
-const activeLifecycleScope =
-  new AsyncLocalStorage<LifecycleHandlerInstanceScope>();
+const activeLifecycleScope = new AsyncLocalStorage<LifecycleHandlerInstanceScope>();
 const detachedStateLaneResource = new AsyncResource('zlink:handler-instance-scope');
 const dispatchScopes = new WeakMap<object, ZLinkHandlerInstanceScope>();
 const lifecycleScopes = new WeakMap<object, Promise<LifecycleHandlerInstanceScope>>();
@@ -69,10 +66,7 @@ export async function runInHandlerInstanceScope<T>(
     dispatchScopes.set(context, scope);
   }
   try {
-    return await activeHandlerScope.run(
-      { scope },
-      () => callback(scope)
-    );
+    return await activeHandlerScope.run({ scope }, () => callback(scope));
   } finally {
     if (context !== undefined && dispatchScopes.get(context) === scope) {
       dispatchScopes.delete(context);
@@ -89,9 +83,7 @@ export async function resolveLifecycleHandler<T>(
   let scope = lifecycleScopes.get(owner);
   if (scope === undefined) {
     scope = Promise.resolve(
-      new LifecycleHandlerInstanceScope(
-        createHandlerInstanceScope(providerResolver)
-      )
+      new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver))
     );
     lifecycleScopes.set(owner, scope);
   }
@@ -107,9 +99,7 @@ export async function runWithLifecycleHandler<THandler, TResult>(
   let scope = lifecycleScopes.get(owner);
   if (scope === undefined) {
     scope = Promise.resolve(
-      new LifecycleHandlerInstanceScope(
-        createHandlerInstanceScope(providerResolver)
-      )
+      new LifecycleHandlerInstanceScope(createHandlerInstanceScope(providerResolver))
     );
     lifecycleScopes.set(owner, scope);
   }
@@ -129,21 +119,22 @@ function createHandlerInstanceScope(
   providerResolver?: ZLinkProviderResolver,
   context?: ZLinkMessageContext
 ): ZLinkHandlerInstanceScope {
-  const factory = providerResolver === undefined
-    ? undefined
-    : (providerResolver as unknown as Record<PropertyKey, unknown>)[HANDLER_SCOPE_FACTORY];
+  const factory =
+    providerResolver === undefined
+      ? undefined
+      : (providerResolver as unknown as Record<PropertyKey, unknown>)[HANDLER_SCOPE_FACTORY];
   if (isHandlerInstanceScopeFactory(factory)) {
     return factory.create(context);
   }
   return new DefaultHandlerInstanceScope(providerResolver);
 }
 
-function isHandlerInstanceScopeFactory(
-  value: unknown
-): value is ZLinkHandlerInstanceScopeFactory {
-  return typeof value === 'object'
-    && value !== null
-    && typeof (value as { create?: unknown }).create === 'function';
+function isHandlerInstanceScopeFactory(value: unknown): value is ZLinkHandlerInstanceScopeFactory {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { create?: unknown }).create === 'function'
+  );
 }
 
 class DefaultHandlerInstanceScope implements ZLinkHandlerInstanceScope {
@@ -205,8 +196,7 @@ class DefaultHandlerInstanceScope implements ZLinkHandlerInstanceScope {
   private async activate<T>(type: Type<T>, activation: Deferred<unknown>): Promise<void> {
     let instance: T;
     try {
-      instance = await this.providerResolver?.create?.(type)
-        ?? new type();
+      instance = (await this.providerResolver?.create?.(type)) ?? new type();
     } catch (error) {
       activation.reject(error);
       return;
@@ -258,9 +248,8 @@ class LifecycleHandlerInstanceScope {
   ): Promise<TResult> {
     await this.lane.run(() => this.beginInvocationCore());
     try {
-      return await activeLifecycleScope.run(
-        this,
-        async () => callback(await this.instances.resolve(type))
+      return await activeLifecycleScope.run(this, async () =>
+        callback(await this.instances.resolve(type))
       );
     } finally {
       await this.lane.run(() => this.completeInvocationCore());

package/src/runtime/handlers/index.ts

@@ -1,9 +1,12 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } from '../framework-errors-internal';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import {
   type Type,
   type ZLinkHandlerFilterNext,
   type ZLinkHandlerFilter,
-  type ZLinkHandlerFilterContext,
+  type ZLinkHandlerFilterContext
 } from '../../contracts';
 import {
   readZLinkDecoratorMetadata,
@@ -20,7 +23,9 @@ export interface ZLinkHandlerExposurePolicy {
   readonly explicitHandlers?: readonly Type[];
 }
 
-export function scanZLinkHandlerTypes(handlerTypes: readonly Type[]): readonly ZLinkHandlerDescriptor[] {
+export function scanZLinkHandlerTypes(
+  handlerTypes: readonly Type[]
+): readonly ZLinkHandlerDescriptor[] {
   return handlerTypes.flatMap((handlerType) =>
     readZLinkDecoratorMetadata(handlerType)
       .filter((metadata) => metadata.kind !== 'handlerGroup' && metadata.kind !== 'packet')
@@ -43,7 +48,10 @@ export function exposeZLinkHandlers(
       return false;
     }
     return readZLinkDecoratorMetadata(descriptor.handlerType).some(
-      (metadata) => metadata.kind === 'handlerGroup' && metadata.groupName !== undefined && groups.has(metadata.groupName)
+      (metadata) =>
+        metadata.kind === 'handlerGroup' &&
+        metadata.groupName !== undefined &&
+        groups.has(metadata.groupName)
     );
   });
 }
@@ -82,10 +90,12 @@ function invokeAtMostOnce(next: ZLinkHandlerFilterNext): ZLinkHandlerFilterNext
   let invoked = false;
   return () => {
     if (invoked) {
-      return Promise.reject(createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.InvalidOperation,
-        'A handler filter cannot invoke next more than once.'
-      ));
+      return Promise.reject(
+        createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.InvalidOperation,
+          'A handler filter cannot invoke next more than once.'
+        )
+      );
     }
     invoked = true;
     return next();