@zlink-systems/framework 0.21.0 → 0.22.0

package/src/runtime/spots/spot-handler-registry.ts

@@ -4,7 +4,7 @@ import type {
   ZLinkEntrySpot,
   ZLinkInstanceSpotHandlerRegistry,
   ZLinkSpot,
-  ZLinkSpotHandlerRegistry,
+  ZLinkSpotHandlerRegistry
 } from '../../contracts';
 import type {
   ZLinkEntrySpotActorRequestHandlerRegistration,
@@ -17,19 +17,11 @@ import type {
   ZLinkSpotSubscriptionHandlerRegistration
 } from '../../contracts/Configuration/RegistrationTypes';
 import { ZLinkConfigurationException } from '../configuration';
-import {
-  ZLinkActorPacketKind,
-  ZLinkSpotActorHandlerRegistryRuntime
-} from '../actors';
+import { ZLinkActorPacketKind, ZLinkSpotActorHandlerRegistryRuntime } from '../actors';
 import { readZLinkDecoratorMetadata } from '../../contracts/Handlers/Attributes';
 
 export interface ZLinkSpotHandlerRegistration {
-  readonly kind:
-    | 'packet'
-    | 'subscribe'
-    | 'actorSend'
-    | 'actorRequest'
-    | 'spotHandler';
+  readonly kind: 'packet' | 'subscribe' | 'actorSend' | 'actorRequest' | 'spotHandler';
   readonly handlerType: Type;
   readonly packetName?: string;
   readonly channelName?: string;
@@ -37,14 +29,17 @@ export interface ZLinkSpotHandlerRegistration {
   readonly actorType?: Type<ZLinkActor>;
 }
 
-export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkActor> implements ZLinkSpotHandlerRegistry {
+export class DefaultZLinkSpotHandlerRegistry<
+  TActor extends ZLinkActor = ZLinkActor
+> implements ZLinkSpotHandlerRegistry {
   private readonly entries: ZLinkSpotHandlerRegistration[] = [];
 
   constructor(private readonly actorHandlers?: ZLinkSpotActorHandlerRegistryRuntime) {}
 
   addHandler<THandler>(handlerType: Type<THandler>, packetName?: string): this {
-    const metadata = readZLinkDecoratorMetadata(handlerType).find((entry) =>
-      entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
+    const metadata = readZLinkDecoratorMetadata(handlerType).find(
+      (entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest'
+    );
     const resolvedPacketName = packetName ?? metadata?.packetName;
     if (metadata === undefined || resolvedPacketName === undefined) {
       throw new ZLinkConfigurationException(
@@ -52,9 +47,7 @@ export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkAc
       );
     }
     return this.addActorPacketRegistration(
-      metadata.kind === 'spotActorSend'
-        ? ZLinkActorPacketKind.Send
-        : ZLinkActorPacketKind.Request,
+      metadata.kind === 'spotActorSend' ? ZLinkActorPacketKind.Send : ZLinkActorPacketKind.Request,
       handlerType,
       Object as unknown as Type<TActor>,
       resolvedPacketName
@@ -65,10 +58,13 @@ export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkAc
     handlerType: Type<THandler>,
     actorType: Type<TRegisteredActor>
   ): this {
-    const metadata = readZLinkDecoratorMetadata(handlerType).find((entry) =>
-      entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
+    const metadata = readZLinkDecoratorMetadata(handlerType).find(
+      (entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest'
+    );
     if (metadata?.packetName === undefined) {
-      throw new ZLinkConfigurationException(`Actor packet handler '${handlerType.name}' must declare a packet name.`);
+      throw new ZLinkConfigurationException(
+        `Actor packet handler '${handlerType.name}' must declare a packet name.`
+      );
     }
     return this.addActorPacketRegistration(
       metadata.kind === 'spotActorSend' ? ZLinkActorPacketKind.Send : ZLinkActorPacketKind.Request,
@@ -79,9 +75,14 @@ export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkAc
   }
 
   addPacket(handlerType: Type, packetName?: string): this {
-    const declared = readZLinkDecoratorMetadata(handlerType)
-      .find((entry) => entry.kind === 'packet')?.packetName;
-    this.entries.push({ kind: 'packet', handlerType, packetName: packetName ?? declared ?? handlerType.name });
+    const declared = readZLinkDecoratorMetadata(handlerType).find(
+      (entry) => entry.kind === 'packet'
+    )?.packetName;
+    this.entries.push({
+      kind: 'packet',
+      handlerType,
+      packetName: packetName ?? declared ?? handlerType.name
+    });
     return this;
   }
 
@@ -110,7 +111,11 @@ export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkAc
     return this;
   }
 
-  actorSend(packetName: string, handlerType: Type, actorType: Type<TActor> = Object as unknown as Type<TActor>): this {
+  actorSend(
+    packetName: string,
+    handlerType: Type,
+    actorType: Type<TActor> = Object as unknown as Type<TActor>
+  ): this {
     return this.addActorPacketRegistration(
       ZLinkActorPacketKind.Send,
       handlerType,
@@ -119,7 +124,11 @@ export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkAc
     );
   }
 
-  actorRequest(packetName: string, handlerType: Type, actorType: Type<TActor> = Object as unknown as Type<TActor>): this {
+  actorRequest(
+    packetName: string,
+    handlerType: Type,
+    actorType: Type<TActor> = Object as unknown as Type<TActor>
+  ): this {
     return this.addActorPacketRegistration(
       ZLinkActorPacketKind.Request,
       handlerType,
@@ -135,10 +144,15 @@ export class DefaultZLinkSpotHandlerRegistry<TActor extends ZLinkActor = ZLinkAc
     if (topic.trim().length === 0) {
       throw new ZLinkConfigurationException('SPOT subscribe topic must not be empty.');
     }
-    if (this.entries.some((entry) => entry.kind === 'subscribe'
-      && entry.handlerType === handlerType
-      && entry.channelName === channelName
-      && entry.topic === topic)) {
+    if (
+      this.entries.some(
+        (entry) =>
+          entry.kind === 'subscribe' &&
+          entry.handlerType === handlerType &&
+          entry.channelName === channelName &&
+          entry.topic === topic
+      )
+    ) {
       return this;
     }
     this.entries.push({ kind: 'subscribe', handlerType, channelName, topic });
@@ -268,6 +282,5 @@ function isSpotImplementation(
   registeredType: Type<ZLinkSpot>,
   implementation: Type<ZLinkSpot>
 ): boolean {
-  return registeredType === implementation
-    || implementation.prototype instanceof registeredType;
+  return registeredType === implementation || implementation.prototype instanceof registeredType;
 }

package/src/runtime/spots/spot-location-claim.ts

@@ -1,9 +1,10 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException  } from '../framework-errors-internal';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException
+} from '../framework-errors-internal';
 import type { RoutingId } from '../../contracts';
 import { ZLinkLocationWriteStatus } from '../../contracts/Locations';
-import {
-  ZLinkSpotKind,
-} from '../../contracts';
+import { ZLinkSpotKind } from '../../contracts';
 import { ZLinkConfigurationException } from '../configuration';
 import type { ZLinkLocationLifecycle } from '../locations';
 

package/src/runtime/spots/spot-manager-public.ts

@@ -1,4 +1,9 @@
-import { ZLinkFrameworkInternalErrorKind, createInternalFrameworkException, internalFrameworkErrorKind, wireReplyFailureException  } from '../framework-errors-internal';
+import {
+  ZLinkFrameworkInternalErrorKind,
+  createInternalFrameworkException,
+  internalFrameworkErrorKind,
+  wireReplyFailureException
+} from '../framework-errors-internal';
 import { randomUUID } from 'node:crypto';
 import {
   ZLinkFrameworkException,
@@ -16,23 +21,14 @@ import {
 import type { ZLinkMessageSerializer } from '../../contracts';
 import type { ZLinkObjectFactoryRegistration } from '../../contracts/Configuration/RegistrationTypes';
 import { ZLinkConfigurationException } from '../configuration';
-import type {
-  ZLinkUserSpotCreationCoordinator
-} from '../host/user-spot-creation-coordinator';
+import type { ZLinkUserSpotCreationCoordinator } from '../host/user-spot-creation-coordinator';
 import type { ZLinkSpotRouteResolver } from './spot-routing-internal';
 import type { DefaultZLinkSpotManager } from './index';
 import { encodeFrameworkCreationPayload } from '../messaging/creation-payload-codec';
-import type {
-  ServiceUserSpotCloseRecord
-} from '../foundation/service-stateful-wire-codec';
-import type {
-  ServiceUserSpotOperationResult
-} from '../foundation/service-stateful-runtime';
+import type { ServiceUserSpotCloseRecord } from '../foundation/service-stateful-wire-codec';
+import type { ServiceUserSpotOperationResult } from '../foundation/service-stateful-runtime';
 import type { ZLinkAuthoritySnapshot } from '../locations/internal-location-contracts';
-import {
-  captureZLinkSpotSerialTurn,
-  requireZLinkYieldTurn
-} from '../execution';
+import { captureZLinkSpotSerialTurn, requireZLinkYieldTurn } from '../execution';
 
 export interface ZLinkPublicSpotManagerOptions {
   readonly local: DefaultZLinkSpotManager;
@@ -88,8 +84,8 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
       };
     } catch (error) {
       if (
-        error instanceof ZLinkFrameworkException
-        && internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotRouteNotFound
+        error instanceof ZLinkFrameworkException &&
+        internalFrameworkErrorKind(error) === ZLinkFrameworkInternalErrorKind.SpotRouteNotFound
       ) {
         return undefined;
       }
@@ -138,10 +134,7 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
       },
       timeoutMs
     );
-    if (
-      result.terminalResult !== 0
-      || result.tail?.kind !== 'userSpotClose'
-    ) {
+    if (result.terminalResult !== 0 || result.tail?.kind !== 'userSpotClose') {
       const message = `Remote User Spot close failed. terminalResult=${result.terminalResult}, failureCode=${result.failureCode}.`;
       //  Route the close terminal through the shared ownership-aware translator
       //  (spec 32-framework-error-model:81-118, 99-108) instead of an ad-hoc
@@ -193,22 +186,10 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
         state.timeoutMs = timeoutMs;
         return call;
       },
-      submit: (signal) => this.submit(
-        spotId,
-        stableType,
-        generatedIdentity,
-        state,
-        signal
-      ),
+      submit: (signal) => this.submit(spotId, stableType, generatedIdentity, state, signal),
       yield: (signal) => {
         const yieldTurn = requireZLinkYieldTurn(turn);
-        const pending = this.submit(
-          spotId,
-          stableType,
-          generatedIdentity,
-          state,
-          signal
-        );
+        const pending = this.submit(spotId, stableType, generatedIdentity, state, signal);
         return yieldTurn.yieldPromise(pending);
       }
     };
@@ -243,54 +224,53 @@ export class ZLinkPublicSpotManager implements ZLinkSpotManager {
         true
       );
     }
-    const coordinated = await this.options.coordinator.getOrCreate({
-      meshName: state.meshName,
-      spotId,
-      stableType,
-      requestPayload: requestBytes,
-      timeoutMs: Math.ceil(remainingMs),
-      signal,
-      generatedIdentity
-    }, async (target, authority, deadlineSignal) => {
-          const selected = selectFactory(this.options.factories, stableType, target.meshName);
-          this.options.local.beginUserSpotPublication(target.meshName, spotId);
-          try {
-            const result = await this.options.local.getOrCreateWithAuthority(
-              target.meshName,
-              selected.registration.implementation as Type<ZLinkSpot>,
-              spotId,
-              state.request,
-              {
-                stableType,
-                objectGeneration: authority.objectGeneration,
-                authorityOwnerGeneration: authority.authorityOwnerGeneration
-              },
-              deadlineSignal
-            );
-            return {
-              ...result,
-              publication: {
-                publish: () => this.options.local.publishUserSpot(
-                  target.meshName,
-                  spotId
-                ),
-                abort: () => this.options.local.abortUserSpotPublication(
-                  target.meshName,
-                  spotId
-                )
-              }
-            };
-          } catch (error) {
-            this.options.local.abortUserSpotPublication(target.meshName, spotId);
-            throw error;
-          }
-        }, async (cleanupSignal) => {
-          const meshName = state.meshName ?? [...this.options.factories]
-            .find(([, byType]) => byType.has(stableType))?.[0];
-          if (meshName !== undefined) {
-            await this.options.local.close(meshName, spotId, cleanupSignal);
-          }
-        });
+    const coordinated = await this.options.coordinator.getOrCreate(
+      {
+        meshName: state.meshName,
+        spotId,
+        stableType,
+        requestPayload: requestBytes,
+        timeoutMs: Math.ceil(remainingMs),
+        signal,
+        generatedIdentity
+      },
+      async (target, authority, deadlineSignal) => {
+        const selected = selectFactory(this.options.factories, stableType, target.meshName);
+        this.options.local.beginUserSpotPublication(target.meshName, spotId);
+        try {
+          const result = await this.options.local.getOrCreateWithAuthority(
+            target.meshName,
+            selected.registration.implementation as Type<ZLinkSpot>,
+            spotId,
+            state.request,
+            {
+              stableType,
+              objectGeneration: authority.objectGeneration,
+              authorityOwnerGeneration: authority.authorityOwnerGeneration
+            },
+            deadlineSignal
+          );
+          return {
+            ...result,
+            publication: {
+              publish: () => this.options.local.publishUserSpot(target.meshName, spotId),
+              abort: () => this.options.local.abortUserSpotPublication(target.meshName, spotId)
+            }
+          };
+        } catch (error) {
+          this.options.local.abortUserSpotPublication(target.meshName, spotId);
+          throw error;
+        }
+      },
+      async (cleanupSignal) => {
+        const meshName =
+          state.meshName ??
+          [...this.options.factories].find(([, byType]) => byType.has(stableType))?.[0];
+        if (meshName !== undefined) {
+          await this.options.local.close(meshName, spotId, cleanupSignal);
+        }
+      }
+    );
     this.options.resolver()?.invalidate?.(spotId);
     return coordinated.result;
   }

package/src/runtime/spots/spot-native-actor-join-admission.ts

@@ -12,10 +12,7 @@ import {
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import type { Message } from '../../contracts/Common/Message';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import type {
-  ZLinkBackendActorJoinRequest,
-  ZLinkBackendSpot
-} from '../backend/contracts';
+import type { ZLinkBackendActorJoinRequest, ZLinkBackendSpot } from '../backend/contracts';
 import type { ZLinkDispatchErrorReporter } from '../channels';
 import {
   encodeFrameworkPayloadMessage,
@@ -57,16 +54,20 @@ export class ZLinkSpotNativeActorJoinAdmission {
       if (actor !== undefined) {
         const target = this.options.getTarget();
         const joinRequest = request.message;
-        const joinPayload = wrapFrameworkPayloadMessage(joinRequest, this.options.messageSerializers);
+        const joinPayload = wrapFrameworkPayloadMessage(
+          joinRequest,
+          this.options.messageSerializers
+        );
         const response: ZLinkSpotActorJoinResult = await this.options.serial.execute(async () =>
           this.options.defaultAccept || target.onActorJoin === undefined
             ? { accepted: this.options.defaultAccept }
             : target.onActorJoin(actorId, joinPayload)
         );
         accepted = response.accepted;
-        reply = response.reply === undefined
-          ? undefined
-          : encodeFrameworkPayloadMessage(response.reply, this.options.messageSerializers);
+        reply =
+          response.reply === undefined
+            ? undefined
+            : encodeFrameworkPayloadMessage(response.reply, this.options.messageSerializers);
         if (accepted) {
           acceptedActor = actor;
         }
@@ -104,11 +105,13 @@ export class ZLinkSpotNativeActorJoinAdmission {
     }
   }
 
-  private decodeNativeActorJoinRequest(message: Message): {
-    readonly actorType: string;
-    readonly actorCreateRequest?: Message;
-    readonly request: Message;
-  } | undefined {
+  private decodeNativeActorJoinRequest(message: Message):
+    | {
+        readonly actorType: string;
+        readonly actorCreateRequest?: Message;
+        readonly request: Message;
+      }
+    | undefined {
     try {
       const payload = JSON.parse(message.data().toString()) as {
         readonly packetName?: unknown;
@@ -128,9 +131,10 @@ export class ZLinkSpotNativeActorJoinAdmission {
       }
       return {
         actorType: payload.actorType,
-        actorCreateRequest: typeof payload.actorCreateRequest === 'string'
-          ? RuntimeMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
-          : undefined,
+        actorCreateRequest:
+          typeof payload.actorCreateRequest === 'string'
+            ? RuntimeMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
+            : undefined,
         request: RuntimeMessage.from(Buffer.from(payload.request, 'base64'))
       };
     } catch {

package/src/runtime/spots/spot-node-autoconnect.ts

@@ -4,10 +4,7 @@ import type { ZLinkPeerLocationResolver } from '../../contracts/Locations/Resolv
 import type { ZLinkDomainLocationStore as ZLinkLocationStore } from '../locations/domain-store-contract';
 import type { ZLinkPeerLocation } from '../../contracts/Locations/Rows';
 import { ZLinkLocationAutoConnectType } from '../../contracts/Locations/Values';
-import {
-  ZLinkFrameworkRuntimeState,
-  ZLinkLocationRole
-} from '../../contracts';
+import { ZLinkFrameworkRuntimeState, ZLinkLocationRole } from '../../contracts';
 import type { ZLinkSpotNodeOptions } from '../configuration';
 import type { ZLinkBackendMeshNode } from '../backend/contracts';
 import { AsyncResource } from 'node:async_hooks';
@@ -83,37 +80,28 @@ export function spotNodeAutoConnectCapability(
     nodeRid: String(status.routingId),
     endpoint,
     objectRole: spotNode.objectRole ?? 'none',
-    hasRouteMeshServerChannel: Object.values(spotNode.meshChannels ?? {})
-      .some((channel) => channel.server === true)
+    hasRouteMeshServerChannel: Object.values(spotNode.meshChannels ?? {}).some(
+      (channel) => channel.server === true
+    )
   };
   const manualConnections = hasManualRouterConnections(spotNode);
   return {
     local,
-    executor: new ZLinkSpotNodeAutoConnectExecutor(
-      node,
-      manualConnections
-    )
+    executor: new ZLinkSpotNodeAutoConnectExecutor(node, manualConnections)
   };
 }
 
-function meshDescriptorPeerResolver(
-  runtime: ZLinkLocationRuntime
-): ZLinkPeerLocationResolver {
+function meshDescriptorPeerResolver(runtime: ZLinkLocationRuntime): ZLinkPeerLocationResolver {
   return {
     async listLivePeers(
       filter: ZLinkPeerLocationFilter,
       signal?: AbortSignal
     ): Promise<readonly ZLinkPeerLocation[]> {
       if (
-        filter.meshName === undefined
-        || (
-          filter.autoConnectType !== undefined
-          && filter.autoConnectType !== ZLinkLocationAutoConnectType.RouteMesh
-        )
-        || (
-          filter.role !== undefined
-          && filter.role !== ZLinkLocationRole.Router
-        )
+        filter.meshName === undefined ||
+        (filter.autoConnectType !== undefined &&
+          filter.autoConnectType !== ZLinkLocationAutoConnectType.RouteMesh) ||
+        (filter.role !== undefined && filter.role !== ZLinkLocationRole.Router)
       ) {
         return [];
       }
@@ -133,23 +121,25 @@ function meshDescriptorPeerResolver(
           updatedAt: descriptor.updatedAt,
           metadata: {
             objectRole: descriptor.objectRole,
-            hasRouteMeshServerChannel:
-              String(Object.keys(descriptor.channelWeights).length > 0),
+            hasRouteMeshServerChannel: String(Object.keys(descriptor.channelWeights).length > 0),
             descriptorRevision: descriptor.descriptorRevision.toString(),
             securityIdentity: descriptor.securityIdentity
           }
         }))
-        .filter(peer =>
-          (filter.nodeRid === undefined || String(peer.nodeRid) === String(filter.nodeRid))
-          && (filter.endpoint === undefined || peer.endpoint === filter.endpoint)
+        .filter(
+          (peer) =>
+            (filter.nodeRid === undefined || String(peer.nodeRid) === String(filter.nodeRid)) &&
+            (filter.endpoint === undefined || peer.endpoint === filter.endpoint)
         );
     }
   };
 }
 
 function hasManualRouterConnections(spotNode: ZLinkSpotNodeOptions): boolean {
-  return (spotNode.router?.manualConnections?.length ?? 0) > 0
-    || (spotNode.router?.manualPeerConnections?.length ?? 0) > 0;
+  return (
+    (spotNode.router?.manualConnections?.length ?? 0) > 0 ||
+    (spotNode.router?.manualPeerConnections?.length ?? 0) > 0
+  );
 }
 
 const detachedSpotNodeAutoConnectResource = new AsyncResource('zlink:spot-node-autoconnect');
@@ -186,17 +176,16 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
 
   disconnectStalePeers(targets: readonly ZLinkAutoConnectTarget[]): void {
     if (this.manualConnections) return;
-    const current = new Map(targets
-      .filter((target) => target.nodeRid !== undefined)
-      .map((target) => [String(target.nodeRid), target]));
+    const current = new Map(
+      targets
+        .filter((target) => target.nodeRid !== undefined)
+        .map((target) => [String(target.nodeRid), target])
+    );
     const peers = this.node.peers();
     for (const peer of peers) {
       if (peer.routingId === null) continue;
       const target = current.get(String(peer.routingId));
-      if (
-        target !== undefined
-        && peer.endpoint === target.endpoint
-      ) {
+      if (target !== undefined && peer.endpoint === target.endpoint) {
         continue;
       }
       this.node.disconnectPeer(peer.routingId, peer.lifecycleGeneration);
@@ -208,25 +197,35 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
     // reached the admitted table yet. Shutdown must remove that intent before
     // it can treat the automatic route as disconnected.
     if (this.connectionIntents.has(connectionKey(target))) return false;
-    return !this.node.peers().some((peer) =>
-      peer.routingId !== null &&
-      peer.endpoint === target.endpoint &&
-      (target.nodeRid === undefined || String(peer.routingId) === String(target.nodeRid)) &&
-      peer.lifecycleGeneration === target.lifecycleGeneration &&
-      peer.state === 3);
+    return !this.node
+      .peers()
+      .some(
+        (peer) =>
+          peer.routingId !== null &&
+          peer.endpoint === target.endpoint &&
+          (target.nodeRid === undefined || String(peer.routingId) === String(target.nodeRid)) &&
+          peer.lifecycleGeneration === target.lifecycleGeneration &&
+          peer.state === 3
+      );
   }
 
   replaceNotRequired(targets: readonly ZLinkAutoConnectTarget[]): void {
-    this.node.replaceDiscoveredNotRequiredPeers?.(targets
-      .filter((target): target is ZLinkAutoConnectTarget & {
-        readonly nodeRid: NonNullable<ZLinkAutoConnectTarget['nodeRid']>;
-      } => target.nodeRid !== undefined)
-      .map(target => ({
-        nodeRoutingId: String(target.nodeRid),
-        lifecycleGeneration: target.lifecycleGeneration,
-        descriptorRevision: target.descriptorRevision ?? 1n,
-        endpoint: target.endpoint
-      })));
+    this.node.replaceDiscoveredNotRequiredPeers?.(
+      targets
+        .filter(
+          (
+            target
+          ): target is ZLinkAutoConnectTarget & {
+            readonly nodeRid: NonNullable<ZLinkAutoConnectTarget['nodeRid']>;
+          } => target.nodeRid !== undefined
+        )
+        .map((target) => ({
+          nodeRoutingId: String(target.nodeRid),
+          lifecycleGeneration: target.lifecycleGeneration,
+          descriptorRevision: target.descriptorRevision ?? 1n,
+          endpoint: target.endpoint
+        }))
+    );
   }
 
   expectPeers(targets: readonly ZLinkAutoConnectTarget[]): void {
@@ -235,9 +234,7 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
       this.node.expectPeer?.({
         nodeRoutingId: String(target.nodeRid),
         endpoint: target.endpoint,
-        securityIdentity: toAdmissionSecurityIdentity(
-          target.metadata?.securityIdentity
-        ),
+        securityIdentity: toAdmissionSecurityIdentity(target.metadata?.securityIdentity),
         lifecycleGeneration: target.lifecycleGeneration
       });
     }
@@ -258,12 +255,8 @@ class ZLinkSpotNodeAutoConnectExecutor implements IZLinkAutoConnectExecutor {
     try {
       const connectionIntentId = await this.node.connectPeer({
         endpoint: target.endpoint,
-        expectedRid: target.nodeRid === undefined
-          ? undefined
-          : toBackendRoutingId(target.nodeRid),
-        expectedSecurityIdentity: toAdmissionSecurityIdentity(
-          target.metadata?.securityIdentity
-        ),
+        expectedRid: target.nodeRid === undefined ? undefined : toBackendRoutingId(target.nodeRid),
+        expectedSecurityIdentity: toAdmissionSecurityIdentity(target.metadata?.securityIdentity),
         expectedLifecycleGeneration: target.lifecycleGeneration
       });
       const accepted = await this.lane.run(() => {