@zlink-systems/framework 0.21.0 → 0.23.0

package/src/runtime/host/instance-activation-authority.ts

@@ -1,4 +1,7 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } from '../framework-errors-internal';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import { createHash } from 'node:crypto';
 import type {
   ZLinkLocationOwnerToken,
@@ -9,10 +12,11 @@ import type {
   ZLinkAuthorityKey,
   ZLinkAuthoritySnapshot
 } from '../locations/internal-location-contracts';
-import type { ZLinkAuthorityStore, ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
-import {
-  ZLinkFrameworkException
-} from '../../contracts';
+import type {
+  ZLinkAuthorityStore,
+  ZLinkObjectCreationStore
+} from '../locations/internal-store-contracts';
+import { ZLinkFrameworkException } from '../../contracts';
 import {
   decodeServiceInstanceAuthorityPayload,
   decodeServiceReadySpotAuthority,
@@ -32,13 +36,8 @@ import type {
 } from '../foundation/service-stateful-wire-codec';
 import { routingIdsEqual } from '../routing-id';
 import { encodeAuthorityKey } from '../locations/authority-key-codec';
-import {
-  crc32c
-} from '../foundation/service-relocation-runtime';
-import {
-  putNewRelocationBlob,
-  relocationBlobReference
-} from '../locations/relocation-blob';
+import { crc32c } from '../foundation/service-relocation-runtime';
+import { putNewRelocationBlob, relocationBlobReference } from '../locations/relocation-blob';
 
 import {
   encodeInstanceActivationRecoveryEnvelope,
@@ -70,17 +69,14 @@ export interface ZLinkInstanceActivationAuthorityOptions {
   ) => void;
 }
 
-export class ZLinkInstanceActivationAuthority
-implements ServiceAsyncInstanceActivationAuthority {
+export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceActivationAuthority {
   private readonly pending = new Map<string, PendingReservation>();
 
   constructor(private readonly options: ZLinkInstanceActivationAuthorityOptions) {}
 
   async read(target: ServiceInstanceActivationTarget): Promise<ServiceInstanceAuthorityRead> {
     const current = await this.options.store.readAuthority(authorityKey(target.targetSpotId));
-    return current.kind === 'snapshot'
-      ? readyRead(current, target)
-      : { kind: 'missing' };
+    return current.kind === 'snapshot' ? readyRead(current, target) : { kind: 'missing' };
   }
 
   async reserve(
@@ -107,11 +103,11 @@ implements ServiceAsyncInstanceActivationAuthority {
     );
     const storedRead = await relocationStore.read(stored.reference);
     if (
-      stored.reference.value.length === 0
-      || stored.expiresAt.getTime() <= stored.storeNow.getTime()
-      || storedRead.kind !== 'found'
-      || crc32c(storedRead.bytes) !== crc32c(requestBytes)
-      || !Buffer.from(storedRead.bytes).equals(requestBytes)
+      stored.reference.value.length === 0 ||
+      stored.expiresAt.getTime() <= stored.storeNow.getTime() ||
+      storedRead.kind !== 'found' ||
+      crc32c(storedRead.bytes) !== crc32c(requestBytes) ||
+      !Buffer.from(storedRead.bytes).equals(requestBytes)
     ) {
       await this.deleteOrphan(stored.reference);
       throw new Error('Relocation Store returned an invalid creation request receipt.');
@@ -154,9 +150,10 @@ implements ServiceAsyncInstanceActivationAuthority {
           }
         });
         if (reserved.kind === 'conflict' || reserved.kind === 'alreadyExists') {
-          const existingState = reserved.current.kind === 'snapshot'
-            ? decodeServiceInstanceAuthorityPayload(reserved.current.payload)?.state
-            : undefined;
+          const existingState =
+            reserved.current.kind === 'snapshot'
+              ? decodeServiceInstanceAuthorityPayload(reserved.current.payload)?.state
+              : undefined;
           if (existingState === 'closing') {
             await this.awaitClosingRelease(target, activation.deadlineUnixMs);
             continue;
@@ -176,11 +173,11 @@ implements ServiceAsyncInstanceActivationAuthority {
       throw error;
     }
     if (
-      reserved.kind === 'conflict'
-      && reserved.current.kind === 'snapshot'
-      && reserved.current.allocation.objectKind === 'instance_spot'
-      && reserved.current.allocation.stableType === target.stableType
-      && reserved.current.allocation.state === 'reserved'
+      reserved.kind === 'conflict' &&
+      reserved.current.kind === 'snapshot' &&
+      reserved.current.allocation.objectKind === 'instance_spot' &&
+      reserved.current.allocation.stableType === target.stableType &&
+      reserved.current.allocation.state === 'reserved'
     ) {
       this.options.metrics?.recordInstanceSpotClaimConflict(
         this.options.meshName,
@@ -228,22 +225,22 @@ implements ServiceAsyncInstanceActivationAuthority {
     const current = await this.options.store.readAuthority(authorityKey(target.targetSpotId));
     const projection = current.kind === 'snapshot' ? current.pendingCreation : undefined;
     if (
-      current.kind !== 'snapshot'
-      || current.allocation.state !== 'reserved'
-      || current.allocation.objectKind !== 'instance_spot'
-      || current.allocation.stableType !== target.stableType
-      || current.storeVersion.value !== pending.storeVersion
-      || current.objectGeneration !== pending.objectGeneration
-      || current.authorityOwnerGeneration !== pending.authorityOwnerGeneration
-      || current.ownerId !== pending.ownerId
-      || current.ownerLeaseGeneration !== pending.ownerLeaseGeneration
-      || current.allocation.descriptor.meshName !== pending.meshName
-      || !routingIdsEqual(current.allocation.descriptor.rid, pending.nodeRid)
-      || current.allocation.descriptorLifecycleGeneration !== pending.nodeGeneration
-      || projection?.reservationId !== pending.reservationId
-      || projection.requestContentReference !== pending.requestReference
-      || projection.requestEncodedSize !== pending.requestEncodedSize
-      || !Buffer.from(projection.requestSha256).equals(Buffer.from(pending.requestSha256))
+      current.kind !== 'snapshot' ||
+      current.allocation.state !== 'reserved' ||
+      current.allocation.objectKind !== 'instance_spot' ||
+      current.allocation.stableType !== target.stableType ||
+      current.storeVersion.value !== pending.storeVersion ||
+      current.objectGeneration !== pending.objectGeneration ||
+      current.authorityOwnerGeneration !== pending.authorityOwnerGeneration ||
+      current.ownerId !== pending.ownerId ||
+      current.ownerLeaseGeneration !== pending.ownerLeaseGeneration ||
+      current.allocation.descriptor.meshName !== pending.meshName ||
+      !routingIdsEqual(current.allocation.descriptor.rid, pending.nodeRid) ||
+      current.allocation.descriptorLifecycleGeneration !== pending.nodeGeneration ||
+      projection?.reservationId !== pending.reservationId ||
+      projection.requestContentReference !== pending.requestReference ||
+      projection.requestEncodedSize !== pending.requestEncodedSize ||
+      !Buffer.from(projection.requestSha256).equals(Buffer.from(pending.requestSha256))
     ) {
       throw new Error('Pending Instance activation recovery fence is stale.');
     }
@@ -259,9 +256,7 @@ implements ServiceAsyncInstanceActivationAuthority {
         ownerId: current.ownerId,
         leaseGeneration: current.ownerLeaseGeneration
       },
-      requestReference: relocationBlobReference(
-        projection.requestContentReference
-      ),
+      requestReference: relocationBlobReference(projection.requestContentReference),
       requestSha256: Buffer.from(projection.requestSha256),
       requestEncodedSize: Number(projection.requestEncodedSize)
     });
@@ -274,13 +269,7 @@ implements ServiceAsyncInstanceActivationAuthority {
     spot: ServiceSpotState
   ): Promise<{ readonly kind: 'committed' | 'lost'; readonly route: ServiceInstanceRouteFence }> {
     const pending = this.requirePending(reservation);
-    requireCommitIdentity(
-      target,
-      reservation,
-      pending.creating,
-      spot,
-      this.options.meshName
-    );
+    requireCommitIdentity(target, reservation, pending.creating, spot, this.options.meshName);
     let result;
     try {
       result = await this.options.store.commit({
@@ -348,16 +337,16 @@ implements ServiceAsyncInstanceActivationAuthority {
     }
     const decoded = decodeServiceReadySpotAuthority(current.payload);
     if (
-      decoded?.kind !== 'instance_spot'
-      || decoded.spotId !== target.targetSpotId
-      || decoded.stableType !== target.stableType
-      || current.allocation.state !== 'active'
-      || current.objectGeneration !== route.objectGeneration
-      || current.authorityOwnerGeneration !== route.authorityOwnerGeneration
-      || current.ownerId !== route.ownerId
-      || current.ownerLeaseGeneration !== route.leaseGeneration
-      || current.allocation.descriptorLifecycleGeneration !== route.targetNodeGeneration
-      || !routingIdsEqual(current.allocation.descriptor.rid, route.targetNodeRid)
+      decoded?.kind !== 'instance_spot' ||
+      decoded.spotId !== target.targetSpotId ||
+      decoded.stableType !== target.stableType ||
+      current.allocation.state !== 'active' ||
+      current.objectGeneration !== route.objectGeneration ||
+      current.authorityOwnerGeneration !== route.authorityOwnerGeneration ||
+      current.ownerId !== route.ownerId ||
+      current.ownerLeaseGeneration !== route.leaseGeneration ||
+      current.allocation.descriptorLifecycleGeneration !== route.targetNodeGeneration ||
+      !routingIdsEqual(current.allocation.descriptor.rid, route.targetNodeRid)
     ) {
       throw new Error('Instance activation authority changed before inbox release.');
     }
@@ -398,30 +387,26 @@ implements ServiceAsyncInstanceActivationAuthority {
     const completedPayload = decodeServiceReadySpotAuthority(completed.payload);
     const completedRecovery = completedPayload?.activationRecovery;
     if (
-      completedPayload?.kind !== 'instance_spot'
-      || completedRecovery === undefined
-      || completedRecovery.replayCursor !== completedRecovery.inboxSequence
+      completedPayload?.kind !== 'instance_spot' ||
+      completedRecovery === undefined ||
+      completedRecovery.replayCursor !== completedRecovery.inboxSequence
     ) {
       throw new Error('Instance activation terminal completion was not durably recorded.');
     }
-    const stored = await this.options.store.compareExchangeAuthority(
-      key,
-      completed.storeVersion,
-      {
-        kind: 'put',
-        generationTransition: 'preserve',
-        payload: encodeServiceInstanceAuthorityPayload({
-          state: 'ready',
-          stableType: completedPayload.stableType,
-          spotId: completedPayload.spotId,
-          ownerId: completedPayload.ownerId,
-          ownerLeaseGeneration: completedPayload.ownerLeaseGeneration,
-          ownerMeshName: completedPayload.ownerMeshName,
-          ownerNodeRid: completedPayload.ownerNodeRid,
-          ownerNodeGeneration: completedPayload.ownerNodeGeneration
-        })
-      }
-    );
+    const stored = await this.options.store.compareExchangeAuthority(key, completed.storeVersion, {
+      kind: 'put',
+      generationTransition: 'preserve',
+      payload: encodeServiceInstanceAuthorityPayload({
+        state: 'ready',
+        stableType: completedPayload.stableType,
+        spotId: completedPayload.spotId,
+        ownerId: completedPayload.ownerId,
+        ownerLeaseGeneration: completedPayload.ownerLeaseGeneration,
+        ownerMeshName: completedPayload.ownerMeshName,
+        ownerNodeRid: completedPayload.ownerNodeRid,
+        ownerNodeGeneration: completedPayload.ownerNodeGeneration
+      })
+    });
     if (stored.kind !== 'stored') {
       throw new Error(`Instance activation inbox release failed: ${stored.kind}.`);
     }
@@ -480,8 +465,8 @@ implements ServiceAsyncInstanceActivationAuthority {
       const current = await this.options.store.readAuthority(key);
       if (current.kind === 'snapshot') {
         if (
-          current.allocation.objectKind !== 'instance_spot'
-          || current.allocation.stableType !== target.stableType
+          current.allocation.objectKind !== 'instance_spot' ||
+          current.allocation.stableType !== target.stableType
         ) {
           throw new Error('Concurrent Instance activation resolved to a different Spot type.');
         }
@@ -509,10 +494,10 @@ implements ServiceAsyncInstanceActivationAuthority {
       if (current.kind !== 'snapshot') return;
       const decoded = decodeServiceInstanceAuthorityPayload(current.payload);
       if (
-        current.allocation.objectKind !== 'instance_spot'
-        || current.allocation.stableType !== target.stableType
-        || decoded?.kind !== 'instance_spot'
-        || decoded.spotId !== target.targetSpotId
+        current.allocation.objectKind !== 'instance_spot' ||
+        current.allocation.stableType !== target.stableType ||
+        decoded?.kind !== 'instance_spot' ||
+        decoded.spotId !== target.targetSpotId
       ) {
         throw new Error('Instance authority changed to a different Spot while closing.');
       }
@@ -526,10 +511,7 @@ implements ServiceAsyncInstanceActivationAuthority {
 
   private requirePending(reservation: ServiceInstanceActivationReservation): PendingReservation {
     const pending = this.pending.get(reservation.token);
-    if (
-      pending === undefined
-      || pending.creating.objectGeneration !== reservation.attempt
-    ) {
+    if (pending === undefined || pending.creating.objectGeneration !== reservation.attempt) {
       throw new Error('Instance activation reservation is stale.');
     }
     return pending;
@@ -543,18 +525,18 @@ function readyRead(
   const decoded = decodeServiceReadySpotAuthority(snapshot.payload);
   const creating = decodeServiceInstanceAuthorityPayload(snapshot.payload);
   if (
-    creating?.state === 'coldActivating'
-    && snapshot.allocation.objectKind === 'instance_spot'
-    && snapshot.allocation.state === 'reserved'
-    && creating.stableType === target.stableType
-    && creating.spotId === target.targetSpotId
-    && creating.ownerId === snapshot.ownerId
-    && creating.ownerLeaseGeneration === snapshot.ownerLeaseGeneration
-    && creating.ownerMeshName === snapshot.allocation.descriptor.meshName
-    && creating.ownerNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration
-    && routingIdsEqual(creating.ownerNodeRid, snapshot.allocation.descriptor.rid)
-    && routingIdsEqual(target.targetNodeRid, snapshot.allocation.descriptor.rid)
-    && target.targetNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration
+    creating?.state === 'coldActivating' &&
+    snapshot.allocation.objectKind === 'instance_spot' &&
+    snapshot.allocation.state === 'reserved' &&
+    creating.stableType === target.stableType &&
+    creating.spotId === target.targetSpotId &&
+    creating.ownerId === snapshot.ownerId &&
+    creating.ownerLeaseGeneration === snapshot.ownerLeaseGeneration &&
+    creating.ownerMeshName === snapshot.allocation.descriptor.meshName &&
+    creating.ownerNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration &&
+    routingIdsEqual(creating.ownerNodeRid, snapshot.allocation.descriptor.rid) &&
+    routingIdsEqual(target.targetNodeRid, snapshot.allocation.descriptor.rid) &&
+    target.targetNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration
   ) {
     return {
       kind: 'creating',
@@ -563,18 +545,18 @@ function readyRead(
     };
   }
   if (
-    decoded?.kind !== 'instance_spot'
-    || decoded.stableType !== target.stableType
-    || decoded.spotId !== target.targetSpotId
-    || snapshot.allocation.objectKind !== 'instance_spot'
-    || snapshot.allocation.state !== 'active'
-    || decoded.ownerId !== snapshot.ownerId
-    || decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration
-    || decoded.ownerMeshName !== snapshot.allocation.descriptor.meshName
-    || decoded.ownerNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration
-    || !routingIdsEqual(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid)
-    || !routingIdsEqual(target.targetNodeRid, snapshot.allocation.descriptor.rid)
-    || target.targetNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration
+    decoded?.kind !== 'instance_spot' ||
+    decoded.stableType !== target.stableType ||
+    decoded.spotId !== target.targetSpotId ||
+    snapshot.allocation.objectKind !== 'instance_spot' ||
+    snapshot.allocation.state !== 'active' ||
+    decoded.ownerId !== snapshot.ownerId ||
+    decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration ||
+    decoded.ownerMeshName !== snapshot.allocation.descriptor.meshName ||
+    decoded.ownerNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration ||
+    !routingIdsEqual(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid) ||
+    !routingIdsEqual(target.targetNodeRid, snapshot.allocation.descriptor.rid) ||
+    target.targetNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration
   ) {
     return { kind: 'missing' };
   }
@@ -587,16 +569,16 @@ function readyExisting(
 ): Extract<ServiceInstanceAuthorityRead, { readonly kind: 'ready' }> {
   const decoded = decodeServiceReadySpotAuthority(snapshot.payload);
   if (
-    decoded?.kind !== 'instance_spot'
-    || decoded.stableType !== target.stableType
-    || decoded.spotId !== target.targetSpotId
-    || snapshot.allocation.objectKind !== 'instance_spot'
-    || snapshot.allocation.state !== 'active'
-    || decoded.ownerId !== snapshot.ownerId
-    || decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration
-    || decoded.ownerMeshName !== snapshot.allocation.descriptor.meshName
-    || decoded.ownerNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration
-    || !routingIdsEqual(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid)
+    decoded?.kind !== 'instance_spot' ||
+    decoded.stableType !== target.stableType ||
+    decoded.spotId !== target.targetSpotId ||
+    snapshot.allocation.objectKind !== 'instance_spot' ||
+    snapshot.allocation.state !== 'active' ||
+    decoded.ownerId !== snapshot.ownerId ||
+    decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration ||
+    decoded.ownerMeshName !== snapshot.allocation.descriptor.meshName ||
+    decoded.ownerNodeGeneration !== snapshot.allocation.descriptorLifecycleGeneration ||
+    !routingIdsEqual(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid)
   ) {
     throw new Error('Existing Instance authority is not a matching Ready allocation.');
   }
@@ -619,18 +601,18 @@ function requireCommitIdentity(
   meshName: string
 ): void {
   if (
-    creating.allocation.state !== 'reserved'
-    || creating.allocation.objectKind !== 'instance_spot'
-    || creating.allocation.stableType !== target.stableType
-    || creating.objectGeneration !== reservation.attempt
-    || !routingIdsEqual(creating.allocation.descriptor.rid, target.targetNodeRid)
-    || creating.allocation.descriptor.meshName !== meshName
-    || creating.allocation.descriptorLifecycleGeneration !== target.targetNodeGeneration
-    || spot.kind !== 'instance'
-    || spot.stableType !== target.stableType
-    || spot.ref.spotId !== target.targetSpotId
-    || spot.ref.generation !== reservation.attempt
-    || spot.authorityOwnerGeneration !== creating.authorityOwnerGeneration
+    creating.allocation.state !== 'reserved' ||
+    creating.allocation.objectKind !== 'instance_spot' ||
+    creating.allocation.stableType !== target.stableType ||
+    creating.objectGeneration !== reservation.attempt ||
+    !routingIdsEqual(creating.allocation.descriptor.rid, target.targetNodeRid) ||
+    creating.allocation.descriptor.meshName !== meshName ||
+    creating.allocation.descriptorLifecycleGeneration !== target.targetNodeGeneration ||
+    spot.kind !== 'instance' ||
+    spot.stableType !== target.stableType ||
+    spot.ref.spotId !== target.targetSpotId ||
+    spot.ref.generation !== reservation.attempt ||
+    spot.authorityOwnerGeneration !== creating.authorityOwnerGeneration
   ) {
     throw new Error('Instance activation Ready identity does not match its exact reservation.');
   }

package/src/runtime/host/location-runtime-owner.ts

@@ -94,10 +94,14 @@ export class ZLinkLocationRuntimeOwner {
       metrics: this.options.metrics,
       meshNames: [...this.options.registration.spotNodes.keys()],
       leaseScopes: [
-        ...[...this.options.registration.spotNodes.keys()]
-          .map(name => ({ kind: 'mesh' as const, name })),
-        ...[...this.options.registration.channels.keys()]
-          .map(name => ({ kind: 'channel' as const, name }))
+        ...[...this.options.registration.spotNodes.keys()].map((name) => ({
+          kind: 'mesh' as const,
+          name
+        })),
+        ...[...this.options.registration.channels.keys()].map((name) => ({
+          kind: 'channel' as const,
+          name
+        }))
       ],
       rewriteAuthorityPayloadForOwner: this.options.rewriteAuthorityPayloadForOwner
     });
@@ -108,7 +112,7 @@ export class ZLinkLocationRuntimeOwner {
       primaryMeshName ?? '',
       stores.authorityStore,
       stores.spotStore,
-      spotId => this.spotRouteInvalidator?.(spotId)
+      (spotId) => this.spotRouteInvalidator?.(spotId)
     );
     return runtime;
   }
@@ -131,7 +135,9 @@ export class ZLinkLocationRuntimeOwner {
   createSpotRouteResolver(
     spotMeshNames: readonly string[],
     spotRouterChannelIdByMesh: (meshName: string) => string,
-    resolveLocalSpot?: (spotId: RoutingId) => import('../spots/spot-routing-internal').ZLinkSpotRouteTarget | undefined
+    resolveLocalSpot?: (
+      spotId: RoutingId
+    ) => import('../spots/spot-routing-internal').ZLinkSpotRouteTarget | undefined
   ): ZLinkSpotRouteResolver | undefined {
     const stores = this.stores;
     if (stores === undefined || spotMeshNames.length === 0) {
@@ -150,7 +156,9 @@ export class ZLinkLocationRuntimeOwner {
     );
   }
 
-  createActorLocationResolver(spotMeshNames: readonly string[]): ZLinkStoreLocationResolvers | undefined {
+  createActorLocationResolver(
+    spotMeshNames: readonly string[]
+  ): ZLinkStoreLocationResolvers | undefined {
     const stores = this.stores;
     if (stores === undefined) {
       return undefined;
@@ -166,9 +174,8 @@ export class ZLinkLocationRuntimeOwner {
 
   ownerNodeRid(spotNodeRuntime?: ZLinkSpotNodeRuntimeManager): RoutingId {
     const primaryMeshNode = spotNodeRuntime?.primaryMeshNode;
-    const spotNodeRid = primaryMeshNode === undefined
-      ? undefined
-      : String(primaryMeshNode.status().routingId);
+    const spotNodeRid =
+      primaryMeshNode === undefined ? undefined : String(primaryMeshNode.status().routingId);
     if (spotNodeRid !== undefined) {
       return spotNodeRid;
     }
@@ -184,7 +191,8 @@ export class ZLinkLocationRuntimeOwner {
       }
     }
     for (const spotNode of this.options.registration.spotNodes.values()) {
-      const routingId = spotNode.routingId ?? spotNode.router?.routingId ?? spotNode.pubSub?.routingId;
+      const routingId =
+        spotNode.routingId ?? spotNode.router?.routingId ?? spotNode.pubSub?.routingId;
       if (routingId !== undefined) {
         return routingId;
       }
@@ -297,19 +305,23 @@ export class ZLinkLocationRuntimeOwner {
 }
 
 function isActorTransferStore(value: unknown): value is ZLinkActorTransferStore {
-  const store = value as Partial<Record<
-    | 'prepareActorTransfer'
-    | 'commitActorTransfer'
-    | 'activateActorTransfer'
-    | 'abortActorTransfer'
-    | 'takeOverActorTransfer'
-    | 'resolveActorTransfer',
-    unknown
-  >>;
-  return typeof store.prepareActorTransfer === 'function'
-    && typeof store.commitActorTransfer === 'function'
-    && typeof store.activateActorTransfer === 'function'
-    && typeof store.abortActorTransfer === 'function'
-    && typeof store.takeOverActorTransfer === 'function'
-    && typeof store.resolveActorTransfer === 'function';
+  const store = value as Partial<
+    Record<
+      | 'prepareActorTransfer'
+      | 'commitActorTransfer'
+      | 'activateActorTransfer'
+      | 'abortActorTransfer'
+      | 'takeOverActorTransfer'
+      | 'resolveActorTransfer',
+      unknown
+    >
+  >;
+  return (
+    typeof store.prepareActorTransfer === 'function' &&
+    typeof store.commitActorTransfer === 'function' &&
+    typeof store.activateActorTransfer === 'function' &&
+    typeof store.abortActorTransfer === 'function' &&
+    typeof store.takeOverActorTransfer === 'function' &&
+    typeof store.resolveActorTransfer === 'function'
+  );
 }

package/src/runtime/host/mesh-router-resolver.ts

@@ -7,8 +7,10 @@ export class MeshRouterResolver {
   constructor(private readonly registration: ZLinkFrameworkRegistration) {}
 
   canUseRouterChannel(routerChannelId: string): boolean {
-    return this.registration.routeChannels.has(routerChannelId)
-      || this.registration.spotNodes.get(routerChannelId)?.router !== undefined;
+    return (
+      this.registration.routeChannels.has(routerChannelId) ||
+      this.registration.spotNodes.get(routerChannelId)?.router !== undefined
+    );
   }
 
   classifyManualNodeTarget(meshName: string, targetNodeRid: RoutingId): boolean | undefined {
@@ -38,9 +40,10 @@ export class MeshRouterResolver {
     return candidates.length === 1 ? candidates[0] : undefined;
   }
 
-  remoteBoundSessionTargetForSource(sourceNodeRid: RoutingId): ZLinkRemoteBoundSessionTarget | undefined {
-    const routerChannelId = this.defaultSpotRouterChannelId()
-      ?? this.defaultRouterChannelId();
+  remoteBoundSessionTargetForSource(
+    sourceNodeRid: RoutingId
+  ): ZLinkRemoteBoundSessionTarget | undefined {
+    const routerChannelId = this.defaultSpotRouterChannelId() ?? this.defaultRouterChannelId();
     if (routerChannelId === undefined) {
       return undefined;
     }
@@ -54,12 +57,14 @@ export class MeshRouterResolver {
 
   primaryMeshName(): string | undefined {
     const names = [...this.registration.spotNodes.entries()]
-      .filter(([, node]) =>
-        node.entrySpotType !== undefined
-        || (node.spotFactories?.length ?? 0) > 0
-        || (node.actorFactories instanceof Map
-          ? node.actorFactories.size > 0
-          : Object.keys(node.actorFactories ?? {}).length > 0))
+      .filter(
+        ([, node]) =>
+          node.entrySpotType !== undefined ||
+          (node.spotFactories?.length ?? 0) > 0 ||
+          (node.actorFactories instanceof Map
+            ? node.actorFactories.size > 0
+            : Object.keys(node.actorFactories ?? {}).length > 0)
+      )
       .map(([name]) => name);
     if (names.length === 1) return names[0];
     if (names.length > 1) return undefined;
@@ -69,18 +74,19 @@ export class MeshRouterResolver {
 
   actorMeshName(actorType: string): string | undefined {
     const matches = [...this.registration.spotNodes.entries()]
-      .filter(([, node]) => node.actorFactories instanceof Map
-        ? node.actorFactories.has(actorType)
-        : node.actorFactories !== undefined && Object.hasOwn(node.actorFactories, actorType))
+      .filter(([, node]) =>
+        node.actorFactories instanceof Map
+          ? node.actorFactories.has(actorType)
+          : node.actorFactories !== undefined && Object.hasOwn(node.actorFactories, actorType)
+      )
       .map(([name]) => name);
     return matches.length === 1 ? matches[0] : undefined;
   }
 
   spotLocationMeshNames(): readonly string[] {
-    return [...new Set([
-      ...this.registration.spotNodes.keys(),
-      ...this.registration.routeChannels.keys()
-    ])];
+    return [
+      ...new Set([...this.registration.spotNodes.keys(), ...this.registration.routeChannels.keys()])
+    ];
   }
 
   spotRouterChannelIdByMesh(): (meshName: string) => string {
@@ -89,8 +95,8 @@ export class MeshRouterResolver {
     for (const [spotMeshName, spotNode] of this.registration.spotNodes.entries()) {
       const conventionalRouteChannelId = `${spotMeshName}.route`;
       if (
-        this.registration.routeChannels.has(conventionalRouteChannelId)
-        || this.registration.routeChannelOptions.has(conventionalRouteChannelId)
+        this.registration.routeChannels.has(conventionalRouteChannelId) ||
+        this.registration.routeChannelOptions.has(conventionalRouteChannelId)
       ) {
         mapped.set(spotMeshName, conventionalRouteChannelId);
         continue;
@@ -100,9 +106,10 @@ export class MeshRouterResolver {
         continue;
       }
       const candidates = routeChannels
-        .filter((routeChannel) =>
-          routeChannel.routingId !== undefined &&
-          routingIdsEqual(routeChannel.routingId, spotNodeRid)
+        .filter(
+          (routeChannel) =>
+            routeChannel.routingId !== undefined &&
+            routingIdsEqual(routeChannel.routingId, spotNodeRid)
         )
         .map((routeChannel) => routeChannel.routerChannelId);
       if (candidates.length === 1) {