@zlink-systems/framework 0.21.0 → 0.23.0

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}'.`);
 }
@@ -62,7 +70,8 @@ export enum ZLinkStreamHeaderFlags {
   HasMetadata = 0x02,
   PayloadCompressed = 0x04,
   HasCorrelationId = 0x08,
-  HasFlowId = 0x10
+  HasFlowId = 0x10,
+  HasActorSlot = 0x20
 }
 
 export enum ZLinkStreamCloseReasonCode {
@@ -87,18 +96,21 @@ export interface ZLinkStreamFrameHeader {
   readonly correlationId?: string;
   readonly flowId?: string;
   readonly flowOrigin?: ZLinkFlowOrigin;
+  readonly actorSlot?: number;
 }
 
 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 +129,38 @@ 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 encodeActorBoundFrame(actorSlot: number, actorId: string): Uint8Array {
+  const actorIdBytes = utf8Encode(actorId);
+  if (actorIdBytes.length < 1 || actorIdBytes.length > 0xff) {
+    throw new Error('Actor id length is invalid for a STREAM binding control packet.');
+  }
+  const payload = new Uint8Array(4 + actorIdBytes.length);
+  payload[0] = 1;
+  payload[1] = actorSlot >>> 8;
+  payload[2] = actorSlot & 0xff;
+  payload[3] = actorIdBytes.length;
+  payload.set(actorIdBytes, 4);
+  return encodeStreamFrame(controlHeader('$zlink.actor.bound'), payload);
+}
+
+export function encodeActorUnboundFrame(actorSlot: number): Uint8Array {
+  const payload = new Uint8Array(3);
+  payload[0] = 1;
+  payload[1] = actorSlot >>> 8;
+  payload[2] = actorSlot & 0xff;
+  return encodeStreamFrame(controlHeader('$zlink.actor.unbound'), payload);
 }
 
 export function encodeSessionClosingFrame(
@@ -138,13 +175,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 +200,14 @@ 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.');
+  const hasActorSlot = header.actorSlot !== undefined;
+  if (
+    header.kind === ZLinkStreamMessageKind.Control &&
+    (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)
+  ) {
+    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.
@@ -174,14 +220,12 @@ export function encodeStreamHeader(header: ZLinkStreamFrameHeader): Uint8Array {
     metadata: header.metadata,
     correlationId: header.correlationId,
     flowId: header.flowId,
-    flowOrigin: encodeFlowOrigin(header.flowOrigin)
+    flowOrigin: encodeFlowOrigin(header.flowOrigin),
+    actorSlot: header.actorSlot
   });
 }
 
-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,26 +233,35 @@ 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.');
+  const hasActorSlot = (flags & ZLinkStreamHeaderFlags.HasActorSlot) !== 0;
+  if (
+    kind === ZLinkStreamMessageKind.Control &&
+    (hasCorrelation || hasRequestSeq || hasMetadata || hasFlow || hasActorSlot)
+  ) {
+    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,
     correlationId: decoded.correlationId,
     flowId: decoded.flowId,
-    flowOrigin: decodeFlowOrigin(decoded.flowOrigin)
+    flowOrigin: decodeFlowOrigin(decoded.flowOrigin),
+    actorSlot: decoded.actorSlot
   };
 }
 
-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 +303,31 @@ 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 }
-      : {})
+    actorSlot: requestHeader.actorSlot,
+    ...(includeFlow ? { flowId: requestHeader.flowId, flowOrigin: requestHeader.flowOrigin } : {})
+  };
+}
+
+function controlHeader(name: string): ZLinkStreamFrameHeader {
+  return {
+    kind: ZLinkStreamMessageKind.Control,
+    codec: ZLinkStreamCodec.Raw,
+    flags: ZLinkStreamHeaderFlags.None,
+    name,
+    metadata: EMPTY_STREAM_METADATA
   };
 }
 
 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 +352,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);
 }

package/src/runtime/streams/session-actor-coordinator.ts

@@ -1,9 +1,8 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } from '../framework-errors-internal';
 import {
-  ActorRef,
-  ZLinkActor,
-  ZLinkFrameworkException
-} from '../../contracts';
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
+import { ActorRef, ZLinkActor, ZLinkFrameworkException } from '../../contracts';
 import { throwIfAborted } from '../abort';
 import { routingIdsEqual } from '../routing-id';
 import type { ZLinkRuntimeMetrics } from '../diagnostics';
@@ -12,13 +11,8 @@ import {
   type ZLinkActorSessionAuthorityFence
 } from './actor-session-binding-registry';
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
-import {
-  ZLinkManagedStream
-} from './managed-stream';
-import {
-  DefaultZLinkSessionActor,
-  DefaultZLinkSessionContext
-} from './session-context';
+import { ZLinkManagedStream } from './managed-stream';
+import { DefaultZLinkSessionActor, DefaultZLinkSessionContext } from './session-context';
 
 export interface ZLinkSessionActorCoordinatorOptions {
   readonly actorBindTimeoutMs?: number;
@@ -27,9 +21,11 @@ export interface ZLinkSessionActorCoordinatorOptions {
     actorId: string,
     signal?: AbortSignal
   ) => Promise<ZLinkActorSessionAuthorityFence | undefined>;
-  readonly nativeActorNodeProvider?: () => {
-    status(): { readonly routingId: unknown };
-  } | undefined;
+  readonly nativeActorNodeProvider?: () =>
+    | {
+        status(): { readonly routingId: unknown };
+      }
+    | undefined;
   readonly nativeActorMeshNameProvider?: () => string | undefined;
   readonly confirmRemoteActorSessionBinding?: (
     actor: ActorRef,
@@ -37,15 +33,20 @@ export interface ZLinkSessionActorCoordinatorOptions {
     signal?: AbortSignal,
     options?: { readonly waitForAcknowledgement?: boolean }
   ) => Promise<void>;
-  readonly errorSink?: () => {
-    reportRuntimeTaskException(taskName: string, error: unknown): void;
-  } | undefined;
+  readonly errorSink?: () =>
+    | {
+        reportRuntimeTaskException(taskName: string, error: unknown): void;
+      }
+    | undefined;
   readonly metrics?: ZLinkRuntimeMetrics;
 }
 
 export class ZLinkSessionActorCoordinator {
   constructor(
-    private readonly routes: ZLinkActorSessionBindingRegistry<DefaultZLinkSessionContext, DefaultZLinkSessionActor>,
+    private readonly routes: ZLinkActorSessionBindingRegistry<
+      DefaultZLinkSessionContext,
+      DefaultZLinkSessionActor
+    >,
     private readonly sessionActorRuntime: ConstructorParameters<typeof DefaultZLinkSessionActor>[0],
     private readonly options: ZLinkSessionActorCoordinatorOptions = {},
     private readonly lifecycle = new ZLinkActorSessionLifecycleCoordinator()
@@ -59,7 +60,9 @@ export class ZLinkSessionActorCoordinator {
     const actorRef = isActorRefLike(actorOrRef)
       ? normalizeActorRef(actorOrRef, this.options.nativeActorMeshNameProvider?.())
       : this.resolveActorRef(actorOrRef as ZLinkActor);
-    return await this.lifecycle.run(actorRef.actorId, async () => this.replaceBinding(context, actorRef, signal));
+    return await this.lifecycle.run(actorRef.actorId, async () =>
+      this.replaceBinding(context, actorRef, signal)
+    );
   }
 
   private async replaceBinding(
@@ -101,13 +104,12 @@ export class ZLinkSessionActorCoordinator {
 
     const previous = await this.routes.route(actorRef.actorId);
     const sameIncarnation =
-      previous !== undefined
-      && previous.context === context
-      && previous.actor.ref.actorId === actorRef.actorId
-      && BigInt(previous.actor.ref.objectGeneration) === BigInt(actorRef.objectGeneration);
+      previous !== undefined &&
+      previous.context === context &&
+      previous.actor.ref.actorId === actorRef.actorId &&
+      BigInt(previous.actor.ref.objectGeneration) === BigInt(actorRef.objectGeneration);
     const samePhysicalBinding = sameIncarnation && sameActorRef(previous!.actor.ref, actorRef);
-    const reuseActor =
-      sameIncarnation ? previous!.actor : undefined;
+    const reuseActor = sameIncarnation ? previous!.actor : undefined;
     if (reuseActor !== undefined) {
       // A repeated bind from the same physical session is idempotent. A route
       // refresh for the same actor incarnation still submits the native bind,
@@ -127,10 +129,10 @@ export class ZLinkSessionActorCoordinator {
         : undefined,
       previous?.actor.ref
     );
-    const sessionActor = reuseActor
-      ?? new DefaultZLinkSessionActor(this.sessionActorRuntime, boundActorRef, bindingToken);
+    const sessionActor =
+      reuseActor ??
+      new DefaultZLinkSessionActor(this.sessionActorRuntime, boundActorRef, bindingToken);
     const sessionIdentity = String(this.actorBindingRoutingId(context));
-    sessionActor.updateRef(boundActorRef);
     if (previous === undefined) {
       if (releaseSeal !== undefined) {
         throw createInternalFrameworkException(
@@ -139,7 +141,14 @@ export class ZLinkSessionActorCoordinator {
           true
         );
       }
-      await this.routes.bind(context, sessionActor, bindingToken, authorityFence, sessionIdentity);
+      await this.routes.bind(
+        context,
+        sessionActor,
+        bindingToken,
+        authorityFence,
+        sessionIdentity,
+        () => sessionActor.updateRef(boundActorRef)
+      );
     } else if (releaseSeal !== undefined) {
       await this.routes.replaceAndReleaseSeal(
         previous,
@@ -148,7 +157,8 @@ export class ZLinkSessionActorCoordinator {
         bindingToken,
         releaseSeal.sealId,
         authorityFence,
-        sessionIdentity
+        sessionIdentity,
+        () => sessionActor.updateRef(boundActorRef)
       );
     } else {
       await this.routes.replace(
@@ -157,12 +167,16 @@ export class ZLinkSessionActorCoordinator {
         sessionActor,
         bindingToken,
         authorityFence,
-        sessionIdentity
+        sessionIdentity,
+        () => sessionActor.updateRef(boundActorRef)
       );
     }
-    if (confirmRemoteSessionBinding !== false && this.options.confirmRemoteActorSessionBinding !== undefined) {
-      const waitForAcknowledgement = previous === undefined
-        && confirmRemoteSessionBinding !== 'send';
+    if (
+      confirmRemoteSessionBinding !== false &&
+      this.options.confirmRemoteActorSessionBinding !== undefined
+    ) {
+      const waitForAcknowledgement =
+        previous === undefined && confirmRemoteSessionBinding !== 'send';
       const confirmation = this.options.confirmRemoteActorSessionBinding(
         boundActorRef,
         this.actorBindingRoutingId(context),
@@ -174,10 +188,9 @@ export class ZLinkSessionActorCoordinator {
         // its failure is bounded diagnostics rather than a rollback. The
         // relay retries independently and reports the typed failure through
         // the runtime error sink instead of silently discarding it.
-        this.options.errorSink?.()?.reportRuntimeTaskException(
-          'remote session binding confirmation',
-          error
-        );
+        this.options
+          .errorSink?.()
+          ?.reportRuntimeTaskException('remote session binding confirmation', error);
       };
       if (waitForAcknowledgement) {
         try {
@@ -227,11 +240,11 @@ export class ZLinkSessionActorCoordinator {
       readonly ownerLeaseGeneration?: bigint;
       readonly ownerNodeGeneration?: bigint;
     };
-    if (internal.ownershipGeneration !== undefined
-      && internal.ownerLeaseGeneration !== undefined) {
-      const resolved = internal.ownerNodeGeneration === undefined
-        ? await this.options.actorAuthorityFenceResolver?.(actorRef.actorId, signal)
-        : undefined;
+    if (internal.ownershipGeneration !== undefined && internal.ownerLeaseGeneration !== undefined) {
+      const resolved =
+        internal.ownerNodeGeneration === undefined
+          ? await this.options.actorAuthorityFenceResolver?.(actorRef.actorId, signal)
+          : undefined;
       return {
         authorityOwnerGeneration: internal.ownershipGeneration,
         ownerLeaseGeneration: internal.ownerLeaseGeneration,
@@ -331,11 +344,10 @@ export class ZLinkSessionActorCoordinator {
       requireSameIncarnation(route.actor.ref, normalizedActorRef);
       if (routingIdsEqual(route.actor.ref.nodeRid, normalizedActorRef.nodeRid)) {
         const authorityFence = await this.resolveAuthorityFence(normalizedActorRef, signal);
-        if (options.releaseSeal !== undefined
-          && !await this.routes.validateSeal(
-            normalizedActorRef.actorId,
-            options.releaseSeal.sealId
-          )) {
+        if (
+          options.releaseSeal !== undefined &&
+          !(await this.routes.validateSeal(normalizedActorRef.actorId, options.releaseSeal.sealId))
+        ) {
           throw createInternalFrameworkException(
             ZLinkFrameworkInternalErrorKind.ActorLocationStale,
             `Actor '${normalizedActorRef.actorId}' route switch did not match its relocation seal.`,
@@ -346,11 +358,10 @@ export class ZLinkSessionActorCoordinator {
         if (authorityFence !== undefined) {
           await this.routes.updateAuthorityFence(normalizedActorRef.actorId, authorityFence);
         }
-        if (options.releaseSeal !== undefined
-          && !await this.routes.abortSeal(
-            normalizedActorRef.actorId,
-            options.releaseSeal.sealId
-          )) {
+        if (
+          options.releaseSeal !== undefined &&
+          !(await this.routes.abortSeal(normalizedActorRef.actorId, options.releaseSeal.sealId))
+        ) {
           throw createInternalFrameworkException(
             ZLinkFrameworkInternalErrorKind.ActorLocationStale,
             `Actor '${normalizedActorRef.actorId}' route switch lost its relocation seal.`,
@@ -379,10 +390,10 @@ export class ZLinkSessionActorCoordinator {
       throwIfAborted(signal);
       const route = await this.routes.route(actorRef.actorId);
       if (
-        route === undefined
-        || !sameActorRef(route.actor.ref, actorRef)
-        || !routingIdsEqual(route.sessionIdentity, sessionRid)
-        || bindingGenerationOf(route.actor.ref) !== bindingGeneration
+        route === undefined ||
+        !sameActorRef(route.actor.ref, actorRef) ||
+        !routingIdsEqual(route.sessionIdentity, sessionRid) ||
+        bindingGenerationOf(route.actor.ref) !== bindingGeneration
       ) {
         return false;
       }
@@ -394,26 +405,29 @@ export class ZLinkSessionActorCoordinator {
     });
   }
 
-  async authorityFence(actorId: string): Promise<{
-    readonly authorityOwnerGeneration: bigint;
-    readonly ownerLeaseGeneration: bigint;
-  } | undefined> {
+  async authorityFence(actorId: string): Promise<
+    | {
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+      }
+    | undefined
+  > {
     return (await this.routes.route(actorId))?.authorityFence;
   }
 
-  async sessionRouteFence(actorId: string): Promise<{
-    readonly actor: ActorRef;
-    readonly sessionRid: ActorRef['nodeRid'];
-    readonly bindingGeneration: bigint;
-  } | undefined> {
+  async sessionRouteFence(actorId: string): Promise<
+    | {
+        readonly actor: ActorRef;
+        readonly sessionRid: ActorRef['nodeRid'];
+        readonly bindingGeneration: bigint;
+      }
+    | undefined
+  > {
     const route = await this.routes.route(actorId);
     const sessionRid = route?.sessionIdentity;
-    const actor = route?.actor.ref as (ActorRef & { readonly bindingGeneration?: bigint }) | undefined;
-    if (
-      route === undefined
-      || sessionRid === undefined
-      || actor?.bindingGeneration === undefined
-    ) {
+    const actor = route?.actor.ref as
+      (ActorRef & { readonly bindingGeneration?: bigint }) | undefined;
+    if (route === undefined || sessionRid === undefined || actor?.bindingGeneration === undefined) {
       return undefined;
     }
     return {
@@ -468,9 +482,8 @@ export class ZLinkSessionActorCoordinator {
   private actorBindingRoutingId(context: DefaultZLinkSessionContext): ActorRef['nodeRid'] {
     return context.stream instanceof ZLinkManagedStream
       ? context.stream.actorBindingRoutingId
-      : context.routingId as ActorRef['nodeRid'];
+      : (context.routingId as ActorRef['nodeRid']);
   }
-
 }
 
 function withBindingGeneration(
@@ -480,9 +493,8 @@ function withBindingGeneration(
 ): ActorRef {
   const input = actorRef as ActorRef & { readonly bindingGeneration?: bigint };
   const previous = previousRef as (ActorRef & { readonly bindingGeneration?: bigint }) | undefined;
-  const bindingGeneration = nativeBindingGeneration
-    ?? input.bindingGeneration
-    ?? previous?.bindingGeneration;
+  const bindingGeneration =
+    nativeBindingGeneration ?? input.bindingGeneration ?? previous?.bindingGeneration;
   if (bindingGeneration === undefined) {
     return actorRef;
   }
@@ -518,10 +530,12 @@ function preserveInternalActorRefField(
   source: ActorRef,
   field: 'ownershipGeneration' | 'ownerLeaseGeneration'
 ): void {
-  const value = (source as ActorRef & {
-    readonly ownershipGeneration?: bigint;
-    readonly ownerLeaseGeneration?: bigint;
-  })[field];
+  const value = (
+    source as ActorRef & {
+      readonly ownershipGeneration?: bigint;
+      readonly ownerLeaseGeneration?: bigint;
+    }
+  )[field];
   if (value === undefined) return;
   Object.defineProperty(target, field, {
     configurable: false,
@@ -540,10 +554,10 @@ function isActorRefLike(
   value: ZLinkActor | ActorRef | CompatibleActorRef
 ): value is CompatibleActorRef {
   return (
-    typeof value === 'object'
-    && 'nodeRid' in value
-    && 'actorId' in value
-    && ('objectGeneration' in value || 'generation' in value)
+    typeof value === 'object' &&
+    'nodeRid' in value &&
+    'actorId' in value &&
+    ('objectGeneration' in value || 'generation' in value)
   );
 }
 
@@ -584,22 +598,24 @@ function createBindingToken(): string {
 }
 
 function sameActorRef(left: ActorRef, right: ActorRef): boolean {
-  return routingIdsEqual(left.nodeRid, right.nodeRid)
-    && left.actorId === right.actorId
-    && BigInt(left.objectGeneration) === BigInt(right.objectGeneration);
+  return (
+    routingIdsEqual(left.nodeRid, right.nodeRid) &&
+    left.actorId === right.actorId &&
+    BigInt(left.objectGeneration) === BigInt(right.objectGeneration)
+  );
 }
 
 function requireSameIncarnation(current: ActorRef, updated: ActorRef): void {
   if (
-    current.actorId === updated.actorId
-    && BigInt(current.objectGeneration) === BigInt(updated.objectGeneration)
+    current.actorId === updated.actorId &&
+    BigInt(current.objectGeneration) === BigInt(updated.objectGeneration)
   ) {
     return;
   }
   throw createInternalFrameworkException(
     ZLinkFrameworkInternalErrorKind.ActorLocationStale,
-    `Actor '${updated.actorId}' route update cannot replace object generation `
-      + `${String(current.objectGeneration)} with ${String(updated.objectGeneration)}.`,
+    `Actor '${updated.actorId}' route update cannot replace object generation ` +
+      `${String(current.objectGeneration)} with ${String(updated.objectGeneration)}.`,
     true
   );
 }

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

@@ -5,9 +5,7 @@ import type {
   ZLinkSessionSendCall
 } from '../../contracts';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
-import {
-  requireOneWayCompletion
-} from '../messaging/submission-result';
+import { requireOneWayCompletion } from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
 import { throwIfAborted } from '../abort';
 import { ZLinkConfigurationException } from '../configuration';
@@ -160,11 +158,7 @@ export class DefaultZLinkSessionSendCall implements ZLinkSessionSendCall {
       this.message
     );
     try {
-      const result = await this.context.stream.submitRaw(
-        message,
-        signal,
-        this.selectedTimeoutMs
-      );
+      const result = await this.context.stream.submitRaw(message, signal, this.selectedTimeoutMs);
       requireOneWayCompletion(result, 'STREAM session send');
       this.context.traceFrameWritten?.(ZLinkStreamMessageKind.Send, packetName, undefined);
     } finally {