@matter-server/dashboard 0.6.2 → 0.6.3

package/src/pages/network/network-utils.ts

@@ -4,15 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { MatterNode } from "@matter-server/ws-client";
+import type { BorderRouterEntry, MatterNode } from "@matter-server/ws-client";
 import { getCssVar } from "../../util/shared-styles.js";
 import type {
     CategorizedDevices,
     NetworkType,
+    SignalLevel,
     ThreadConnection,
+    ThreadEdgePair,
+    ThreadExternalDevice,
     ThreadNeighbor,
     ThreadRoute,
-    UnknownThreadDevice,
 } from "./network-types.js";
 
 // NetworkCommissioning cluster feature map bits (cluster 0x31/49)
@@ -388,25 +390,38 @@ export function buildRloc16Map(nodes: Record<string, MatterNode>): Map<number, s
     return rloc16Map;
 }
 
+interface ExternalAggregate {
+    extAddressHex: string;
+    extAddress: bigint;
+    seenBy: string[];
+    isRouter: boolean;
+    bestRssi: number | null;
+    /** xp of the first observing matter node; all neighbors of a Thread node share its xp. */
+    extendedPanIdHex?: string;
+}
+
 /**
- * Finds unknown Thread devices - addresses seen in neighbor tables
- * that don't match any known commissioned device.
- * These are typically Thread Border Routers or devices from other ecosystems.
- * Uses RLOC16 as fallback when extended address matching fails.
+ * Finds external Thread devices - addresses seen in neighbor tables that don't match
+ * any commissioned device. Classifies each against the optional Border Router registry:
+ * matched ones are emitted as kind:"br" with full mDNS enrichment; the rest stay as
+ * kind:"unknown". Uses RLOC16 as fallback when extended address matching fails.
  */
 export function findUnknownDevices(
     nodes: Record<string, MatterNode>,
     extAddrMap: Map<bigint, string>,
     rloc16Map: Map<number, string>,
-): UnknownThreadDevice[] {
-    const unknownMap = new Map<string, UnknownThreadDevice>();
+    borderRouters?: ReadonlyMap<string, BorderRouterEntry>,
+): ThreadExternalDevice[] {
+    const aggregates = new Map<string, ExternalAggregate>();
 
     for (const node of Object.values(nodes)) {
         const nodeId = String(node.node_id);
         const neighbors = parseNeighborTable(node);
+        const observerXp = getThreadExtendedPanId(node);
+        const observerXpHex =
+            observerXp !== undefined ? observerXp.toString(16).padStart(16, "0").toUpperCase() : undefined;
 
         for (const neighbor of neighbors) {
-            // Check if this neighbor is in our known devices (by extended address or RLOC16 fallback)
             if (extAddrMap.has(neighbor.extAddress)) {
                 continue;
             }
@@ -415,43 +430,180 @@ export function findUnknownDevices(
             }
 
             const extAddressHex = neighbor.extAddress.toString(16).padStart(16, "0").toUpperCase();
-            const id = `unknown_${extAddressHex}`;
 
-            if (!unknownMap.has(id)) {
-                unknownMap.set(id, {
-                    id,
+            let agg = aggregates.get(extAddressHex);
+            if (agg === undefined) {
+                agg = {
                     extAddressHex,
                     extAddress: neighbor.extAddress,
                     seenBy: [],
                     isRouter: false,
                     bestRssi: null,
-                });
+                    extendedPanIdHex: observerXpHex,
+                };
+                aggregates.set(extAddressHex, agg);
+            } else if (agg.extendedPanIdHex === undefined && observerXpHex !== undefined) {
+                agg.extendedPanIdHex = observerXpHex;
             }
 
-            const unknown = unknownMap.get(id)!;
-
-            // Add this node to seenBy if not already there
-            if (!unknown.seenBy.includes(nodeId)) {
-                unknown.seenBy.push(nodeId);
+            if (!agg.seenBy.includes(nodeId)) {
+                agg.seenBy.push(nodeId);
             }
-
-            // Update router status (field 10 = rxOnWhenIdle, indicates router-like behavior)
             if (neighbor.rxOnWhenIdle) {
-                unknown.isRouter = true;
+                agg.isRouter = true;
             }
-
-            // Track best signal
             const rssi = neighbor.avgRssi ?? neighbor.lastRssi;
-            if (rssi !== null && (unknown.bestRssi === null || rssi > unknown.bestRssi)) {
-                unknown.bestRssi = rssi;
+            if (rssi !== null && (agg.bestRssi === null || rssi > agg.bestRssi)) {
+                agg.bestRssi = rssi;
             }
         }
     }
 
-    return Array.from(unknownMap.values());
+    // Pre-compute xp → networkName from the BR registry so we can label unknowns by network.
+    const networkNameByXp = new Map<string, string>();
+    if (borderRouters !== undefined) {
+        for (const br of borderRouters.values()) {
+            if (br.extendedPanIdHex !== undefined && br.networkName !== undefined) {
+                networkNameByXp.set(br.extendedPanIdHex, br.networkName);
+            }
+        }
+    }
+
+    const out = new Array<ThreadExternalDevice>();
+    for (const agg of aggregates.values()) {
+        const br = borderRouters?.get(agg.extAddressHex);
+        if (br !== undefined) {
+            out.push({
+                kind: "br",
+                ...br,
+                id: `br_${agg.extAddressHex}`,
+                extAddressHex: agg.extAddressHex,
+                extAddress: agg.extAddress,
+                seenBy: agg.seenBy,
+                isRouter: agg.isRouter,
+                bestRssi: agg.bestRssi,
+            });
+        } else {
+            const networkName =
+                agg.extendedPanIdHex !== undefined ? networkNameByXp.get(agg.extendedPanIdHex) : undefined;
+            out.push({
+                kind: "unknown",
+                id: `unknown_${agg.extAddressHex}`,
+                extAddressHex: agg.extAddressHex,
+                extAddress: agg.extAddress,
+                seenBy: agg.seenBy,
+                isRouter: agg.isRouter,
+                bestRssi: agg.bestRssi,
+                extendedPanIdHex: agg.extendedPanIdHex,
+                networkName,
+            });
+        }
+    }
+    return out;
+}
+
+/**
+ * Decoded form of the MeshCoP `_meshcop` TXT `sb` (state bitmap) field. Layout per
+ * OpenThread's `border_agent_txt_data.hpp` (`openthread/openthread`, the de-facto reference
+ * implementation for Thread Border Router service publication):
+ *
+ *   bits 0-2   Connection Mode         (0=Disabled, 1=PSKc/DTLS, 2=PSKd/DTLS, 3=Vendor, 4=X.509)
+ *   bits 3-4   Thread Interface State  (0=NotInit, 1=Init/inactive, 2=Init/active)
+ *   bits 5-6   Availability            (0=Infrequent, 1=High)
+ *   bit  7     BBR Active              (0/1)
+ *   bit  8     BBR Is Primary          (0=secondary, 1=primary; only meaningful when BBR Active)
+ *   bits 9-10  Thread Role             (0=Detached, 1=Child, 2=Router, 3=Leader)
+ *   bit  11    ePSKc Supported         (0/1)
+ *   bits 12-13 Multi-AIL State         (0=Disabled, 1=Not detected, 2=Detected)
+ *   bits 14-31 Reserved
+ */
+export interface DecodedStateBitmap {
+    connectionMode?: string;
+    connectionModeValue: number;
+    threadInterfaceStatus?: string;
+    threadInterfaceStatusValue: number;
+    availability?: string;
+    availabilityValue: number;
+    bbr: boolean;
+    /** "primary" / "secondary" — only meaningful when {@link bbr} is true. */
+    bbrFunction?: string;
+    threadRole?: string;
+    threadRoleValue: number;
+    epskcSupported: boolean;
+    multiAilState?: string;
+    multiAilStateValue: number;
+    /** Hex of any bits beyond bit 13 (reserved/future). Undefined when zero. */
+    reservedHex?: string;
 }
 
-export type SignalLevel = "strong" | "medium" | "weak";
+const CONNECTION_MODE_LABELS: Record<number, string> = {
+    0: "disabled",
+    1: "PSKc / DTLS",
+    2: "PSKd / DTLS",
+    3: "vendor-defined",
+    4: "X.509",
+};
+
+const THREAD_INTERFACE_STATUS_LABELS: Record<number, string> = {
+    0: "not initialized",
+    1: "initialized, inactive",
+    2: "initialized, active",
+};
+
+const AVAILABILITY_LABELS: Record<number, string> = {
+    0: "infrequent",
+    1: "high",
+};
+
+const THREAD_ROLE_LABELS: Record<number, string> = {
+    0: "detached",
+    1: "child",
+    2: "router",
+    3: "leader",
+};
+
+const MULTI_AIL_STATE_LABELS: Record<number, string> = {
+    0: "disabled",
+    1: "not detected",
+    2: "detected",
+};
+
+/**
+ * Decodes a MeshCoP state bitmap hex string (e.g. "000005B1") per the OpenThread reference
+ * layout. Returns undefined if the input is not a valid hex value.
+ */
+export function decodeMeshcopStateBitmap(hex: string | undefined): DecodedStateBitmap | undefined {
+    if (hex === undefined || !/^[0-9a-fA-F]{1,8}$/.test(hex)) return undefined;
+    const value = parseInt(hex, 16);
+    if (!Number.isFinite(value)) return undefined;
+
+    const connectionModeValue = value & 0x7;
+    const threadInterfaceStatusValue = (value >> 3) & 0x3;
+    const availabilityValue = (value >> 5) & 0x3;
+    const bbr = ((value >> 7) & 0x1) === 1;
+    const bbrIsPrimary = ((value >> 8) & 0x1) === 1;
+    const threadRoleValue = (value >> 9) & 0x3;
+    const epskcSupported = ((value >> 11) & 0x1) === 1;
+    const multiAilStateValue = (value >> 12) & 0x3;
+    const reserved = (value >>> 14) >>> 0;
+
+    return {
+        connectionModeValue,
+        connectionMode: CONNECTION_MODE_LABELS[connectionModeValue],
+        threadInterfaceStatusValue,
+        threadInterfaceStatus: THREAD_INTERFACE_STATUS_LABELS[threadInterfaceStatusValue],
+        availabilityValue,
+        availability: AVAILABILITY_LABELS[availabilityValue],
+        bbr,
+        bbrFunction: bbr ? (bbrIsPrimary ? "primary" : "secondary") : undefined,
+        threadRoleValue,
+        threadRole: THREAD_ROLE_LABELS[threadRoleValue],
+        epskcSupported,
+        multiAilStateValue,
+        multiAilState: MULTI_AIL_STATE_LABELS[multiAilStateValue],
+        reservedHex: reserved !== 0 ? reserved.toString(16).toUpperCase() : undefined,
+    };
+}
 
 /** Determine signal level from a Thread neighbor's RSSI/LQI. */
 export function getSignalLevel(neighbor: ThreadNeighbor): SignalLevel {
@@ -461,8 +613,13 @@ export function getSignalLevel(neighbor: ThreadNeighbor): SignalLevel {
         if (rssi > SIGNAL_MEDIUM_THRESHOLD) return "medium";
         return "weak";
     }
-    if (neighbor.lqi > LQI_STRONG_THRESHOLD) return "strong";
-    if (neighbor.lqi > LQI_MEDIUM_THRESHOLD) return "medium";
+    return getSignalLevelFromLqi(neighbor.lqi);
+}
+
+/** Determine signal level from an LQI value alone (e.g. route table entries without RSSI). */
+export function getSignalLevelFromLqi(lqi: number): SignalLevel {
+    if (lqi > LQI_STRONG_THRESHOLD) return "strong";
+    if (lqi > LQI_MEDIUM_THRESHOLD) return "medium";
     return "weak";
 }
 
@@ -669,20 +826,73 @@ export function getWiFiVersionName(version: number | null): string {
 }
 
 /**
- * Builds Thread mesh connections from neighbor tables.
- * Returns connections with signal information.
- * Includes connections to unknown devices (prefixed with 'unknown_').
+ * Represents a connection from the perspective of a specific node.
+ * Includes both neighbors this node reports AND nodes that report this node as their neighbor.
+ */
+export interface NodeConnection {
+    /** The connected node ID (number for known nodes, string for unknown devices) */
+    connectedNodeId: number | string;
+    /** The connected MatterNode if it's a known device */
+    connectedNode?: MatterNode;
+    /** Extended address hex string for display */
+    extAddressHex: string;
+    /** Signal strength info (if available) */
+    signalColor: string;
+    /** Undefined when link strength is unknown. */
+    signalLevel?: SignalLevel;
+    lqi: number | null;
+    rssi: number | null;
+    /** Whether this connection is from THIS node's neighbor table (true) or from the OTHER node's table (false) */
+    isOutgoing: boolean;
+    /** True when only the peer reports this edge — this node has no matching neighbor-table entry. Surfaces true asymmetric visibility, distinct from a reverse view caused by filtering. */
+    isReverseOnly: boolean;
+    /** Whether this is an unknown/external device */
+    isUnknown: boolean;
+    /** Path cost from route table (1 = direct, higher = multi-hop). Only available for routers. */
+    pathCost?: number;
+    /** Bidirectional LQI from route table (average of lqiIn and lqiOut) */
+    bidirectionalLqi?: number;
+}
+
+/**
+ * Creates a canonical pair key from two node IDs.
+ * The key is always ordered so that the same pair produces the same key regardless of direction.
  */
-export function buildThreadConnections(
+export function makePairKey(a: string, b: string): string {
+    return a < b ? `${a}|${b}` : `${b}|${a}`;
+}
+
+/**
+ * Computes a numeric signal score for edge comparison.
+ * Lower score = weaker signal (worst case).
+ */
+export function getEdgeSignalScore(conn: ThreadConnection): number {
+    const levelScore =
+        conn.signalLevel === "strong"
+            ? 3000
+            : conn.signalLevel === "medium"
+              ? 2000
+              : conn.signalLevel === "weak"
+                ? 1000
+                : 0;
+    const detail = conn.rssi !== null ? conn.rssi + 200 : conn.lqi;
+    return levelScore + detail;
+}
+
+/**
+ * Builds edge pairs for all Thread connections.
+ * Each pair represents two connected nodes with up to 2 directional edges
+ * (one from each node's neighbor/route table). No dedup is performed —
+ * callers are responsible for selecting which edge to display per pair.
+ */
+export function buildThreadEdgePairs(
     nodes: Record<string, MatterNode>,
     extAddrMap: Map<bigint, string>,
     rloc16Map: Map<number, string>,
-    unknownDevices: UnknownThreadDevice[],
-): ThreadConnection[] {
-    const connections: ThreadConnection[] = [];
-    const seenConnections = new Set<string>();
+    unknownDevices: ThreadExternalDevice[],
+): Map<string, ThreadEdgePair> {
+    const pairs = new Map<string, ThreadEdgePair>();
 
-    // Build map of unknown device extAddress -> id
     const unknownExtAddrMap = new Map<bigint, string>();
     for (const unknown of unknownDevices) {
         unknownExtAddrMap.set(unknown.extAddress, unknown.id);
@@ -693,55 +903,50 @@ export function buildThreadConnections(
         const neighbors = parseNeighborTable(node);
 
         for (const neighbor of neighbors) {
-            // Try to find in known devices first (extAddress, then RLOC16 fallback)
             let toNodeId: string | undefined = extAddrMap.get(neighbor.extAddress);
             if (toNodeId === undefined && neighbor.rloc16 !== 0) {
                 toNodeId = rloc16Map.get(neighbor.rloc16);
             }
-
-            // If not found, check unknown devices
             if (toNodeId === undefined) {
                 toNodeId = unknownExtAddrMap.get(neighbor.extAddress);
             }
+            if (toNodeId === undefined || fromNodeId === toNodeId) continue;
 
-            if (toNodeId === undefined) {
-                // Should not happen if unknownDevices was built correctly
-                continue;
+            const pairKey = makePairKey(fromNodeId, toNodeId);
+            if (!pairs.has(pairKey)) {
+                const [nodeA, nodeB] = fromNodeId < toNodeId ? [fromNodeId, toNodeId] : [toNodeId, fromNodeId];
+                pairs.set(pairKey, { pairKey, nodeA, nodeB });
             }
 
-            // Skip self-connections
-            if (fromNodeId === toNodeId) {
-                continue;
-            }
+            const pair = pairs.get(pairKey)!;
+            const isFromA = fromNodeId === pair.nodeA;
 
-            // Create a unique key for this connection
-            const connectionKey = `${fromNodeId}-${toNodeId}`;
-            const reverseKey = `${toNodeId}-${fromNodeId}`;
+            // Neighbor table entry takes precedence — skip if already present for this direction
+            if (isFromA && pair.edgeAB) continue;
+            if (!isFromA && pair.edgeBA) continue;
 
-            if (seenConnections.has(connectionKey) || seenConnections.has(reverseKey)) {
-                // Already have this connection
-                continue;
-            }
-            seenConnections.add(connectionKey);
-
-            // Look up route table entry for supplementary data (pathCost, bidirectional LQI)
             const routeEntry = findRouteByExtAddress(node, neighbor.extAddress);
             const bidirectionalLqi = routeEntry ? getRouteBidirectionalLqi(routeEntry) : undefined;
 
-            // Always use neighbor table RSSI/LQI for signal color (most accurate link quality)
-            connections.push({
+            const edge: ThreadConnection = {
                 fromNodeId,
                 toNodeId,
                 signalColor: getSignalColor(neighbor),
+                signalLevel: getSignalLevel(neighbor),
                 lqi: neighbor.lqi,
                 rssi: neighbor.avgRssi ?? neighbor.lastRssi,
                 pathCost: routeEntry?.pathCost,
                 bidirectionalLqi,
-            });
+            };
+
+            if (isFromA) {
+                pair.edgeAB = edge;
+            } else {
+                pair.edgeBA = edge;
+            }
         }
 
-        // Check route table for connections not in neighbor table (supplementary data)
-        // This helps when neighbor table is stale or incomplete
+        // Supplementary: route table entries not already covered by neighbor table
         const routes = parseRouteTable(node);
         for (const route of routes) {
             if (!route.linkEstablished || !route.allocated) continue;
@@ -755,156 +960,170 @@ export function buildThreadConnections(
             }
             if (toNodeId === undefined || toNodeId === fromNodeId) continue;
 
-            const connectionKey = `${fromNodeId}-${toNodeId}`;
-            const reverseKey = `${toNodeId}-${fromNodeId}`;
-
-            // Only add if we don't already have this connection from neighbor table
-            if (seenConnections.has(connectionKey) || seenConnections.has(reverseKey)) {
-                continue;
+            const pairKey = makePairKey(fromNodeId, toNodeId);
+            if (!pairs.has(pairKey)) {
+                const [nodeA, nodeB] = fromNodeId < toNodeId ? [fromNodeId, toNodeId] : [toNodeId, fromNodeId];
+                pairs.set(pairKey, { pairKey, nodeA, nodeB });
             }
-            seenConnections.add(connectionKey);
+
+            const pair = pairs.get(pairKey)!;
+            const isFromA = fromNodeId === pair.nodeA;
+
+            // Only add from route table if no neighbor table edge for this direction
+            if (isFromA && pair.edgeAB) continue;
+            if (!isFromA && pair.edgeBA) continue;
 
             const bidirectionalLqi = getRouteBidirectionalLqi(route);
             const signalColor =
                 bidirectionalLqi !== undefined
                     ? getSignalColorFromLqi(bidirectionalLqi)
-                    : "var(--md-sys-color-outline, grey)"; // Unknown signal
+                    : "var(--md-sys-color-outline, grey)";
 
-            connections.push({
+            const edge: ThreadConnection = {
                 fromNodeId,
                 toNodeId,
                 signalColor,
+                signalLevel: bidirectionalLqi !== undefined ? getSignalLevelFromLqi(bidirectionalLqi) : undefined,
                 lqi: bidirectionalLqi ?? 0,
                 rssi: null,
                 pathCost: route.pathCost,
                 bidirectionalLqi,
                 fromRouteTable: true,
-            });
+            };
+
+            if (isFromA) {
+                pair.edgeAB = edge;
+            } else {
+                pair.edgeBA = edge;
+            }
         }
     }
 
-    return connections;
+    return pairs;
 }
 
 /**
- * Represents a connection from the perspective of a specific node.
- * Includes both neighbors this node reports AND nodes that report this node as their neighbor.
+ * Filter options for edge visibility, matching the graph's filter pipeline.
  */
-export interface NodeConnection {
-    /** The connected node ID (number for known nodes, string for unknown devices) */
-    connectedNodeId: number | string;
-    /** The connected MatterNode if it's a known device */
-    connectedNode?: MatterNode;
-    /** Extended address hex string for display */
-    extAddressHex: string;
-    /** Signal strength info (if available) */
-    signalColor: string;
-    lqi: number | null;
-    rssi: number | null;
-    /** Whether this connection is from THIS node's neighbor table (true) or from the OTHER node's table (false) */
-    isOutgoing: boolean;
-    /** Whether this is an unknown/external device */
-    isUnknown: boolean;
-    /** Path cost from route table (1 = direct, higher = multi-hop). Only available for routers. */
-    pathCost?: number;
-    /** Bidirectional LQI from route table (average of lqiIn and lqiOut) */
-    bidirectionalLqi?: number;
+export interface EdgeFilterOptions {
+    hideOfflineNodes?: boolean;
+    hideWeakSignalEdges?: boolean;
+    hideMediumSignalEdges?: boolean;
+    hideStrongSignalEdges?: boolean;
 }
 
 /**
- * Get all connections for a specific node (bidirectional).
- * This includes:
- * 1. Neighbors this node reports in its neighbor table (outgoing)
- * 2. Nodes that report this node as their neighbor (incoming)
+ * Derives NodeConnection[] from pre-computed edge pairs for a given node.
+ * Uses the same edge pairs as the graph, ensuring the side panel and the
+ * graph always agree on which connections exist.
+ *
+ * The function mirrors the graph's exact pipeline:
+ *   1. Filter each edge independently (offline cascade + signal level)
+ *   2. Among survivors per pair, prefer the outgoing edge (matches graph
+ *      highlight swap); fall back to worst signal (matches graph dedup)
  *
- * Returns a deduplicated list - if both directions exist, only the outgoing one is included
- * (since that has signal data from THIS node's perspective).
+ * When filters are omitted, no filtering is applied and the outgoing
+ * edge is preferred (useful for the "update connections" dialog).
  *
- * @param nodeId - Node ID as string to avoid BigInt precision loss
+ * One entry per connected peer (no duplicates).
  */
-export function getNodeConnections(
+export function getNodeConnectionsFromPairs(
     nodeId: string,
+    edgePairs: Map<string, ThreadEdgePair>,
     nodes: Record<string, MatterNode>,
-    extAddrMap: Map<bigint, string>,
-    rloc16Map?: Map<number, string>,
+    filters?: EdgeFilterOptions,
 ): NodeConnection[] {
     const connections: NodeConnection[] = [];
-    const seenConnectedIds = new Set<string>();
 
-    const node = nodes[nodeId];
-    if (!node) return connections;
+    // Build set of hidden node IDs (offline cascade, same as graph)
+    const hiddenNodeIds = new Set<string>();
+    if (filters?.hideOfflineNodes) {
+        for (const node of Object.values(nodes)) {
+            if (node.available === false) {
+                hiddenNodeIds.add(String(node.node_id));
+            }
+        }
+    }
+
+    for (const pair of edgePairs.values()) {
+        const isA = pair.nodeA === nodeId;
+        const isB = pair.nodeB === nodeId;
+        if (!isA && !isB) continue;
+
+        const remoteId = isA ? pair.nodeB : pair.nodeA;
+        const outgoing = isA ? pair.edgeAB : pair.edgeBA;
+        const incoming = isA ? pair.edgeBA : pair.edgeAB;
+
+        // Apply filters to each edge independently (mirrors graph pipeline)
+        const survivors: { conn: ThreadConnection; isOutgoing: boolean }[] = [];
+
+        for (const [conn, isOut] of [
+            [outgoing, true],
+            [incoming, false],
+        ] as const) {
+            if (!conn) continue;
+
+            if (filters) {
+                const fromId = String(conn.fromNodeId);
+                const toId = String(conn.toNodeId);
+
+                // Offline cascade: skip if either endpoint is hidden
+                if (hiddenNodeIds.has(fromId) || hiddenNodeIds.has(toId)) continue;
 
-    // Get this node's extended address for reverse lookups (from General Diagnostics, not Thread Diagnostics)
-    const thisExtAddr = getThreadExtendedAddress(node);
+                // Signal level filters
+                if (filters.hideWeakSignalEdges && conn.signalLevel === "weak") continue;
+                if (filters.hideMediumSignalEdges && conn.signalLevel === "medium") continue;
+                if (filters.hideStrongSignalEdges && conn.signalLevel === "strong") continue;
+            }
 
-    // 1. Add neighbors this node reports (outgoing connections)
-    const neighbors = parseNeighborTable(node);
-    for (const neighbor of neighbors) {
-        let connectedNodeId = extAddrMap.get(neighbor.extAddress);
-        if (connectedNodeId === undefined && rloc16Map && neighbor.rloc16 !== 0) {
-            connectedNodeId = rloc16Map.get(neighbor.rloc16);
+            survivors.push({ conn, isOutgoing: isOut });
         }
-        const connectedNode = connectedNodeId ? nodes[connectedNodeId] : undefined;
-        const isUnknown = connectedNodeId === undefined;
-        const displayId: string =
-            connectedNodeId ?? `unknown_${neighbor.extAddress.toString(16).toUpperCase().padStart(16, "0")}`;
 
-        seenConnectedIds.add(displayId);
+        if (survivors.length === 0) continue;
+
+        // Among survivors: prefer outgoing (matches graph highlight swap),
+        // fall back to worst signal (matches graph dedup)
+        let winner: { conn: ThreadConnection; isOutgoing: boolean };
+        const outgoingSurvivor = survivors.find(s => s.isOutgoing);
+        if (outgoingSurvivor) {
+            winner = outgoingSurvivor;
+        } else {
+            survivors.sort((a, b) => getEdgeSignalScore(a.conn) - getEdgeSignalScore(b.conn));
+            winner = survivors[0];
+        }
 
-        // Look up route table entry for enhanced data
-        const routeEntry = findRouteByExtAddress(node, neighbor.extAddress);
-        const bidirectionalLqi = routeEntry ? getRouteBidirectionalLqi(routeEntry) : undefined;
+        const remoteNode = nodes[remoteId];
+        const isExternalUnknown = remoteId.startsWith("unknown_");
+        const isExternalBr = remoteId.startsWith("br_");
+        const isUnknown = isExternalUnknown || isExternalBr;
+
+        // Derive extended address hex for display
+        let extAddressHex: string;
+        if (isExternalUnknown) {
+            extAddressHex = remoteId.slice("unknown_".length);
+        } else if (isExternalBr) {
+            extAddressHex = remoteId.slice("br_".length);
+        } else if (remoteNode) {
+            extAddressHex = getThreadExtendedAddressHex(remoteNode) ?? "Unknown";
+        } else {
+            extAddressHex = "Unknown";
+        }
 
         connections.push({
-            connectedNodeId: displayId,
-            connectedNode,
-            extAddressHex: neighbor.extAddress.toString(16).toUpperCase().padStart(16, "0"),
-            signalColor: getSignalColor(neighbor),
-            lqi: neighbor.lqi,
-            rssi: neighbor.avgRssi ?? neighbor.lastRssi,
-            isOutgoing: true,
+            connectedNodeId: remoteId,
+            connectedNode: remoteNode,
+            extAddressHex,
+            signalColor: winner.conn.signalColor,
+            signalLevel: winner.conn.signalLevel,
+            lqi: winner.conn.lqi,
+            rssi: winner.conn.rssi,
+            isOutgoing: winner.isOutgoing,
+            isReverseOnly: !outgoing,
             isUnknown,
-            pathCost: routeEntry?.pathCost,
-            bidirectionalLqi,
+            pathCost: winner.conn.pathCost,
+            bidirectionalLqi: winner.conn.bidirectionalLqi,
         });
     }
 
-    // 2. Find nodes that report THIS node as their neighbor (incoming connections)
-    if (thisExtAddr !== undefined) {
-        for (const otherNode of Object.values(nodes)) {
-            const otherNodeId = String(otherNode.node_id);
-            if (otherNodeId === nodeId) continue; // Skip self
-
-            // Check if already connected via outgoing
-            if (seenConnectedIds.has(otherNodeId)) continue;
-
-            // Check if other node reports this node as neighbor
-            const otherNeighbors = parseNeighborTable(otherNode);
-            const reverseEntry = otherNeighbors.find(n => n.extAddress === thisExtAddr);
-
-            if (reverseEntry) {
-                const otherExtAddr = getThreadExtendedAddress(otherNode);
-                const extAddrHex = otherExtAddr ? otherExtAddr.toString(16).toUpperCase().padStart(16, "0") : "Unknown";
-
-                // Look up route table entry from the other node's perspective
-                const routeEntry = findRouteByExtAddress(otherNode, thisExtAddr);
-                const bidirectionalLqi = routeEntry ? getRouteBidirectionalLqi(routeEntry) : undefined;
-
-                connections.push({
-                    connectedNodeId: otherNodeId,
-                    connectedNode: otherNode,
-                    extAddressHex: extAddrHex,
-                    signalColor: getSignalColor(reverseEntry),
-                    lqi: reverseEntry.lqi,
-                    rssi: reverseEntry.avgRssi ?? reverseEntry.lastRssi,
-                    isOutgoing: false,
-                    isUnknown: false,
-                    pathCost: routeEntry?.pathCost,
-                    bidirectionalLqi,
-                });
-            }
-        }
-    }
-
     return connections;
 }