@zlink-systems/framework 0.20.0 → 0.22.0

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

@@ -10,10 +10,7 @@ import type {
   ZLinkMessageSerializer,
   ZLinkStream
 } from '../../contracts';
-import {
-  ZLinkSubmitStatus,
-  type ZLinkSubmitResult
-} from '../messaging/submission-result';
+import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
 import { throwIfAborted } from '../abort';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
@@ -58,11 +55,14 @@ export class ZLinkManagedStream implements ZLinkStream {
   private currentLocalAddr: string | undefined;
   private currentRemoteAddr: string | undefined;
   private transportClosed = false;
-  private readonly nativeActorBindings = new Map<string, {
-    readonly actor: ZLinkBackendActorRef;
-    readonly bindingGeneration: bigint;
-    readonly route?: ZLinkNativeSessionRoute;
-  }>();
+  private readonly nativeActorBindings = new Map<
+    string,
+    {
+      readonly actor: ZLinkBackendActorRef;
+      readonly bindingGeneration: bigint;
+      readonly route?: ZLinkNativeSessionRoute;
+    }
+  >();
 
   constructor(
     private readonly socket: ZLinkBackendStreamSocket,
@@ -138,12 +138,11 @@ export class ZLinkManagedStream implements ZLinkStream {
     signal?: AbortSignal
   ): Promise<ZLinkSubmitResult> {
     throwIfAborted(signal);
-    return await this.sendBoundActor(actorId, parts, ZLINK_SEND_DONT_WAIT)
+    return (await this.sendBoundActor(actorId, parts, ZLINK_SEND_DONT_WAIT))
       ? { status: ZLinkSubmitStatus.Submitted }
       : { status: ZLinkSubmitStatus.Backpressured };
   }
 
-
   async close(signal?: AbortSignal): Promise<void> {
     throwIfAborted(signal);
     this.markTransportClosed();
@@ -211,25 +210,29 @@ export class ZLinkManagedStream implements ZLinkStream {
       }
       await this.requireSuccessfulCompletion(
         route.completions.submit(
-          () => route.service.bindActor(
-            this.backendRoutingId(),
-            nativeActor,
-            timeoutMs,
-            onBindingReplaced === undefined
-              ? undefined
-              : (_actorId, retiredSession, replacedActor) => {
-                  onBindingReplaced(replacedActor, retiredSession);
-                },
-            toStreamSessionActorAuthorityFence(authorityFence)
-          ),
+          () =>
+            route.service.bindActor(
+              this.backendRoutingId(),
+              nativeActor,
+              timeoutMs,
+              onBindingReplaced === undefined
+                ? undefined
+                : (_actorId, retiredSession, replacedActor) => {
+                    onBindingReplaced(replacedActor, retiredSession);
+                  },
+              toStreamSessionActorAuthorityFence(authorityFence)
+            ),
           signal
         ),
-        `Actor '${actor.actorId}' native session bind`,
+        `Actor '${actor.actorId}' native session bind`
       );
-      const binding = route.service.bindings(this.backendRoutingId())
-        .find((candidate) =>
-          candidate.actor.actorId === nativeActor.actorId
-          && candidate.actor.generation === nativeActor.generation);
+      const binding = route.service
+        .bindings(this.backendRoutingId())
+        .find(
+          (candidate) =>
+            candidate.actor.actorId === nativeActor.actorId &&
+            candidate.actor.generation === nativeActor.generation
+        );
       if (binding === undefined) {
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.RouteNotConnected,
@@ -240,12 +243,13 @@ export class ZLinkManagedStream implements ZLinkStream {
         try {
           await this.requireSuccessfulCompletion(
             route.completions.submit(
-              () => route.service.unbindActor(
-                this.backendRoutingId(),
-                nativeActor as never,
-                binding.bindingGeneration,
-                timeoutMs
-              ),
+              () =>
+                route.service.unbindActor(
+                  this.backendRoutingId(),
+                  nativeActor as never,
+                  binding.bindingGeneration,
+                  timeoutMs
+                ),
               signal
             ),
             `Actor '${actor.actorId}' native session unbind`,
@@ -268,7 +272,12 @@ export class ZLinkManagedStream implements ZLinkStream {
       });
       return;
     }
-    await this.socket.bindActor(this.backendRoutingId(), toBackendActorRef(actor), timeoutMs, signal);
+    await this.socket.bindActor(
+      this.backendRoutingId(),
+      toBackendActorRef(actor),
+      timeoutMs,
+      signal
+    );
   }
 
   private async ensureNativeActorRoute(
@@ -282,23 +291,24 @@ export class ZLinkManagedStream implements ZLinkStream {
       signal
     );
     try {
-      const resolved = completion.kindData?.kind === 'actorLookupCompletion'
-        ? completion.kindData.location.actor
-        : undefined;
+      const resolved =
+        completion.kindData?.kind === 'actorLookupCompletion'
+          ? completion.kindData.location.actor
+          : undefined;
       if (
-        completion.terminalResult !== 0
-        || completion.failureErrno !== 0
-        || resolved === undefined
-        || resolved.actorId !== actor.actorId
-        || resolved.generation !== actor.objectGeneration
-        || String(resolved.nodeRid) !== String(actor.nodeRid)
+        completion.terminalResult !== 0 ||
+        completion.failureErrno !== 0 ||
+        resolved === undefined ||
+        resolved.actorId !== actor.actorId ||
+        resolved.generation !== actor.objectGeneration ||
+        String(resolved.nodeRid) !== String(actor.nodeRid)
       ) {
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.ActorRouteNotFound,
-          `Actor '${actor.actorId}' native route fence does not match its ActorRef `
-          + `(expected ${String(actor.nodeRid)}/${actor.objectGeneration}, `
-          + `resolved ${resolved === undefined ? 'none' : `${String(resolved.nodeRid)}/${resolved.generation}`}, `
-          + `terminal=${completion.terminalResult}, failure=${completion.failureErrno}).`
+          `Actor '${actor.actorId}' native route fence does not match its ActorRef ` +
+            `(expected ${String(actor.nodeRid)}/${actor.objectGeneration}, ` +
+            `resolved ${resolved === undefined ? 'none' : `${String(resolved.nodeRid)}/${resolved.generation}`}, ` +
+            `terminal=${completion.terminalResult}, failure=${completion.failureErrno}).`
         );
       }
     } finally {
@@ -324,12 +334,13 @@ export class ZLinkManagedStream implements ZLinkStream {
       try {
         await this.requireSuccessfulCompletion(
           route.completions.submit(
-            () => route.service.unbindActor(
-              this.backendRoutingId(),
-              binding.actor as never,
-              binding.bindingGeneration,
-              timeoutMs
-            ),
+            () =>
+              route.service.unbindActor(
+                this.backendRoutingId(),
+                binding.actor as never,
+                binding.bindingGeneration,
+                timeoutMs
+              ),
             signal
           ),
           `Actor '${actorId}' native session unbind`,
@@ -370,24 +381,21 @@ export class ZLinkManagedStream implements ZLinkStream {
     if (binding?.route !== undefined) {
       const nativeParts = parts.map((part) => NativeMessage.from(part.data()));
       try {
-        return await binding.route.service.sendToActor(
-          this.backendRoutingId(),
-          binding.actor as never,
-          nativeParts,
-          { flags: flags ?? 0 }
-        ) === 0;
+        return (
+          (await binding.route.service.sendToActor(
+            this.backendRoutingId(),
+            binding.actor as never,
+            nativeParts,
+            { flags: flags ?? 0 }
+          )) === 0
+        );
       } finally {
         for (const part of nativeParts) {
           part.close();
         }
       }
     }
-    return this.socket.sendBoundActor(
-      this.backendRoutingId(),
-      actorId,
-      parts,
-      flags ?? 0
-    );
+    return this.socket.sendBoundActor(this.backendRoutingId(), actorId, parts, flags ?? 0);
   }
 
   updateAddresses(localAddr: string | undefined, remoteAddr: string | undefined): void {
@@ -406,9 +414,12 @@ export class ZLinkManagedStream implements ZLinkStream {
     bindingGeneration: bigint
   ): boolean {
     try {
-      return route.service.bindings(this.backendRoutingId()).some(candidate =>
-        candidate.actor.actorId === actorId
-        && candidate.bindingGeneration === bindingGeneration);
+      return route.service
+        .bindings(this.backendRoutingId())
+        .some(
+          (candidate) =>
+            candidate.actor.actorId === actorId && candidate.bindingGeneration === bindingGeneration
+        );
     } catch {
       // A closed native service owns the teardown state. Keep the original
       // error when its binding snapshot is unavailable.
@@ -428,8 +439,8 @@ export class ZLinkManagedStream implements ZLinkStream {
     const completion = await completionPromise;
     try {
       if (
-        completion.terminalResult !== 0
-        && !acceptedTerminalResults.has(completion.terminalResult)
+        completion.terminalResult !== 0 &&
+        !acceptedTerminalResults.has(completion.terminalResult)
       ) {
         throw wireReplyFailureException(
           completion.terminalResult,
@@ -443,15 +454,15 @@ export class ZLinkManagedStream implements ZLinkStream {
   }
 
   private nativeRoute(meshName: string): ZLinkNativeSessionRoute | undefined {
-    return this.nativeSessionRouteForMesh?.(meshName)
-      ?? (
-        this.nativeSessionService !== undefined && this.meshCompletions !== undefined
-          ? {
-              service: this.nativeSessionService,
-              completions: this.meshCompletions
-            }
-          : undefined
-      );
+    return (
+      this.nativeSessionRouteForMesh?.(meshName) ??
+      (this.nativeSessionService !== undefined && this.meshCompletions !== undefined
+        ? {
+            service: this.nativeSessionService,
+            completions: this.meshCompletions
+          }
+        : undefined)
+    );
   }
 }
 
@@ -460,18 +471,18 @@ export function streamSessionIdFromRoutingId(routingId: unknown): string {
     return routingId;
   }
   if (
-    typeof routingId === 'object'
-    && routingId !== null
-    && 'toHex' in routingId
-    && typeof (routingId as { toHex?: unknown }).toHex === 'function'
+    typeof routingId === 'object' &&
+    routingId !== null &&
+    'toHex' in routingId &&
+    typeof (routingId as { toHex?: unknown }).toHex === 'function'
   ) {
     return (routingId as { toHex(): string }).toHex();
   }
   if (
-    typeof routingId === 'object'
-    && routingId !== null
-    && 'toString' in routingId
-    && typeof (routingId as { toString?: unknown }).toString === 'function'
+    typeof routingId === 'object' &&
+    routingId !== null &&
+    'toString' in routingId &&
+    typeof (routingId as { toString?: unknown }).toString === 'function'
   ) {
     return (routingId as { toString(): string }).toString();
   }

package/src/runtime/streams/native-fallback-bound-session.ts

@@ -63,7 +63,9 @@ export class ZLinkNativeFallbackBoundSession implements ZLinkBoundSession {
     const remoteTarget = this.options.remoteBoundSessionTargetProvider();
     if (remoteTarget !== undefined) {
       const spotKind: ZLinkSpotKind | undefined =
-        'spotKind' in remoteTarget ? remoteTarget.spotKind as ZLinkSpotKind | undefined : undefined;
+        'spotKind' in remoteTarget
+          ? (remoteTarget.spotKind as ZLinkSpotKind | undefined)
+          : undefined;
       const payload = encodeRemoteActorPacketRelayPayload({
         actorId: this.options.actorId,
         routerChannelId: remoteTarget.routerChannelId,
@@ -76,27 +78,26 @@ export class ZLinkNativeFallbackBoundSession implements ZLinkBoundSession {
         spotId: remoteTarget.spotId,
         spotKind: spotKind ?? ZLinkSpotKind.Entry
       };
-      if (await tryRequestRoutedJson(
-        this.options.routedTransport,
-        target,
-        payload,
-        { timeoutMs: this.options.requestTimeoutMs, signal }
-      )) {
+      if (
+        await tryRequestRoutedJson(this.options.routedTransport, target, payload, {
+          timeoutMs: this.options.requestTimeoutMs,
+          signal
+        })
+      ) {
         return;
       }
-      await this.options.routedTransport.sendToSpot(
-        target,
-        payload,
-        { packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, signal }
-      );
+      await this.options.routedTransport.sendToSpot(target, payload, {
+        packetName: ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
+        signal
+      });
       return;
     }
     const actorRef = this.options.actorRefProvider();
     const node = this.options.nativeActorNodeProvider();
     if (
-      actorRef !== undefined
-      && node !== undefined
-      && currentBindingGeneration(actorRef) !== undefined
+      actorRef !== undefined &&
+      node !== undefined &&
+      currentBindingGeneration(actorRef) !== undefined
     ) {
       await this.options.runtime.disconnectNativeBoundSession(node, actorRef, signal);
       return;
@@ -129,7 +130,11 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
     if (this.executed) {
       throwAlreadySubmitted('Bound session send call');
     }
-    const packetName = resolveFrameworkPacketName(this.message, this.selectedPacketName, 'Bound session');
+    const packetName = resolveFrameworkPacketName(
+      this.message,
+      this.selectedPacketName,
+      'Bound session'
+    );
     this.executed = true;
     throwIfAborted(signal);
     const result = await this.execute(packetName, signal);
@@ -144,13 +149,15 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
     // Call-scoped flow (spec 27 §4): the relay JSON flow pair and any nested
     // routed-transport envelope share one ambient flow that does not outlive
     // this submit call.
-    return runWithOutboundFlow(
-      this.options.flowCreationEnabled?.() ?? true,
-      () => this.executeScoped(packetName, signal)
+    return runWithOutboundFlow(this.options.flowCreationEnabled?.() ?? true, () =>
+      this.executeScoped(packetName, signal)
     );
   }
 
-  private async executeScoped(packetName: string, signal?: AbortSignal): Promise<ZLinkSubmitResult> {
+  private async executeScoped(
+    packetName: string,
+    signal?: AbortSignal
+  ): Promise<ZLinkSubmitResult> {
     const localActor = this.options.localActorProvider?.() === true;
     const remoteTarget = this.options.remoteBoundSessionTargetProvider();
     const sealedRemoteTarget = remoteTarget?.relocationSealId !== undefined;
@@ -175,11 +182,7 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
       const actorRef = this.options.actorRefProvider();
       const node = this.options.nativeActorNodeProvider();
       const bindingGeneration = currentBindingGeneration(actorRef);
-      if (
-        actorRef !== undefined
-        && node !== undefined
-        && bindingGeneration !== undefined
-      ) {
+      if (actorRef !== undefined && node !== undefined && bindingGeneration !== undefined) {
         nativeAttempted = true;
         const result = await this.options.runtime.sendNativeBoundSession(
           node,
@@ -200,8 +203,9 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
     }
     if (remoteTarget !== undefined) {
       const actorRef = this.options.actorRefProvider();
-      const ownershipGeneration = (actorRef as (ActorRef & { ownershipGeneration?: bigint }) | undefined)
-        ?.ownershipGeneration;
+      const ownershipGeneration = (
+        actorRef as (ActorRef & { ownershipGeneration?: bigint }) | undefined
+      )?.ownershipGeneration;
       const payload = encodeRemoteBoundSessionSendPayload({
         actorId: this.options.actorId,
         actorMeshName: actorRef?.meshName,
@@ -220,27 +224,28 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
           ? currentOrCreateFlow('Application')
           : undefined)
       });
-      const submit = this.options.routedTransport.submitInfrastructure
-        ?? this.options.routedTransport.submit;
-      const result = submit === undefined
-        ? await this.options.routedTransport.sendToSpot(
-            {
-              routerChannelId: remoteTarget.routerChannelId,
-              targetNodeRid: remoteTarget.targetNodeRid,
-              spotId: remoteTarget.spotId,
-              spotKind: ZLinkSpotKind.Entry
-            },
-            payload,
-            { packetName: ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, signal }
-          )
-        : await submit.call(
-            this.options.routedTransport,
-            remoteTarget.routerChannelId,
-            String(remoteTarget.targetNodeRid),
-            ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET,
-            payload,
-            signal
-          );
+      const submit =
+        this.options.routedTransport.submitInfrastructure ?? this.options.routedTransport.submit;
+      const result =
+        submit === undefined
+          ? await this.options.routedTransport.sendToSpot(
+              {
+                routerChannelId: remoteTarget.routerChannelId,
+                targetNodeRid: remoteTarget.targetNodeRid,
+                spotId: remoteTarget.spotId,
+                spotKind: ZLinkSpotKind.Entry
+              },
+              payload,
+              { packetName: ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, signal }
+            )
+          : await submit.call(
+              this.options.routedTransport,
+              remoteTarget.routerChannelId,
+              String(remoteTarget.targetNodeRid),
+              ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET,
+              payload,
+              signal
+            );
       this.traceSubmitted(result, packetName);
       return result;
     }
@@ -259,10 +264,10 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
     const node = this.options.nativeActorNodeProvider();
     const bindingGeneration = currentBindingGeneration(actorRef);
     if (
-      !nativeAttempted
-      && actorRef !== undefined
-      && node !== undefined
-      && bindingGeneration !== undefined
+      !nativeAttempted &&
+      actorRef !== undefined &&
+      node !== undefined &&
+      bindingGeneration !== undefined
     ) {
       const result = await this.options.runtime.sendNativeBoundSession(
         node,

package/src/runtime/streams/protocol.ts

@@ -30,20 +30,28 @@ export enum ZLinkStreamCodec {
 
 export function streamCodecContentType(codec: ZLinkStreamCodec): string {
   switch (codec) {
-    case ZLinkStreamCodec.Json: return 'application/json';
-    case ZLinkStreamCodec.MessagePack: return 'application/x-msgpack';
-    case ZLinkStreamCodec.Protobuf: return 'application/x-protobuf';
-    case ZLinkStreamCodec.Raw: return 'application/octet-stream';
+    case ZLinkStreamCodec.Json:
+      return 'application/json';
+    case ZLinkStreamCodec.MessagePack:
+      return 'application/x-msgpack';
+    case ZLinkStreamCodec.Protobuf:
+      return 'application/x-protobuf';
+    case ZLinkStreamCodec.Raw:
+      return 'application/octet-stream';
   }
   throw new TypeError(`Unsupported STREAM codec '${codec}'.`);
 }
 
 export function streamCodecForContentType(contentType: string): ZLinkStreamCodec {
   switch (contentType) {
-    case 'application/json': return ZLinkStreamCodec.Json;
-    case 'application/x-msgpack': return ZLinkStreamCodec.MessagePack;
-    case 'application/x-protobuf': return ZLinkStreamCodec.Protobuf;
-    case 'application/octet-stream': return ZLinkStreamCodec.Raw;
+    case 'application/json':
+      return ZLinkStreamCodec.Json;
+    case 'application/x-msgpack':
+      return ZLinkStreamCodec.MessagePack;
+    case 'application/x-protobuf':
+      return ZLinkStreamCodec.Protobuf;
+    case 'application/octet-stream':
+      return ZLinkStreamCodec.Raw;
   }
   throw new TypeError(`Unsupported STREAM content type '${contentType}'.`);
 }
@@ -90,15 +98,17 @@ export interface ZLinkStreamFrameHeader {
 }
 
 export type ZLinkStreamReplyMessageKind =
-  | ZLinkStreamMessageKind.Response
-  | ZLinkStreamMessageKind.Error;
+  ZLinkStreamMessageKind.Response | ZLinkStreamMessageKind.Error;
 
 export interface ZLinkStreamFrame {
   readonly header: Uint8Array;
   readonly payload: Uint8Array;
 }
 
-export function resolvePacketName(message: unknown, explicitPacketName: string | undefined): string {
+export function resolvePacketName(
+  message: unknown,
+  explicitPacketName: string | undefined
+): string {
   const packetName = resolveFrameworkPacketName(message, explicitPacketName, 'Stream');
   if (packetName.trim().length === 0) {
     throw new Error('Stream packet name must not be empty.');
@@ -117,13 +127,16 @@ export function encodeStreamFrame(header: ZLinkStreamFrameHeader, payload: Uint8
 }
 
 export function encodeStreamControlFrame(name: string): Uint8Array {
-  return encodeStreamFrame({
-    kind: ZLinkStreamMessageKind.Control,
-    codec: ZLinkStreamCodec.Raw,
-    flags: ZLinkStreamHeaderFlags.None,
-    name,
-    metadata: EMPTY_STREAM_METADATA
-  }, new Uint8Array());
+  return encodeStreamFrame(
+    {
+      kind: ZLinkStreamMessageKind.Control,
+      codec: ZLinkStreamCodec.Raw,
+      flags: ZLinkStreamHeaderFlags.None,
+      name,
+      metadata: EMPTY_STREAM_METADATA
+    },
+    new Uint8Array()
+  );
 }
 
 export function encodeSessionClosingFrame(
@@ -138,13 +151,16 @@ export function encodeSessionClosingFrame(
   payload[2] = diagnosticBytes.length >>> 8;
   payload[3] = diagnosticBytes.length & 0xff;
   payload.set(diagnosticBytes, 4);
-  return encodeStreamFrame({
-    kind: ZLinkStreamMessageKind.Control,
-    codec: ZLinkStreamCodec.Raw,
-    flags: ZLinkStreamHeaderFlags.None,
-    name: 'session-closing',
-    metadata: new Map()
-  }, payload);
+  return encodeStreamFrame(
+    {
+      kind: ZLinkStreamMessageKind.Control,
+      codec: ZLinkStreamCodec.Raw,
+      flags: ZLinkStreamHeaderFlags.None,
+      name: 'session-closing',
+      metadata: new Map()
+    },
+    payload
+  );
 }
 
 export function decodeStreamFrame(frame: Uint8Array): ZLinkStreamFrame {
@@ -160,8 +176,13 @@ export function encodeStreamHeader(header: ZLinkStreamFrameHeader): Uint8Array {
   const hasMetadata = header.metadata.size > 0;
   const hasCorrelation = header.correlationId !== undefined && header.correlationId.length > 0;
   const hasFlow = header.flowId !== undefined || header.flowOrigin !== undefined;
-  if (header.kind === ZLinkStreamMessageKind.Control && (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow)) {
-    throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
+  if (
+    header.kind === ZLinkStreamMessageKind.Control &&
+    (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow)
+  ) {
+    throw new Error(
+      'Control packet must not contain a request sequence, metadata, correlation id, or flow id.'
+    );
   }
   //  Explicit construction: this runs for every outbound frame, so avoid a
   //  per-message spread of the whole header.
@@ -178,10 +199,7 @@ export function encodeStreamHeader(header: ZLinkStreamFrameHeader): Uint8Array {
   });
 }
 
-export function decodeStreamHeader(
-  header: Uint8Array,
-  flowEnabled = true
-): ZLinkStreamFrameHeader {
+export function decodeStreamHeader(header: Uint8Array, flowEnabled = true): ZLinkStreamFrameHeader {
   const decoded = decodeStreamWireHeader(header, undefined, flowEnabled);
   const kind = decoded.kind as ZLinkStreamMessageKind;
   const flags = decoded.flags as ZLinkStreamHeaderFlags;
@@ -189,16 +207,21 @@ export function decodeStreamHeader(
   const hasMetadata = (flags & ZLinkStreamHeaderFlags.HasMetadata) !== 0;
   const hasCorrelation = (flags & ZLinkStreamHeaderFlags.HasCorrelationId) !== 0;
   const hasFlow = (flags & ZLinkStreamHeaderFlags.HasFlowId) !== 0;
-  if (kind === ZLinkStreamMessageKind.Control && (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow)) {
-    throw new Error('Control packet must not contain a request sequence, metadata, correlation id, or flow id.');
+  if (
+    kind === ZLinkStreamMessageKind.Control &&
+    (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow)
+  ) {
+    throw new Error(
+      'Control packet must not contain a request sequence, metadata, correlation id, or flow id.'
+    );
   }
   const metadata = publicStreamMetadata(decoded.metadata);
   return {
     kind,
     codec: decoded.codec as ZLinkStreamCodec,
-    flags: (metadata.size === 0
-      ? flags & ~ZLinkStreamHeaderFlags.HasMetadata
-      : flags) & (flowEnabled ? ~0 : ~ZLinkStreamHeaderFlags.HasFlowId),
+    flags:
+      (metadata.size === 0 ? flags & ~ZLinkStreamHeaderFlags.HasMetadata : flags) &
+      (flowEnabled ? ~0 : ~ZLinkStreamHeaderFlags.HasFlowId),
     requestSeq: decoded.requestSeq,
     name: decoded.name,
     metadata,
@@ -208,7 +231,9 @@ export function decodeStreamHeader(
   };
 }
 
-export function actorRequestDeadlineMetadata(deadlineUnixMs: number | undefined): ReadonlyMap<string, string> {
+export function actorRequestDeadlineMetadata(
+  deadlineUnixMs: number | undefined
+): ReadonlyMap<string, string> {
   return deadlineUnixMs === undefined
     ? EMPTY_STREAM_METADATA
     : new Map([[actorRequestDeadlineMetadataKey, String(deadlineUnixMs)]]);
@@ -250,18 +275,20 @@ export function createStreamReplyHeader(
     // observation-only and is not copied into the reply when tracing is Off
     // (spec 27 §4, §7).
     correlationId: requestHeader.correlationId,
-    ...(includeFlow
-      ? { flowId: requestHeader.flowId, flowOrigin: requestHeader.flowOrigin }
-      : {})
+    ...(includeFlow ? { flowId: requestHeader.flowId, flowOrigin: requestHeader.flowOrigin } : {})
   };
 }
 
 function encodeFlowOrigin(origin: ZLinkFlowOrigin | undefined): number | undefined {
-  return origin === undefined ? undefined : ({ Inbound: 1, Timer: 2, Application: 3, Lifecycle: 4 } as const)[origin];
+  return origin === undefined
+    ? undefined
+    : ({ Inbound: 1, Timer: 2, Application: 3, Lifecycle: 4 } as const)[origin];
 }
 
 function decodeFlowOrigin(origin: number | undefined): ZLinkFlowOrigin | undefined {
-  return origin === undefined ? undefined : ({ 1: 'Inbound', 2: 'Timer', 3: 'Application', 4: 'Lifecycle' } as const)[origin];
+  return origin === undefined
+    ? undefined
+    : ({ 1: 'Inbound', 2: 'Timer', 3: 'Application', 4: 'Lifecycle' } as const)[origin];
 }
 
 export function messageToBytes(message: Message): Uint8Array {
@@ -286,6 +313,9 @@ export function lz4Pickle(payload: Uint8Array): Uint8Array {
   return lz4PickleUncompressed(payload);
 }
 
-export function lz4Unpickle(payload: Uint8Array, maxDecompressedSize = defaultMaxDecompressedPayloadSize): Uint8Array {
+export function lz4Unpickle(
+  payload: Uint8Array,
+  maxDecompressedSize = defaultMaxDecompressedPayloadSize
+): Uint8Array {
   return lz4UnpicklePayload(payload, maxDecompressedSize);
 }