@zlink-systems/framework 0.21.0 → 0.22.0

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,8 +129,9 @@ 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) {
@@ -160,9 +163,12 @@ export class ZLinkSessionActorCoordinator {
         sessionIdentity
       );
     }
-    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 +180,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 +232,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 +336,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 +350,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 +382,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 +397,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 +474,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 +485,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 +522,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 +546,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 +590,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 {

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

@@ -36,10 +36,7 @@ import {
   DefaultZLinkSessionReplyCall,
   DefaultZLinkSessionSendCall
 } from './session-calls';
-import {
-  ZLinkSessionRequestTracker,
-  type ZLinkPendingSessionRequest
-} from './session-requests';
+import { ZLinkSessionRequestTracker, type ZLinkPendingSessionRequest } from './session-requests';
 import { ZLinkSessionLocalActorBindings } from './session-local-actors';
 import type { ServiceActorRef } from '../foundation/service-stateful-registry';
 import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
@@ -126,10 +123,13 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
     correlationId: string | undefined
   ) => void;
   private closingForActorReplacement = false;
-  private readonly retiredActorBindings = new Map<string, {
-    readonly actorGeneration: bigint;
-    readonly retiredSession: ServiceRetiredBoundSessionRouteFence;
-  }>();
+  private readonly retiredActorBindings = new Map<
+    string,
+    {
+      readonly actorGeneration: bigint;
+      readonly retiredSession: ServiceRetiredBoundSessionRouteFence;
+    }
+  >();
 
   constructor(
     private readonly runtime: ZLinkSessionContextRuntime,
@@ -173,11 +173,13 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
   }
 
   /** Wired by the owning session runtime; see ZLinkSessionCallContext.traceFrameWritten. */
-  setFrameWrittenObserver(observer: (
-    kind: ZLinkStreamMessageKind,
-    packetName: string,
-    correlationId: string | undefined
-  ) => void): void {
+  setFrameWrittenObserver(
+    observer: (
+      kind: ZLinkStreamMessageKind,
+      packetName: string,
+      correlationId: string | undefined
+    ) => void
+  ): void {
     this.frameWrittenObserver = observer;
   }
 
@@ -199,9 +201,9 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
   ): boolean {
     const previous = this.retiredActorBindings.get(actor.actorId);
     if (
-      previous !== undefined
-      && previous.actorGeneration === actor.generation
-      && sameRetiredSession(previous.retiredSession, retiredSession)
+      previous !== undefined &&
+      previous.actorGeneration === actor.generation &&
+      sameRetiredSession(previous.retiredSession, retiredSession)
     ) {
       return false;
     }
@@ -219,17 +221,19 @@ export class DefaultZLinkSessionContext implements ZLinkSessionContext {
   ): boolean {
     const expected = this.retiredActorBindings.get(actor.actorId);
     if (
-      expected === undefined
-      || expected.actorGeneration !== actor.generation
-      || !sameRetiredSession(expected.retiredSession, retiredSession)
+      expected === undefined ||
+      expected.actorGeneration !== actor.generation ||
+      !sameRetiredSession(expected.retiredSession, retiredSession)
     ) {
       return false;
     }
     const current = this.findBoundActor(actor.actorId);
     if (current === undefined) return true;
     const currentRef = current.ref as ActorRef & { readonly bindingGeneration?: bigint };
-    return BigInt(currentRef.objectGeneration) === actor.generation
-      && currentRef.bindingGeneration === retiredSession.retiredBindingGeneration;
+    return (
+      BigInt(currentRef.objectGeneration) === actor.generation &&
+      currentRef.bindingGeneration === retiredSession.retiredBindingGeneration
+    );
   }
 
   createTextMessage(payload: string): Message {
@@ -372,13 +376,14 @@ class DefaultZLinkSessionHandlerRegistry implements ZLinkSessionHandlerRegistry
         `Session packet '${packetName}' is already registered.`
       );
     }
-    if (typeof (handlerType as { prototype?: { handle?: unknown } }).prototype?.handle !== 'function') {
+    if (
+      typeof (handlerType as { prototype?: { handle?: unknown } }).prototype?.handle !== 'function'
+    ) {
       throw new TypeError(`Session handler '${handlerType.name}' must implement handle(...).`);
     }
-    this.handlersByPacket.set(
-      packetName,
-      { handlerType: handlerType as Type<ZLinkSessionPacketHandler<ZLinkSessionContext>> }
-    );
+    this.handlersByPacket.set(packetName, {
+      handlerType: handlerType as Type<ZLinkSessionPacketHandler<ZLinkSessionContext>>
+    });
     return this;
   }
 
@@ -386,7 +391,10 @@ class DefaultZLinkSessionHandlerRegistry implements ZLinkSessionHandlerRegistry
     this.registrationOpen = false;
   }
 
-  async tryHandle(dispatch: import('../../contracts').ZLinkSessionDispatchContext, payload: ZLinkMessage): Promise<boolean> {
+  async tryHandle(
+    dispatch: import('../../contracts').ZLinkSessionDispatchContext,
+    payload: ZLinkMessage
+  ): Promise<boolean> {
     const registration = this.handlersByPacket.get(dispatch.packetName);
     if (registration === undefined) {
       return false;
@@ -407,9 +415,11 @@ class DefaultZLinkSessionHandlerRegistry implements ZLinkSessionHandlerRegistry
   private async createHandler(
     handlerType: Type<ZLinkSessionPacketHandler<ZLinkSessionContext>>
   ): Promise<ZLinkSessionPacketHandler<ZLinkSessionContext>> {
-    return this.providerResolver?.get?.(handlerType)
-      ?? await this.providerResolver?.create?.(handlerType)
-      ?? new handlerType();
+    return (
+      this.providerResolver?.get?.(handlerType) ??
+      (await this.providerResolver?.create?.(handlerType)) ??
+      new handlerType()
+    );
   }
 }
 
@@ -420,7 +430,8 @@ interface SessionHandlerRegistration {
 
 function sessionHandlerPacketName(handlerType: new (...args: never[]) => unknown): string {
   const declared = readZLinkDecoratorMetadata(handlerType)
-    .find((metadata) => metadata.kind === 'packet')?.packetName?.trim();
+    .find((metadata) => metadata.kind === 'packet')
+    ?.packetName?.trim();
   if (declared === undefined || declared.length === 0) {
     throw new ZLinkConfigurationException(
       `Session handler '${handlerType.name}' must declare a packet name with @ZLinkPacket(...).`
@@ -489,9 +500,9 @@ export class DefaultZLinkSessionActor implements ZLinkSessionActor {
     }
     if (BigInt(ref.objectGeneration) !== BigInt(this.currentRef.objectGeneration)) {
       throw new Error(
-        `Cannot change session actor '${this.actorId}' object generation `
-          + `from ${String(this.currentRef.objectGeneration)} `
-          + `to ${String(ref.objectGeneration)}.`
+        `Cannot change session actor '${this.actorId}' object generation ` +
+          `from ${String(this.currentRef.objectGeneration)} ` +
+          `to ${String(ref.objectGeneration)}.`
       );
     }
     this.currentRef = ref;
@@ -508,9 +519,7 @@ export class DefaultZLinkSessionActor implements ZLinkSessionActor {
     payloadOrSignal?: ZLinkMessage | AbortSignal,
     signal?: AbortSignal
   ): Promise<void> {
-    const dispatch = isSessionDispatchContext(dispatchOrPayload)
-      ? dispatchOrPayload
-      : undefined;
+    const dispatch = isSessionDispatchContext(dispatchOrPayload) ? dispatchOrPayload : undefined;
     let payload: ZLinkMessage;
     let relaySignal: AbortSignal | undefined;
     let header: ZLinkStreamFrameHeader | undefined;
@@ -537,7 +546,9 @@ export class DefaultZLinkSessionActor implements ZLinkSessionActor {
 
 const SESSION_DISPATCH_HEADERS = new WeakMap<ZLinkSessionDispatchContext, ZLinkStreamFrameHeader>();
 
-export function createSessionDispatchContext(header: ZLinkStreamFrameHeader): ZLinkSessionDispatchContext {
+export function createSessionDispatchContext(
+  header: ZLinkStreamFrameHeader
+): ZLinkSessionDispatchContext {
   const dispatch: ZLinkSessionDispatchContext = {
     packetName: header.name,
     metadata: header.metadata,
@@ -548,15 +559,20 @@ export function createSessionDispatchContext(header: ZLinkStreamFrameHeader): ZL
 }
 
 function isSessionDispatchContext(value: unknown): value is ZLinkSessionDispatchContext {
-  return value !== null && typeof value === 'object'
-    && typeof (value as ZLinkSessionDispatchContext).packetName === 'string'
-    && 'canReply' in value;
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as ZLinkSessionDispatchContext).packetName === 'string' &&
+    'canReply' in value
+  );
 }
 
 function sessionDispatchHeader(dispatch: ZLinkSessionDispatchContext): ZLinkStreamFrameHeader {
   const header = SESSION_DISPATCH_HEADERS.get(dispatch);
   if (header === undefined) {
-    throw new Error('Session actor relay dispatch must be the context supplied to the active session handler.');
+    throw new Error(
+      'Session actor relay dispatch must be the context supplied to the active session handler.'
+    );
   }
   return header;
 }
@@ -600,10 +616,12 @@ function sameRetiredSession(
   left: ServiceRetiredBoundSessionRouteFence,
   right: ServiceRetiredBoundSessionRouteFence
 ): boolean {
-  return left.sessionOwnerNodeRid === right.sessionOwnerNodeRid
-    && left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration
-    && left.sessionOwnerId === right.sessionOwnerId
-    && left.sessionOwnerLeaseGeneration === right.sessionOwnerLeaseGeneration
-    && left.sessionRid === right.sessionRid
-    && left.retiredBindingGeneration === right.retiredBindingGeneration;
+  return (
+    left.sessionOwnerNodeRid === right.sessionOwnerNodeRid &&
+    left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration &&
+    left.sessionOwnerId === right.sessionOwnerId &&
+    left.sessionOwnerLeaseGeneration === right.sessionOwnerLeaseGeneration &&
+    left.sessionRid === right.sessionRid &&
+    left.retiredBindingGeneration === right.retiredBindingGeneration
+  );
 }

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

@@ -1,8 +1,4 @@
-import type {
-  Type,
-  ZLinkSession,
-  ZLinkSessionFactory
-} from '../../contracts';
+import type { Type, ZLinkSession, ZLinkSessionFactory } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { DefaultZLinkSessionContext } from './session-context';
 
@@ -45,6 +41,8 @@ async function createProviderInstance<T>(
 }
 
 function isSessionFactory(value: unknown): value is ZLinkSessionFactory {
-  return typeof (value as { create?: unknown }).create === 'function'
-    && (value as { context?: unknown }).context === undefined;
+  return (
+    typeof (value as { create?: unknown }).create === 'function' &&
+    (value as { context?: unknown }).context === undefined
+  );
 }

package/src/runtime/streams/session-serial-executor.ts

@@ -46,10 +46,12 @@ export class ZLinkSessionSerialExecutor {
 
   executeFinal(work: () => Promise<void>): Promise<void> {
     if (this.closed) {
-      return Promise.reject(createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.RuntimeShutdown,
-        'Session execution queue is closed.'
-      ));
+      return Promise.reject(
+        createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.RuntimeShutdown,
+          'Session execution queue is closed.'
+        )
+      );
     }
     const boundWork = bindApplicationJobPermit(work);
     return hasApplicationJobPermit()
@@ -69,8 +71,7 @@ export class ZLinkSessionSerialExecutor {
     const submitted = hasApplicationJobPermit()
       ? this.scheduler.submitPreAdmitted(boundWork, serialOptions)
       : this.scheduler.submit(boundWork, serialOptions);
-    void submitted
-      .catch(error => onRejected?.(error));
+    void submitted.catch((error) => onRejected?.(error));
     return true;
   }