@zlink-systems/framework 0.20.0 → 0.22.0

package/src/runtime/host/spot-node-runtime-options-factory.ts

@@ -1,5 +1,4 @@
-import type {
-} from '../../contracts';
+import type {} from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
 import {
@@ -18,7 +17,10 @@ import type {
   ZLinkDetachedTaskRunner,
   ZLinkSpotRoutedTransport
 } from '../spots';
-import type { ZLinkEntryActorRuntime, ZLinkSpotActorTransferRuntime } from '../spots/spot-runtime-ports';
+import type {
+  ZLinkEntryActorRuntime,
+  ZLinkSpotActorTransferRuntime
+} from '../spots/spot-runtime-ports';
 import type { MeshRouterResolver } from './mesh-router-resolver';
 import type { ZLinkBoundSessionRelay } from './bound-session-relay';
 import type { ZLinkActorHandoffCoordinator } from '../actors';
@@ -55,8 +57,14 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
       primaryMeshName: this.options.meshRouters.primaryMeshName(),
       backendAdapterFactory: this.options.backendAdapterFactory,
       context: this.options.context,
-      channelClient: new DefaultZLinkChannelClient(this.options.registration, this.options.channelTransport),
-      fanoutClient: new DefaultZLinkFanoutClient(this.options.registration, this.options.channelTransport),
+      channelClient: new DefaultZLinkChannelClient(
+        this.options.registration,
+        this.options.channelTransport
+      ),
+      fanoutClient: new DefaultZLinkFanoutClient(
+        this.options.registration,
+        this.options.channelTransport
+      ),
       spotPublisherClient: new DefaultZLinkSpotPublisherClient(
         this.options.registration,
         this.options.spotPublisherTransport
@@ -68,8 +76,7 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
       runtimeEventPublisher: this.options.runtimeEventPublisher,
       metrics: this.options.metrics,
       applicationJobQueue: this.options.applicationJobQueue,
-      applicationJobReceiveFlowFailureSink:
-        this.options.applicationJobReceiveFlowFailureSink,
+      applicationJobReceiveFlowFailureSink: this.options.applicationJobReceiveFlowFailureSink,
       detachedTaskRunner: this.options.detachedTaskRunner,
       messageSerializers: this.options.registration.messageSerializers,
       entryActorRuntime: this.options.entryActorRuntime,
@@ -78,5 +85,4 @@ export class ZLinkSpotNodeRuntimeOptionsFactory {
       actorHandoffRuntime: this.options.actorHandoff
     };
   }
-
 }

package/src/runtime/host/spot-runtime-options-factory.ts

@@ -1,8 +1,5 @@
 import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
-import {
-  ZLinkSpotRelocationCoordinationMode,
-  ZLinkUserSpotExecutionMode
-} from '../../contracts';
+import { ZLinkSpotRelocationCoordinationMode, ZLinkUserSpotExecutionMode } from '../../contracts';
 import {
   toFrameworkActorRef,
   type DefaultZLinkActorManager,
@@ -18,10 +15,7 @@ import {
   type ZLinkSpotPublisherClientTransport
 } from '../channels';
 import type { ZLinkDispatchErrorReporter } from '../channels';
-import {
-  ZLinkConfigurationException,
-  type ZLinkFrameworkRegistration
-} from '../configuration';
+import { ZLinkConfigurationException, type ZLinkFrameworkRegistration } from '../configuration';
 import type { ZLinkLocationLifecycle } from '../locations';
 import type { ZLinkBackendMeshNode } from '../backend';
 import type { ZLinkSpotRouteResolver } from '../spots/spot-routing-internal';
@@ -83,16 +77,14 @@ export class ZLinkSpotRuntimeOptionsFactory {
         this.options.spotNodeRuntime()?.meshNode(meshName)?.status().lifecycleGeneration,
       entryNodeRid: undefined,
       entryNodeRidProvider: () => this.primaryNodeRoutingId(),
-      entrySpotIdProvider: meshName =>
+      entrySpotIdProvider: (meshName) =>
         this.options.spotNodeRuntime()?.entrySpotIdForMesh(meshName),
       entrySpotCallbacks: {
         onLeaveActor: (actor, signal, actorRef, membershipEpoch) =>
-          this.options.spotNodeRuntime()?.notifyPrimaryEntrySpotActorLeft(
-            actor,
-            signal,
-            actorRef,
-            membershipEpoch
-          ) ?? Promise.resolve()
+          this.options
+            .spotNodeRuntime()
+            ?.notifyPrimaryEntrySpotActorLeft(actor, signal, actorRef, membershipEpoch) ??
+          Promise.resolve()
       },
       dispatchEntryActorPacket: (
         actorId,
@@ -105,7 +97,9 @@ export class ZLinkSpotRuntimeOptionsFactory {
       ) => {
         const runtime = this.options.spotNodeRuntime();
         if (runtime === undefined) {
-          throw new ZLinkConfigurationException('Entry Spot actor packet dispatch requires the MeshNode runtime.');
+          throw new ZLinkConfigurationException(
+            'Entry Spot actor packet dispatch requires the MeshNode runtime.'
+          );
         }
         return runtime.dispatchEntryActorPacket(
           actorId,
@@ -120,12 +114,20 @@ export class ZLinkSpotRuntimeOptionsFactory {
       dispatchEntryActorJoin: async (meshName, actor, handoffBacklog) => {
         const runtime = this.options.spotNodeRuntime();
         if (runtime === undefined) {
-          throw new ZLinkConfigurationException('Entry Spot actor join requires the MeshNode runtime.');
+          throw new ZLinkConfigurationException(
+            'Entry Spot actor join requires the MeshNode runtime.'
+          );
         }
         await runtime.dispatchEntryActorJoin(meshName, actor, handoffBacklog);
       },
-      channelClient: new DefaultZLinkChannelClient(this.options.registration, this.options.channelTransport),
-      fanoutClient: new DefaultZLinkFanoutClient(this.options.registration, this.options.channelTransport),
+      channelClient: new DefaultZLinkChannelClient(
+        this.options.registration,
+        this.options.channelTransport
+      ),
+      fanoutClient: new DefaultZLinkFanoutClient(
+        this.options.registration,
+        this.options.channelTransport
+      ),
       spotPublisherClient: new DefaultZLinkSpotPublisherClient(
         this.options.registration,
         this.options.spotPublisherTransport
@@ -135,7 +137,9 @@ export class ZLinkSpotRuntimeOptionsFactory {
       spotRouterChannelIdForMesh: this.options.meshRouters.spotRouterChannelIdByMesh(),
       channelMeshNameForChannel: (channelName) => {
         const matches = [...this.options.registration.spotNodes.entries()]
-          .filter(([, node]) => Object.prototype.hasOwnProperty.call(node.meshChannels ?? {}, channelName))
+          .filter(([, node]) =>
+            Object.prototype.hasOwnProperty.call(node.meshChannels ?? {}, channelName)
+          )
           .map(([meshName]) => meshName);
         return matches.length === 1 ? matches[0] : undefined;
       },
@@ -150,36 +154,38 @@ export class ZLinkSpotRuntimeOptionsFactory {
       beginInstanceClosingAuthority: (meshName, spotId) =>
         this.options.beginInstanceClosingAuthority(meshName, String(spotId)),
       instanceSpotApplicationTargetProvider: (meshName, spotId) =>
-        this.options.spotNodeRuntime()
+        this.options
+          .spotNodeRuntime()
           ?.meshNode(meshName)
           ?.instanceSpotApplicationTarget?.(String(spotId)),
       instanceSpotApplicationQuiescenceProvider: (meshName, spotId, signal) =>
-        this.options.spotNodeRuntime()
+        this.options
+          .spotNodeRuntime()
           ?.meshNode(meshName)
-          ?.waitForInstanceApplicationQuiescence?.(String(spotId), signal)
-        ?? Promise.resolve(),
+          ?.waitForInstanceApplicationQuiescence?.(String(spotId), signal) ?? Promise.resolve(),
       createNativeSpot: (meshName, spotId, authority) => {
         const node = this.options.spotNodeRuntime()?.meshNode(meshName);
         if (node === undefined) {
           return undefined;
         }
-        const restored = authority === undefined
-          ? undefined
-          : node.restoreSpotAuthority?.(
-              String(spotId),
-              authority.objectKind ?? 'user_spot',
-              authority.stableType,
-              authority.objectGeneration,
-              authority.authorityOwnerGeneration
-            ) ?? node.restoreUserSpotAuthority?.(
+        const restored =
+          authority === undefined
+            ? undefined
+            : (node.restoreSpotAuthority?.(
+                String(spotId),
+                authority.objectKind ?? 'user_spot',
+                authority.stableType,
+                authority.objectGeneration,
+                authority.authorityOwnerGeneration
+              ) ??
+              node.restoreUserSpotAuthority?.(
                 String(spotId),
                 authority.stableType,
                 authority.objectGeneration,
                 authority.authorityOwnerGeneration
-              );
-        const result = restored === undefined
-          ? node.getOrCreateSpot(spotId)
-          : { spot: restored, created: true };
+              ));
+        const result =
+          restored === undefined ? node.getOrCreateSpot(spotId) : { spot: restored, created: true };
         return {
           routingId: spotId,
           lifecycleGeneration: result.spot.status().lifecycleGeneration,
@@ -216,21 +222,21 @@ export class ZLinkSpotRuntimeOptionsFactory {
           expectedAuthorityOwnerGeneration: fence.authorityOwnerGeneration,
           expectedOwnerLeaseGeneration: fence.ownerLeaseGeneration
         }),
-      actorLifecycleResolver: (actorId) =>
-        this.options.actorManager()?.getState(actorId)?.actor,
+      actorLifecycleResolver: (actorId) => this.options.actorManager()?.getState(actorId)?.actor,
       actorDispatchOwnerResolver: (actorId) => {
         const state = this.options.actorManager()?.getState(actorId);
-        const actorRef = state?.nativeActorRef === undefined
-          ? undefined
-          : toFrameworkActorRef(state.nativeActorRef, state.meshName ?? '');
+        const actorRef =
+          state?.nativeActorRef === undefined
+            ? undefined
+            : toFrameworkActorRef(state.nativeActorRef, state.meshName ?? '');
         const localNodeRid = this.primaryNodeRoutingId();
         if (
-          state?.actor === undefined
-          || state.spot === undefined
-          || state.remoteActorPacketTarget !== undefined
-          || actorRef === undefined
-          || localNodeRid === undefined
-          || String(actorRef.nodeRid) !== localNodeRid
+          state?.actor === undefined ||
+          state.spot === undefined ||
+          state.remoteActorPacketTarget !== undefined ||
+          actorRef === undefined ||
+          localNodeRid === undefined ||
+          String(actorRef.nodeRid) !== localNodeRid
         ) {
           return {};
         }
@@ -241,24 +247,28 @@ export class ZLinkSpotRuntimeOptionsFactory {
       },
       userSpotExecutionMode: (meshName, spotType) => {
         const registrations =
-          this.options.registration.spotNodes.get(meshName)
-            ?.spotFactoryRegistrations ?? {};
-        const registration = Object.values(registrations)
-          .find(candidate => candidate.implementation === spotType);
-        return registration?.options?.executionMode
-          ?? ZLinkUserSpotExecutionMode.SpotWide;
+          this.options.registration.spotNodes.get(meshName)?.spotFactoryRegistrations ?? {};
+        const registration = Object.values(registrations).find(
+          (candidate) => candidate.implementation === spotType
+        );
+        return registration?.options?.executionMode ?? ZLinkUserSpotExecutionMode.SpotWide;
       },
       userSpotRelocationCoordinationMode: (meshName, spotType) => {
         const registrations =
-          this.options.registration.spotNodes.get(meshName)
-            ?.spotFactoryRegistrations ?? {};
-        const registration = Object.values(registrations)
-          .find(candidate => candidate.implementation === spotType);
-        return registration?.options?.relocationCoordinationMode
-          ?? ZLinkSpotRelocationCoordinationMode.FrameworkManaged;
+          this.options.registration.spotNodes.get(meshName)?.spotFactoryRegistrations ?? {};
+        const registration = Object.values(registrations).find(
+          (candidate) => candidate.implementation === spotType
+        );
+        return (
+          registration?.options?.relocationCoordinationMode ??
+          ZLinkSpotRelocationCoordinationMode.FrameworkManaged
+        );
       },
       actorBindingGenerationObserver: (actorId, generation) =>
-        this.options.actorManager()?.getState(actorId)?.setBoundSessionBindingGeneration(generation),
+        this.options
+          .actorManager()
+          ?.getState(actorId)
+          ?.setBoundSessionBindingGeneration(generation),
       actorTransferRuntime,
       boundSessionRuntime: this.options.boundSessionRelay.boundSessions,
       actorHandoffRuntime: this.options.actorHandoff,
@@ -282,5 +292,4 @@ export class ZLinkSpotRuntimeOptionsFactory {
     const node = this.options.spotNodeRuntime()?.meshNode(meshName);
     return node === undefined ? undefined : String(node.status().routingId);
   }
-
 }

package/src/runtime/host/stateful-authority-route-runtime.ts

@@ -4,15 +4,14 @@ import type {
   ZLinkAuthoritySnapshot,
   ZLinkAuthorityReadResult
 } from '../../contracts/Locations/Authority';
-import type { ZLinkAuthorityStore, ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
 import type {
-  ZLinkRelocationStore
-} from '../../contracts/Locations/RelocationStore';
+  ZLinkAuthorityStore,
+  ZLinkObjectCreationStore
+} from '../locations/internal-store-contracts';
+import type { ZLinkRelocationStore } from '../../contracts/Locations/RelocationStore';
 import { relocationBlobReference } from '../locations/relocation-blob';
 import type { ZLinkBackendMeshNode } from '../backend/contracts';
-import type {
-  ServicePendingInstanceActivation
-} from '../foundation/service-stateful-runtime';
+import type { ServicePendingInstanceActivation } from '../foundation/service-stateful-runtime';
 import type {
   ServiceDirectSpotRouteFence,
   ServiceInstanceRouteFence,
@@ -175,9 +174,9 @@ export class ZLinkStatefulAuthorityRouteRuntime {
       const status = sink.status();
       for (const pending of snapshot.pending) {
         if (
-          pending.targetMeshName === meshName
-          && routingIdsEqual(status.routingId, pending.targetNodeRid)
-          && status.lifecycleGeneration === pending.targetNodeGeneration
+          pending.targetMeshName === meshName &&
+          routingIdsEqual(status.routingId, pending.targetNodeRid) &&
+          status.lifecycleGeneration === pending.targetNodeGeneration
         ) {
           await this.recoverPendingInstanceActivation(sink, pending, signal);
         }
@@ -187,20 +186,18 @@ export class ZLinkStatefulAuthorityRouteRuntime {
         if (route.meshName !== meshName) continue;
         const previousRoute = previous.get(key);
         const expectedSpotRoute = previousRoute?.spotRoute ?? null;
-        const expectedInstanceRoute = previousRoute?.kind === 'instance_spot'
-          ? previousRoute.instanceRoute
-          : null;
+        const expectedInstanceRoute =
+          previousRoute?.kind === 'instance_spot' ? previousRoute.instanceRoute : null;
         sink.rememberSpotRoute(route.spotRoute, expectedSpotRoute);
         if (route.kind === 'instance_spot') {
           const status = sink.status();
           if (
-            routingIdsEqual(status.routingId, route.instanceRoute.targetNodeRid)
-            && status.lifecycleGeneration === route.instanceRoute.targetNodeGeneration
+            routingIdsEqual(status.routingId, route.instanceRoute.targetNodeRid) &&
+            status.lifecycleGeneration === route.instanceRoute.targetNodeGeneration
           ) {
             if (route.activationRecovery !== undefined) {
               if (
-                route.activationRecovery.replayCursor
-                === route.activationRecovery.inboxSequence
+                route.activationRecovery.replayCursor === route.activationRecovery.inboxSequence
               ) {
                 const released = await sink.completeRecoveredInstanceActivation(
                   {
@@ -273,9 +270,7 @@ export class ZLinkStatefulAuthorityRouteRuntime {
     // then cannot remove a route or intent installed for a newer generation.
     for (const { meshName, sink } of sinks) {
       const previous = this.appliedByMesh.get(meshName) ?? new Map();
-      const meshCurrent = new Map(
-        [...current].filter(([, route]) => route.meshName === meshName)
-      );
+      const meshCurrent = new Map([...current].filter(([, route]) => route.meshName === meshName));
       const changedSpotIds = new Set<string>();
       for (const [key, oldRoute] of previous) {
         const next = meshCurrent.get(key);
@@ -319,23 +314,25 @@ export class ZLinkStatefulAuthorityRouteRuntime {
     const envelope = await this.readRecoveryEnvelope(recovery, signal);
     const status = sink.status();
     if (
-      envelope.targetMeshName !== route.meshName
-      || envelope.target.stableType !== route.stableType
-      || envelope.target.targetSpotId !== route.instanceRoute.targetSpotId
-      || envelope.target.targetNodeRid !== route.instanceRoute.targetNodeRid
-      || envelope.target.targetNodeGeneration !== route.instanceRoute.targetNodeGeneration
-      || envelope.target.descriptorVersion !== status.descriptorRevision.toString()
+      envelope.targetMeshName !== route.meshName ||
+      envelope.target.stableType !== route.stableType ||
+      envelope.target.targetSpotId !== route.instanceRoute.targetSpotId ||
+      envelope.target.targetNodeRid !== route.instanceRoute.targetNodeRid ||
+      envelope.target.targetNodeGeneration !== route.instanceRoute.targetNodeGeneration ||
+      envelope.target.descriptorVersion !== status.descriptorRevision.toString()
     ) {
       this.options.reportError(
         new Error('Instance activation recovery envelope does not match Ready authority.')
       );
       return false;
     }
-    return (await sink.recoverInstanceActivation(
-      envelope,
-      route.instanceRoute,
-      expectedCurrentRoute
-    )) !== false;
+    return (
+      (await sink.recoverInstanceActivation(
+        envelope,
+        route.instanceRoute,
+        expectedCurrentRoute
+      )) !== false
+    );
   }
 
   private async recoverPendingInstanceActivation(
@@ -343,21 +340,24 @@ export class ZLinkStatefulAuthorityRouteRuntime {
     recovery: PendingInstanceActivationRecovery,
     signal?: AbortSignal
   ): Promise<void> {
-    const envelope = await this.readRecoveryEnvelope({
-      reference: recovery.pending.requestReference,
-      sha256: recovery.pending.requestSha256,
-      encodedSize: Number(recovery.pending.requestEncodedSize),
-      inboxSequence: 1n,
-      replayCursor: 0n
-    }, signal);
+    const envelope = await this.readRecoveryEnvelope(
+      {
+        reference: recovery.pending.requestReference,
+        sha256: recovery.pending.requestSha256,
+        encodedSize: Number(recovery.pending.requestEncodedSize),
+        inboxSequence: 1n,
+        replayCursor: 0n
+      },
+      signal
+    );
     const status = sink.status();
     if (
-      envelope.targetMeshName !== recovery.targetMeshName
-      || envelope.target.stableType !== recovery.stableType
-      || envelope.target.targetSpotId !== recovery.spotId
-      || envelope.target.targetNodeRid !== recovery.targetNodeRid
-      || envelope.target.targetNodeGeneration !== recovery.targetNodeGeneration
-      || envelope.target.descriptorVersion !== status.descriptorRevision.toString()
+      envelope.targetMeshName !== recovery.targetMeshName ||
+      envelope.target.stableType !== recovery.stableType ||
+      envelope.target.targetSpotId !== recovery.spotId ||
+      envelope.target.targetNodeRid !== recovery.targetNodeRid ||
+      envelope.target.targetNodeGeneration !== recovery.targetNodeGeneration ||
+      envelope.target.descriptorVersion !== status.descriptorRevision.toString()
     ) {
       const creationStore = this.options.creationStore;
       if (creationStore === undefined) {
@@ -366,20 +366,23 @@ export class ZLinkStatefulAuthorityRouteRuntime {
         );
         return;
       }
-      const aborted = await creationStore.abort({
-        key: { kind: 'instance_spot', globalId: recovery.spotId },
-        reservationId: recovery.pending.reservationId,
-        expectedStoreVersion: recovery.pending.storeVersion,
-        target: {
-          meshName: recovery.pending.meshName,
-          nodeRid: recovery.pending.nodeRid as never,
-          nodeLifecycleGeneration: recovery.pending.nodeGeneration,
-          owner: {
-            ownerId: recovery.pending.ownerId,
-            leaseGeneration: recovery.pending.ownerLeaseGeneration
+      const aborted = await creationStore.abort(
+        {
+          key: { kind: 'instance_spot', globalId: recovery.spotId },
+          reservationId: recovery.pending.reservationId,
+          expectedStoreVersion: recovery.pending.storeVersion,
+          target: {
+            meshName: recovery.pending.meshName,
+            nodeRid: recovery.pending.nodeRid as never,
+            nodeLifecycleGeneration: recovery.pending.nodeGeneration,
+            owner: {
+              ownerId: recovery.pending.ownerId,
+              leaseGeneration: recovery.pending.ownerLeaseGeneration
+            }
           }
-        }
-      }, signal);
+        },
+        signal
+      );
       if (aborted.kind === 'aborted' || aborted.kind === 'alreadyAborted') {
         try {
           await this.options.relocationStore?.delete(
@@ -392,11 +395,8 @@ export class ZLinkStatefulAuthorityRouteRuntime {
       }
       return;
     }
-    if ((await sink.recoverPendingInstanceActivation(
-      envelope,
-      recovery.pending,
-      null
-    )) === false) return;
+    if ((await sink.recoverPendingInstanceActivation(envelope, recovery.pending, null)) === false)
+      return;
   }
 
   private async readRecoveryEnvelope(
@@ -407,20 +407,15 @@ export class ZLinkStatefulAuthorityRouteRuntime {
     if (relocationStore === undefined) {
       throw new Error('Instance activation recovery requires a Relocation Store.');
     }
-    const result = await relocationStore.read(
-      relocationBlobReference(recovery.reference),
-      signal
-    );
+    const result = await relocationStore.read(relocationBlobReference(recovery.reference), signal);
     if (result.kind !== 'found') {
-      throw new Error(
-        `Instance activation recovery payload '${recovery.reference}' is missing.`
-      );
+      throw new Error(`Instance activation recovery payload '${recovery.reference}' is missing.`);
     }
     const payload = Buffer.from(result.bytes);
     const sha256 = createHash('sha256').update(payload).digest();
     if (
-      payload.byteLength !== recovery.encodedSize
-      || !sha256.equals(Buffer.from(recovery.sha256))
+      payload.byteLength !== recovery.encodedSize ||
+      !sha256.equals(Buffer.from(recovery.sha256))
     ) {
       throw new Error(
         `Instance activation recovery payload '${recovery.reference}' failed integrity validation.`
@@ -480,9 +475,9 @@ export class ZLinkStatefulAuthorityRouteRuntime {
       const route = authorityRoute(current);
       if (route !== undefined) result.set(authorityRouteKey(route), route);
       if (
-        current.allocation.state === 'active'
-        && current.allocation.objectKind === 'actor'
-        && decodeActorAuthorityIdentity(
+        current.allocation.state === 'active' &&
+        current.allocation.objectKind === 'actor' &&
+        decodeActorAuthorityIdentity(
           serviceRelocationAuthorityApplicationPayload(current.payload),
           current.objectGeneration
         ) !== undefined
@@ -502,14 +497,17 @@ function authorityNeedsExactRead(
 ): boolean {
   if (pendingInstanceActivation(snapshot) !== undefined) return true;
   if (relocationCodec.read(snapshot.payload) !== undefined) return true;
-  if (decodeServiceReadySpotAuthority(
-    serviceRelocationAuthorityApplicationPayload(snapshot.payload)
-  )?.activationRecovery !== undefined) {
+  if (
+    decodeServiceReadySpotAuthority(serviceRelocationAuthorityApplicationPayload(snapshot.payload))
+      ?.activationRecovery !== undefined
+  ) {
     return true;
   }
-  return snapshot.allocation.state === 'active'
-    && snapshot.allocation.objectKind === 'actor'
-    && decodeActorAuthorityIdentity(snapshot.payload, snapshot.objectGeneration) !== undefined;
+  return (
+    snapshot.allocation.state === 'active' &&
+    snapshot.allocation.objectKind === 'actor' &&
+    decodeActorAuthorityIdentity(snapshot.payload, snapshot.objectGeneration) !== undefined
+  );
 }
 
 function pendingInstanceActivation(
@@ -519,16 +517,16 @@ function pendingInstanceActivation(
   const projection = snapshot.pendingCreation;
   const decoded = decodeServiceInstanceAuthorityPayload(snapshot.payload);
   if (
-    allocation.state !== 'reserved'
-    || allocation.objectKind !== 'instance_spot'
-    || projection === undefined
-    || decoded?.state !== 'coldActivating'
-    || decoded.stableType !== allocation.stableType
-    || decoded.ownerId !== snapshot.ownerId
-    || decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration
-    || decoded.ownerMeshName !== allocation.descriptor.meshName
-    || decoded.ownerNodeGeneration !== allocation.descriptorLifecycleGeneration
-    || !routingIdsEqual(decoded.ownerNodeRid, allocation.descriptor.rid)
+    allocation.state !== 'reserved' ||
+    allocation.objectKind !== 'instance_spot' ||
+    projection === undefined ||
+    decoded?.state !== 'coldActivating' ||
+    decoded.stableType !== allocation.stableType ||
+    decoded.ownerId !== snapshot.ownerId ||
+    decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration ||
+    decoded.ownerMeshName !== allocation.descriptor.meshName ||
+    decoded.ownerNodeGeneration !== allocation.descriptorLifecycleGeneration ||
+    !routingIdsEqual(decoded.ownerNodeRid, allocation.descriptor.rid)
   ) {
     return undefined;
   }
@@ -561,17 +559,17 @@ function authorityRoute(snapshot: ZLinkAuthoritySnapshot): AppliedAuthorityRoute
     serviceRelocationAuthorityApplicationPayload(snapshot.payload)
   );
   if (
-    allocation.state !== 'active'
-    || allocation.objectKind === 'actor'
-    || allocation.descriptor.meshName.length === 0
-    || decoded === undefined
-    || decoded.kind !== allocation.objectKind
-    || decoded.stableType !== allocation.stableType
-    || decoded.ownerId !== snapshot.ownerId
-    || decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration
-    || decoded.ownerMeshName !== allocation.descriptor.meshName
-    || decoded.ownerNodeGeneration !== allocation.descriptorLifecycleGeneration
-    || !routingIdsEqual(decoded.ownerNodeRid, allocation.descriptor.rid)
+    allocation.state !== 'active' ||
+    allocation.objectKind === 'actor' ||
+    allocation.descriptor.meshName.length === 0 ||
+    decoded === undefined ||
+    decoded.kind !== allocation.objectKind ||
+    decoded.stableType !== allocation.stableType ||
+    decoded.ownerId !== snapshot.ownerId ||
+    decoded.ownerLeaseGeneration !== snapshot.ownerLeaseGeneration ||
+    decoded.ownerMeshName !== allocation.descriptor.meshName ||
+    decoded.ownerNodeGeneration !== allocation.descriptorLifecycleGeneration ||
+    !routingIdsEqual(decoded.ownerNodeRid, allocation.descriptor.rid)
   ) {
     return undefined;
   }
@@ -607,8 +605,9 @@ function authorityRoute(snapshot: ZLinkAuthoritySnapshot): AppliedAuthorityRoute
 }
 
 function authorityRouteKey(route: AppliedAuthorityRoute): string {
-  return `${route.meshName}\0${route.spotRoute.spot.spotId}\0`
-    + `${route.spotRoute.spot.generation}`;
+  return (
+    `${route.meshName}\0${route.spotRoute.spot.spotId}\0` + `${route.spotRoute.spot.generation}`
+  );
 }
 
 function sameAppliedRoute(
@@ -616,26 +615,28 @@ function sameAppliedRoute(
   right: AppliedAuthorityRoute | undefined
 ): boolean {
   if (right === undefined) return false;
-  return left.kind === right.kind
-    && left.stableType === right.stableType
-    && left.meshName === right.meshName
-    && left.instanceRoute.targetNodeRid === right.instanceRoute.targetNodeRid
-    && left.instanceRoute.targetNodeGeneration === right.instanceRoute.targetNodeGeneration
-    && left.instanceRoute.authorityOwnerGeneration === right.instanceRoute.authorityOwnerGeneration
-    && left.instanceRoute.storeVersion === right.instanceRoute.storeVersion;
+  return (
+    left.kind === right.kind &&
+    left.stableType === right.stableType &&
+    left.meshName === right.meshName &&
+    left.instanceRoute.targetNodeRid === right.instanceRoute.targetNodeRid &&
+    left.instanceRoute.targetNodeGeneration === right.instanceRoute.targetNodeGeneration &&
+    left.instanceRoute.authorityOwnerGeneration === right.instanceRoute.authorityOwnerGeneration &&
+    left.instanceRoute.storeVersion === right.instanceRoute.storeVersion
+  );
 }
 
 function asStatefulAuthorityRouteSink(
   node: ZLinkBackendMeshNode
 ): StatefulAuthorityRouteSink | undefined {
   const candidate = node as ZLinkBackendMeshNode & Partial<StatefulAuthorityRouteSink>;
-  return typeof candidate.rememberSpotRoute === 'function'
-    && typeof candidate.forgetSpotRoute === 'function'
-    && typeof candidate.registerInstanceIntent === 'function'
-    && typeof candidate.forgetInstanceIntent === 'function'
-    && typeof candidate.recoverInstanceActivation === 'function'
-    && typeof candidate.completeRecoveredInstanceActivation === 'function'
-    ? candidate as StatefulAuthorityRouteSink
+  return typeof candidate.rememberSpotRoute === 'function' &&
+    typeof candidate.forgetSpotRoute === 'function' &&
+    typeof candidate.registerInstanceIntent === 'function' &&
+    typeof candidate.forgetInstanceIntent === 'function' &&
+    typeof candidate.recoverInstanceActivation === 'function' &&
+    typeof candidate.completeRecoveredInstanceActivation === 'function'
+    ? (candidate as StatefulAuthorityRouteSink)
     : undefined;
 }