@zlink-systems/framework 0.21.0 → 0.23.0

package/src/contracts/Handlers/JsonContract.ts

@@ -52,14 +52,18 @@ export function defineZLinkPacketJsonContract(
   const contracts = packetJsonContracts();
   const current = contracts.get(packetName);
   if (current !== undefined && canonicalContract(current) !== canonicalContract(normalized)) {
-    throw new TypeError(`ZLink packet '${packetName}' has conflicting JSON contracts in one process.`);
+    throw new TypeError(
+      `ZLink packet '${packetName}' has conflicting JSON contracts in one process.`
+    );
   }
   if (current !== undefined) return current;
   contracts.set(packetName, normalized);
   return normalized;
 }
 
-export function readZLinkPacketJsonContract(packetName: string): ZLinkPacketJsonContract | undefined {
+export function readZLinkPacketJsonContract(
+  packetName: string
+): ZLinkPacketJsonContract | undefined {
   return packetJsonContracts().get(packetName);
 }
 
@@ -72,10 +76,13 @@ function normalizeJsonSchema(
   // the TypeScript signature describes the accepted shape.
   const runtimeSchema: unknown = schema;
   if (typeof runtimeSchema !== 'object' || runtimeSchema === null || depth > 64) {
-    throw new TypeError('ZLink packet JSON schema must be an acyclic object with at most 64 levels.');
+    throw new TypeError(
+      'ZLink packet JSON schema must be an acyclic object with at most 64 levels.'
+    );
   }
   const normalizedSchema = runtimeSchema as ZLinkJsonSchema;
-  if (parents.has(normalizedSchema)) throw new TypeError('ZLink packet JSON schema must not contain a cycle.');
+  if (parents.has(normalizedSchema))
+    throw new TypeError('ZLink packet JSON schema must not contain a cycle.');
   const nextParents = new Set(parents).add(normalizedSchema);
   switch (normalizedSchema.type) {
     case 'boolean':
@@ -88,9 +95,11 @@ function normalizeJsonSchema(
     case 'bytes':
       return Object.freeze({ type: normalizedSchema.type });
     case 'enum': {
-      if (!Array.isArray(normalizedSchema.names)
-          || normalizedSchema.names.length === 0
-          || normalizedSchema.names.some((name) => typeof name !== 'string' || name.length === 0)) {
+      if (
+        !Array.isArray(normalizedSchema.names) ||
+        normalizedSchema.names.length === 0 ||
+        normalizedSchema.names.some((name) => typeof name !== 'string' || name.length === 0)
+      ) {
         throw new TypeError('ZLink packet enum schema requires non-empty string names.');
       }
       if (new Set(normalizedSchema.names).size !== normalizedSchema.names.length) {
@@ -99,25 +108,45 @@ function normalizeJsonSchema(
       return Object.freeze({ type: 'enum', names: Object.freeze([...normalizedSchema.names]) });
     }
     case 'nullable':
-      return Object.freeze({ type: 'nullable', value: normalizeJsonSchema(normalizedSchema.value, nextParents, depth + 1) });
+      return Object.freeze({
+        type: 'nullable',
+        value: normalizeJsonSchema(normalizedSchema.value, nextParents, depth + 1)
+      });
     case 'array':
-      return Object.freeze({ type: 'array', items: normalizeJsonSchema(normalizedSchema.items, nextParents, depth + 1) });
+      return Object.freeze({
+        type: 'array',
+        items: normalizeJsonSchema(normalizedSchema.items, nextParents, depth + 1)
+      });
     case 'record':
-      return Object.freeze({ type: 'record', values: normalizeJsonSchema(normalizedSchema.values, nextParents, depth + 1) });
+      return Object.freeze({
+        type: 'record',
+        values: normalizeJsonSchema(normalizedSchema.values, nextParents, depth + 1)
+      });
     case 'object': {
       const runtimeProperties: unknown = normalizedSchema.properties;
-      if (typeof runtimeProperties !== 'object' || runtimeProperties === null || Array.isArray(runtimeProperties)) {
+      if (
+        typeof runtimeProperties !== 'object' ||
+        runtimeProperties === null ||
+        Array.isArray(runtimeProperties)
+      ) {
         throw new TypeError('ZLink packet object schema properties must be an object.');
       }
-      if (!Array.isArray(normalizedSchema.required)
-          || normalizedSchema.required.some((name) => typeof name !== 'string' || name.length === 0)) {
+      if (
+        !Array.isArray(normalizedSchema.required) ||
+        normalizedSchema.required.some((name) => typeof name !== 'string' || name.length === 0)
+      ) {
         throw new TypeError('ZLink packet object schema required must contain property names.');
       }
-      if (normalizedSchema.additionalProperties !== undefined && typeof normalizedSchema.additionalProperties !== 'boolean') {
+      if (
+        normalizedSchema.additionalProperties !== undefined &&
+        typeof normalizedSchema.additionalProperties !== 'boolean'
+      ) {
         throw new TypeError('ZLink packet object schema additionalProperties must be boolean.');
       }
       const properties: Record<string, ZLinkJsonSchema> = {};
-      for (const [name, property] of Object.entries(runtimeProperties as Record<string, ZLinkJsonSchema>)) {
+      for (const [name, property] of Object.entries(
+        runtimeProperties as Record<string, ZLinkJsonSchema>
+      )) {
         if (name === '__proto__' || name === 'prototype' || name === 'constructor') {
           throw new TypeError(`ZLink packet JSON property '${name}' is not allowed.`);
         }
@@ -131,7 +160,9 @@ function normalizeJsonSchema(
           throw new TypeError(`ZLink packet JSON property '${name}' is not allowed.`);
         }
         if (!Object.prototype.hasOwnProperty.call(properties, name)) {
-          throw new TypeError(`ZLink packet JSON required property '${name}' has no property schema.`);
+          throw new TypeError(
+            `ZLink packet JSON required property '${name}' has no property schema.`
+          );
         }
       }
       return Object.freeze({
@@ -144,12 +175,15 @@ function normalizeJsonSchema(
       });
     }
   }
-  throw new TypeError(`ZLink packet JSON schema type '${String((normalizedSchema as { type?: unknown }).type)}' is not supported.`);
+  throw new TypeError(
+    `ZLink packet JSON schema type '${String((normalizedSchema as { type?: unknown }).type)}' is not supported.`
+  );
 }
 
 function packetJsonContracts(): Map<string, ZLinkPacketJsonContract> {
   const root = globalThis as typeof globalThis & Record<symbol, unknown>;
-  let contracts = root[ZLINK_PACKET_JSON_CONTRACTS] as Map<string, ZLinkPacketJsonContract> | undefined;
+  let contracts = root[ZLINK_PACKET_JSON_CONTRACTS] as
+    Map<string, ZLinkPacketJsonContract> | undefined;
   if (contracts === undefined) {
     contracts = new Map();
     Object.defineProperty(root, ZLINK_PACKET_JSON_CONTRACTS, {
@@ -166,7 +200,7 @@ function canonicalContract(value: unknown): string {
   if (Array.isArray(value)) return `[${value.map(canonicalContract).join(',')}]`;
   if (typeof value !== 'object' || value === null) return JSON.stringify(value);
   return `{${Object.entries(value as Record<string, unknown>)
-    .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+    .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
     .map(([key, item]) => `${JSON.stringify(key)}:${canonicalContract(item)}`)
     .join(',')}}`;
 }

package/src/contracts/Locations/ActorTransfer.ts

@@ -3,11 +3,7 @@ import type { ActorRef, RoutingId } from '../Common';
 export type ZLinkActorTransferState = 'prepared' | 'committed' | 'activated' | 'aborted';
 
 export type ZLinkActorTransferWriteStatus =
-  | 'stored'
-  | 'notFound'
-  | 'ignoredStale'
-  | 'rejectedConflict'
-  | 'invalidState';
+  'stored' | 'notFound' | 'ignoredStale' | 'rejectedConflict' | 'invalidState';
 
 export interface ZLinkActorTransferRecord {
   readonly meshName: string;

package/src/contracts/Locations/Authority.ts

@@ -64,8 +64,7 @@ export interface ZLinkAuthoritySnapshot {
 }
 
 export type ZLinkAuthorityReadResult =
-  | { readonly kind: 'missing'; readonly storeNow: Date }
-  | ZLinkAuthoritySnapshot;
+  { readonly kind: 'missing'; readonly storeNow: Date } | ZLinkAuthoritySnapshot;
 
 export type ZLinkAuthorityMutation =
   | {
@@ -120,9 +119,7 @@ export interface ZLinkAuthorityPage {
   readonly nextCursor?: ZLinkAuthorityScanCursor;
 }
 
-export type ZLinkAuthorityScanResult =
-  | ZLinkAuthorityPage
-  | { readonly kind: 'scanExpired' };
+export type ZLinkAuthorityScanResult = ZLinkAuthorityPage | { readonly kind: 'scanExpired' };
 
 export interface ZLinkObjectCreationKey {
   readonly kind: ZLinkPlacementObjectKind;
@@ -249,9 +246,7 @@ export interface ZLinkObjectAbortRequest {
 }
 
 export type ZLinkObjectAbortResult =
-  | { readonly kind: 'aborted' }
-  | { readonly kind: 'alreadyAborted' }
-  | { readonly kind: 'stale' };
+  { readonly kind: 'aborted' } | { readonly kind: 'alreadyAborted' } | { readonly kind: 'stale' };
 
 export interface ZLinkAggregateId {
   readonly value: string;
@@ -296,6 +291,4 @@ export type ZLinkAggregateCommitResult =
   | { readonly kind: 'generationExhausted' };
 
 export type ZLinkAggregateAbortResult =
-  | { readonly kind: 'aborted' }
-  | { readonly kind: 'alreadyAborted' }
-  | { readonly kind: 'stale' };
+  { readonly kind: 'aborted' } | { readonly kind: 'alreadyAborted' } | { readonly kind: 'stale' };

package/src/contracts/Locations/Keys.ts

@@ -1,6 +1,11 @@
 import type { RoutingId, SpotId } from '../Common';
 import type { ZLinkSpotKind } from '../Spots';
-import type { ZLinkLocationAutoConnectType, ZLinkLocationKind, ZLinkLocationRole, ZLinkRouteKind } from './Values';
+import type {
+  ZLinkLocationAutoConnectType,
+  ZLinkLocationKind,
+  ZLinkLocationRole,
+  ZLinkRouteKind
+} from './Values';
 
 /**
  * Peer identity is the full five-component tuple. Missing optional components

package/src/contracts/Locations/Options.ts

@@ -16,8 +16,9 @@ export interface ZLinkLocationOptions {
   relocationNodeInFlightPayloadBudgetBytes(value: number): this;
 }
 
-export type ZLinkLocationOptionOverrides =
-  Partial<ZLinkLocationOptionValues> & { readonly listPageSize?: number };
+export type ZLinkLocationOptionOverrides = Partial<ZLinkLocationOptionValues> & {
+  readonly listPageSize?: number;
+};
 
 export const zlinkRuntimeDefaultLocationOptions: Readonly<
   ZLinkLocationOptionValues & { readonly listPageSize: number }

package/src/contracts/Locations/RelocationStore.ts

@@ -37,10 +37,7 @@ export interface ZLinkRelocationStore {
     retentionMs: number,
     signal?: AbortSignal
   ): Promise<ZLinkBlobPutResult>;
-  read(
-    reference: ZLinkBlobReference,
-    signal?: AbortSignal
-  ): Promise<ZLinkBlobReadResult>;
+  read(reference: ZLinkBlobReference, signal?: AbortSignal): Promise<ZLinkBlobReadResult>;
   renew(
     reference: ZLinkBlobReference,
     retentionMs: number,

package/src/contracts/Locations/Resolvers.ts

@@ -1,8 +1,8 @@
-import type {
-  ZLinkPeerLocation,
-  ZLinkPeerLocationFilter,
-} from './Models';
+import type { ZLinkPeerLocation, ZLinkPeerLocationFilter } from './Models';
 
 export interface ZLinkPeerLocationResolver {
-  listLivePeers(filter: ZLinkPeerLocationFilter, signal?: AbortSignal): Promise<readonly ZLinkPeerLocation[]>;
+  listLivePeers(
+    filter: ZLinkPeerLocationFilter,
+    signal?: AbortSignal
+  ): Promise<readonly ZLinkPeerLocation[]>;
 }

package/src/contracts/Locations/RuntimeQuery.ts

@@ -6,7 +6,7 @@ import type {
   ZLinkLocationTopologyEntry,
   ZLinkLocationTopologyFilter,
   ZLinkMeshNodeDescriptor,
-  ZLinkPageRequest,
+  ZLinkPageRequest
 } from './Models';
 import type { ZLinkPlacementObjectKind } from './Authority';
 
@@ -52,5 +52,9 @@ export interface ZLinkLocationRuntimeQuery {
     spotId: import('../Common').SpotId,
     signal?: AbortSignal
   ): Promise<ZLinkLocationObjectEntry | undefined>;
-  listObjectLocations(filter: ZLinkLocationObjectFilter, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkLocationObjectEntry>>;
+  listObjectLocations(
+    filter: ZLinkLocationObjectFilter,
+    page?: ZLinkPageRequest,
+    signal?: AbortSignal
+  ): Promise<ZLinkLocationPage<ZLinkLocationObjectEntry>>;
 }

package/src/contracts/Locations/Stores.ts

@@ -81,8 +81,7 @@ export interface ZLinkStoreScanPage {
 }
 
 export type ZLinkStoreScanResult =
-  | { readonly kind: 'page'; readonly value: ZLinkStoreScanPage }
-  | { readonly kind: 'expired' };
+  { readonly kind: 'page'; readonly value: ZLinkStoreScanPage } | { readonly kind: 'expired' };
 
 export interface ZLinkLocationStore {
   read(key: ZLinkStoreKey, signal?: AbortSignal): Promise<ZLinkStoreReadResult>;

package/src/contracts/Locations/index.ts

@@ -17,14 +17,8 @@ export type {
   ZLinkStoreWriteRequest,
   ZLinkStoreWriteResult
 } from './Stores';
-export {
-  ZLinkLocationKind,
-  ZLinkLocationRole
-} from './Values';
-export {
-  ZLinkFrameworkRuntimeState,
-  ZLinkObjectRole
-} from './Rows';
+export { ZLinkLocationKind, ZLinkLocationRole } from './Values';
+export { ZLinkFrameworkRuntimeState, ZLinkObjectRole } from './Rows';
 export type {
   ZLinkClientServerServerDescriptor,
   ZLinkFanoutPublisherDescriptor,

package/src/contracts/RouteMesh/Contracts.ts

@@ -33,13 +33,7 @@ export type ZLinkMessageSurface =
   | 'classic_fanout'
   | 'actor_transfer';
 
-export type ZLinkMessageKind =
-  | 'send'
-  | 'request'
-  | 'response'
-  | 'error'
-  | 'publish'
-  | 'control';
+export type ZLinkMessageKind = 'send' | 'request' | 'response' | 'error' | 'publish' | 'control';
 
 export type ZLinkRequestFailureReason = 'timeout' | 'cancelled' | 'shutdown';
 

package/src/contracts/RouteMesh/RuntimeTopology.ts

@@ -1,8 +1,5 @@
 import type { RoutingId } from '../Common';
-import type {
-  ZLinkApplicationJobQueueProfile,
-  ZLinkCoreHwmProfile
-} from '../Dispatch';
+import type { ZLinkApplicationJobQueueProfile, ZLinkCoreHwmProfile } from '../Dispatch';
 import type {
   ZLinkPeerState,
   ZLinkTopologyReason,

package/src/contracts/Spots/Contracts.ts

@@ -1,11 +1,6 @@
 import type { ZLinkActor } from '../Actors';
 import type { ZLinkChannelRequestCall, ZLinkPublishCall, ZLinkSendCall } from '../Channels';
-import type {
-  RoutingId,
-  SpotId,
-  Type,
-  ZLinkMessageMetadata
-} from '../Common';
+import type { RoutingId, SpotId, Type, ZLinkMessageMetadata } from '../Common';
 import type { ZLinkSpotTimerHandler } from '../Handlers';
 import type { ZLinkTimer, ZLinkTimerOptions } from '../Timers';
 import type {
@@ -67,8 +62,7 @@ export interface ZLinkSpotContext<
   close(signal?: AbortSignal): Promise<boolean>;
 }
 
-export interface ZLinkInstanceSpotContext
-  extends ZLinkSpotCommonContext<ZLinkInstanceSpot> {
+export interface ZLinkInstanceSpotContext extends ZLinkSpotCommonContext<ZLinkInstanceSpot> {
   readonly handlers: ZLinkInstanceSpotHandlerRegistry;
   close(signal?: AbortSignal): Promise<boolean>;
 }

package/src/contracts/Spots/SpotKind.ts

@@ -7,18 +7,26 @@ export enum ZLinkSpotKind {
 
 export function zlinkSpotKindToWire(kind: ZLinkSpotKind): number {
   switch (kind) {
-    case ZLinkSpotKind.Entry: return 1;
-    case ZLinkSpotKind.User: return 2;
-    case ZLinkSpotKind.Instance: return 3;
-    default: return 0;
+    case ZLinkSpotKind.Entry:
+      return 1;
+    case ZLinkSpotKind.User:
+      return 2;
+    case ZLinkSpotKind.Instance:
+      return 3;
+    default:
+      return 0;
   }
 }
 
 export function zlinkSpotKindFromWire(value: number): ZLinkSpotKind {
   switch (value) {
-    case 1: return ZLinkSpotKind.Entry;
-    case 2: return ZLinkSpotKind.User;
-    case 3: return ZLinkSpotKind.Instance;
-    default: return ZLinkSpotKind.Invalid;
+    case 1:
+      return ZLinkSpotKind.Entry;
+    case 2:
+      return ZLinkSpotKind.User;
+    case 3:
+      return ZLinkSpotKind.Instance;
+    default:
+      return ZLinkSpotKind.Invalid;
   }
 }

package/src/contracts/Spots/ZLinkSpot.ts

@@ -41,9 +41,7 @@ export interface ZLinkSpotRelocationReadyCall {
   defer(): void;
 }
 
-export interface ZLinkSpotActorMembershipLifecycle<
-  TActor extends ZLinkActor = ZLinkActor
-> {
+export interface ZLinkSpotActorMembershipLifecycle<TActor extends ZLinkActor = ZLinkActor> {
   onJoinedActor(actor: TActor): Promise<void>;
   onLeaveActor(actor: TActor): Promise<void>;
   onDisconnectActor?(actor: TActor): Promise<void>;
@@ -58,8 +56,9 @@ export interface ZLinkUserSpotActorLifecycle<
   onActorJoin(actorId: string, request: ZLinkMessage): Promise<ZLinkSpotActorJoinResult>;
 }
 
-export interface ZLinkSpot<TActor extends ZLinkActor = ZLinkActor>
-  extends ZLinkUserSpotActorLifecycle<TActor> {
+export interface ZLinkSpot<
+  TActor extends ZLinkActor = ZLinkActor
+> extends ZLinkUserSpotActorLifecycle<TActor> {
   readonly context: ZLinkSpotContext<TActor>;
   configure?(): void;
   onCreate?(request: ZLinkMessage): Promise<ZLinkSpotCreateResponse>;
@@ -75,14 +74,12 @@ export interface ZLinkInstanceSpot {
   onClosing?(context: ZLinkSpotClosingContext, cleanupSignal: AbortSignal): Promise<void>;
 }
 
-export interface ZLinkEntrySpot<TActor extends ZLinkActor = ZLinkActor>
-  extends ZLinkSpotActorMembershipLifecycle<TActor> {
+export interface ZLinkEntrySpot<
+  TActor extends ZLinkActor = ZLinkActor
+> extends ZLinkSpotActorMembershipLifecycle<TActor> {
   readonly context: ZLinkEntrySpotContext<TActor>;
   configure?(): void;
   onInitialize?(): Promise<void>;
   onClosing?(context: ZLinkSpotClosingContext, cleanupSignal: AbortSignal): Promise<void>;
-  onCreateActor?(
-    actor: TActor,
-    createRequest: ZLinkMessage
-  ): Promise<ZLinkActorCreateResponse>;
+  onCreateActor?(actor: TActor, createRequest: ZLinkMessage): Promise<ZLinkActorCreateResponse>;
 }

package/src/contracts/Streams/IZLinkSession.ts

@@ -1,5 +1,5 @@
 import type { RoutingId, ZLinkMessage } from '../Common';
-import type { ZLinkSessionActors } from './IZLinkSessionActor';
+import type { ZLinkSessionActor, ZLinkSessionActors } from './IZLinkSessionActor';
 import type { ZLinkStreamError } from './ZLinkStreamError';
 import type { ZLinkSessionHandlerRegistry } from './IZLinkSessionPacketHandler';
 
@@ -16,9 +16,9 @@ export interface ZLinkSessionDispatchContext {
   readonly packetName: string;
   readonly metadata: ReadonlyMap<string, string>;
   readonly canReply: boolean;
+  readonly actor?: ZLinkSessionActor;
 }
 
-
 export interface ZLinkSessionFactory<TSession extends ZLinkSession = ZLinkSession> {
   create(context: ZLinkSessionContext): Promise<TSession>;
 }

package/src/contracts/Streams/IZLinkSessionActor.ts

@@ -12,6 +12,10 @@ export interface ZLinkSessionActor {
   readonly actorId: string;
   readonly ref: ActorRef;
   relay(payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
-  relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
+  relay(
+    dispatch: ZLinkSessionDispatchContext,
+    payload: ZLinkMessage,
+    signal?: AbortSignal
+  ): Promise<void>;
   notifyDisconnected(signal?: AbortSignal): Promise<void>;
 }

package/src/contracts/Streams/IZLinkSessionPacketHandler.ts

@@ -2,7 +2,11 @@ import type { Type, ZLinkMessage } from '../Common';
 import type { ZLinkSessionDispatchContext } from './IZLinkSession';
 
 export interface ZLinkSessionPacketHandler<TSessionContext, TMessage = ZLinkMessage> {
-  handle(context: TSessionContext, dispatch: ZLinkSessionDispatchContext, message: TMessage): Promise<void>;
+  handle(
+    context: TSessionContext,
+    dispatch: ZLinkSessionDispatchContext,
+    message: TMessage
+  ): Promise<void>;
 }
 
 export interface ZLinkSessionHandlerRegistry {

package/src/internal.ts

@@ -12,11 +12,12 @@ export * from './runtime/configuration';
 export * from './runtime/locations';
 export * from './runtime/locations/key-codec';
 export * from './runtime/locations/canonical-codec';
-export { ZLinkLocationAutoConnectType, ZLinkLocationKind, ZLinkRouteKind } from './contracts/Locations/Values';
 export {
-  ZLinkLocationWriteIntent,
-  ZLinkLocationWriteStatus
-} from './contracts/Locations/Writes';
+  ZLinkLocationAutoConnectType,
+  ZLinkLocationKind,
+  ZLinkRouteKind
+} from './contracts/Locations/Values';
+export { ZLinkLocationWriteIntent, ZLinkLocationWriteStatus } from './contracts/Locations/Writes';
 export * from './runtime/channels';
 export * from './runtime/backend';
 export * from './runtime/codecs';

package/src/location-store-integration.ts

@@ -14,38 +14,46 @@ export function matchesPeerLocation(
   row: ZLinkPeerLocation,
   filter: ZLinkPeerLocationFilter
 ): boolean {
-  return (filter.autoConnectType === undefined || row.autoConnectType === filter.autoConnectType)
-    && (filter.meshName === undefined || row.meshName === filter.meshName)
-    && (filter.role === undefined || row.role === filter.role)
-    && (filter.nodeRid === undefined || routingIdsEqual(row.nodeRid, filter.nodeRid))
-    && (filter.endpoint === undefined || row.endpoint === filter.endpoint);
+  return (
+    (filter.autoConnectType === undefined || row.autoConnectType === filter.autoConnectType) &&
+    (filter.meshName === undefined || row.meshName === filter.meshName) &&
+    (filter.role === undefined || row.role === filter.role) &&
+    (filter.nodeRid === undefined || routingIdsEqual(row.nodeRid, filter.nodeRid)) &&
+    (filter.endpoint === undefined || row.endpoint === filter.endpoint)
+  );
 }
 
 export function matchesSpotLocation(
   row: ZLinkSpotLocation,
   filter: ZLinkSpotLocationFilter
 ): boolean {
-  return (filter.meshName === undefined || row.meshName === filter.meshName)
-    && (filter.spotType === undefined || row.spotType === filter.spotType)
-    && (filter.nodeRid === undefined || routingIdsEqual(row.ownerNodeRid, filter.nodeRid))
-    && (filter.spotKind === undefined || row.spotKind === filter.spotKind);
+  return (
+    (filter.meshName === undefined || row.meshName === filter.meshName) &&
+    (filter.spotType === undefined || row.spotType === filter.spotType) &&
+    (filter.nodeRid === undefined || routingIdsEqual(row.ownerNodeRid, filter.nodeRid)) &&
+    (filter.spotKind === undefined || row.spotKind === filter.spotKind)
+  );
 }
 
 export function matchesActorLocation(
   row: ZLinkActorLocation,
   filter: ZLinkActorLocationFilter
 ): boolean {
-  return (filter.actorType === undefined || row.actorType === filter.actorType)
-    && (filter.nodeRid === undefined || routingIdsEqual(row.ownerNodeRid, filter.nodeRid))
-    && (filter.spotId === undefined || row.spotId === filter.spotId)
-    && (filter.locationKind === undefined || row.spotKind === filter.locationKind);
+  return (
+    (filter.actorType === undefined || row.actorType === filter.actorType) &&
+    (filter.nodeRid === undefined || routingIdsEqual(row.ownerNodeRid, filter.nodeRid)) &&
+    (filter.spotId === undefined || row.spotId === filter.spotId) &&
+    (filter.locationKind === undefined || row.spotKind === filter.locationKind)
+  );
 }
 
 export function matchesRouteLocation(
   row: ZLinkRouteLocation,
   filter: ZLinkRouteLocationFilter
 ): boolean {
-  return (filter.routeKind === undefined || row.routeKind === filter.routeKind)
-    && (filter.ownerNodeRid === undefined || routingIdsEqual(row.ownerNodeRid, filter.ownerNodeRid))
-    && (filter.ownerId === undefined || row.ownerId === filter.ownerId);
+  return (
+    (filter.routeKind === undefined || row.routeKind === filter.routeKind) &&
+    (filter.ownerNodeRid === undefined || routingIdsEqual(row.ownerNodeRid, filter.ownerNodeRid)) &&
+    (filter.ownerId === undefined || row.ownerId === filter.ownerId)
+  );
 }