fix: customizer v2 type colors default to black (#514)

- Server: add default typeColors in handleConfigTheme matching roles.js
- Client: fall back to window.TYPE_COLORS before #000000 in _renderNodes
- Tests: verify typeColors defaults in theme API and frontend fallback

cmd/server/config.go

@@ -55,8 +55,6 @@ type Config struct {
 	GeoFilter *GeoFilterConfig `json:"geo_filter,omitempty"`
 
 	Timestamps *TimestampConfig `json:"timestamps,omitempty"`
-
-	DebugAffinity bool `json:"debugAffinity,omitempty"`
 }
 
 // PacketStoreConfig controls in-memory packet store limits.

cmd/server/neighbor_api.go

@@ -80,8 +80,7 @@ func (s *Server) getNeighborGraph() *NeighborGraph {
 
 	if s.neighborGraph == nil || s.neighborGraph.IsStale() {
 		if s.store != nil {
-			debugLog := s.cfg != nil && s.cfg.DebugAffinity
-			s.neighborGraph = BuildFromStoreWithLog(s.store, debugLog)
+			s.neighborGraph = BuildFromStore(s.store)
 		} else {
 			s.neighborGraph = NewNeighborGraph()
 		}

cmd/server/neighbor_debug.go

@@ -1,399 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"math"
-	"net/http"
-	"sort"
-	"strings"
-	"time"
-)
-
-// ─── Debug API response types ──────────────────────────────────────────────────
-
-type DebugAffinityResponse struct {
-	Edges       []DebugEdge       `json:"edges"`
-	Resolutions []DebugResolution `json:"resolutions"`
-	Stats       DebugStats        `json:"stats"`
-}
-
-type DebugEdge struct {
-	NodeA            string   `json:"nodeA"`
-	NodeAName        string   `json:"nodeAName,omitempty"`
-	NodeB            string   `json:"nodeB"`
-	NodeBName        string   `json:"nodeBName,omitempty"`
-	Prefix           string   `json:"prefix"`
-	Weight           int      `json:"weight"`
-	ObservationCount int      `json:"observationCount"`
-	LastSeen         string   `json:"lastSeen"`
-	FirstSeen        string   `json:"firstSeen"`
-	Score            float64  `json:"score"`
-	Jaccard          float64  `json:"jaccard,omitempty"`
-	AvgSNR           *float64 `json:"avgSnr,omitempty"`
-	Observers        []string `json:"observers"`
-	Ambiguous        bool     `json:"ambiguous"`
-	Unresolved       bool     `json:"unresolved,omitempty"`
-	Resolved         bool     `json:"resolved,omitempty"`
-}
-
-type DebugResolution struct {
-	Prefix           string             `json:"prefix"`
-	Chosen           string             `json:"chosen,omitempty"`
-	ChosenName       string             `json:"chosenName,omitempty"`
-	ChosenScore      int                `json:"chosenScore"`
-	ChosenJaccard    float64            `json:"chosenJaccard"`
-	Confidence       string             `json:"confidence"`
-	Candidates       []DebugCandidate   `json:"candidates"`
-	Ratio            float64            `json:"ratio"`
-	ThresholdApplied float64            `json:"thresholdApplied"`
-	Method           string             `json:"method"`
-	Tier             string             `json:"tier"`
-	KnownNode        string             `json:"knownNode"`
-	KnownNodeName    string             `json:"knownNodeName,omitempty"`
-}
-
-type DebugCandidate struct {
-	Pubkey  string  `json:"pubkey"`
-	Name    string  `json:"name,omitempty"`
-	Score   int     `json:"score"`
-	Jaccard float64 `json:"jaccard"`
-}
-
-type DebugStats struct {
-	TotalEdges       int     `json:"totalEdges"`
-	TotalNodes       int     `json:"totalNodes"`
-	ResolvedCount    int     `json:"resolvedCount"`
-	AmbiguousCount   int     `json:"ambiguousCount"`
-	UnresolvedCount  int     `json:"unresolvedCount"`
-	AvgConfidence    float64 `json:"avgConfidence"`
-	ColdStartCoverage float64 `json:"coldStartCoverage"`
-	CacheAge         string  `json:"cacheAge"`
-	LastRebuild      string  `json:"lastRebuild"`
-}
-
-// ─── Debug API Handler ─────────────────────────────────────────────────────────
-
-func (s *Server) handleDebugAffinity(w http.ResponseWriter, r *http.Request) {
-	prefixFilter := strings.ToLower(r.URL.Query().Get("prefix"))
-	nodeFilter := strings.ToLower(r.URL.Query().Get("node"))
-
-	graph := s.getNeighborGraph()
-	now := time.Now()
-	nodeMap := s.buildNodeInfoMap()
-
-	allEdges := graph.AllEdges()
-
-	// Build edges response
-	var debugEdges []DebugEdge
-	nodeSet := make(map[string]bool)
-	resolvedCount := 0
-	ambiguousCount := 0
-	unresolvedCount := 0
-	var scoreSum float64
-	var scoreCount int
-
-	for _, e := range allEdges {
-		// Apply filters
-		if prefixFilter != "" && !strings.EqualFold(e.Prefix, prefixFilter) {
-			continue
-		}
-		if nodeFilter != "" {
-			if !strings.EqualFold(e.NodeA, nodeFilter) && !strings.EqualFold(e.NodeB, nodeFilter) {
-				// Also check if any candidate matches
-				found := false
-				for _, c := range e.Candidates {
-					if strings.EqualFold(c, nodeFilter) {
-						found = true
-						break
-					}
-				}
-				if !found {
-					continue
-				}
-			}
-		}
-
-		score := e.Score(now)
-		de := DebugEdge{
-			NodeA:            e.NodeA,
-			NodeB:            e.NodeB,
-			Prefix:           e.Prefix,
-			Weight:           e.Count,
-			ObservationCount: e.Count,
-			LastSeen:         e.LastSeen.UTC().Format(time.RFC3339),
-			FirstSeen:        e.FirstSeen.UTC().Format(time.RFC3339),
-			Score:            math.Round(score*1000) / 1000,
-			Observers:        observerList(e.Observers),
-			Ambiguous:        e.Ambiguous,
-			Resolved:         e.Resolved,
-		}
-
-		if e.SNRCount > 0 {
-			avg := e.AvgSNR()
-			de.AvgSNR = &avg
-		}
-
-		// Add names
-		if nodeMap != nil {
-			if info, ok := nodeMap[strings.ToLower(e.NodeA)]; ok {
-				de.NodeAName = info.Name
-			}
-			if info, ok := nodeMap[strings.ToLower(e.NodeB)]; ok {
-				de.NodeBName = info.Name
-			}
-		}
-
-		if e.Ambiguous {
-			if len(e.Candidates) == 0 {
-				de.Unresolved = true
-				unresolvedCount++
-			} else {
-				ambiguousCount++
-			}
-		} else {
-			resolvedCount++
-			scoreSum += score
-			scoreCount++
-		}
-
-		debugEdges = append(debugEdges, de)
-
-		if e.NodeA != "" && !strings.HasPrefix(e.NodeA, "prefix:") {
-			nodeSet[e.NodeA] = true
-		}
-		if e.NodeB != "" && !strings.HasPrefix(e.NodeB, "prefix:") {
-			nodeSet[e.NodeB] = true
-		}
-	}
-
-	// Build resolutions from the graph's disambiguation history
-	resolutions := s.buildResolutions(graph, nodeMap, prefixFilter, nodeFilter)
-
-	// Cold-start coverage: % of 1-byte prefixes with ≥3 observations
-	coldStart := s.computeColdStartCoverage(allEdges)
-
-	avgConf := 0.0
-	if scoreCount > 0 {
-		avgConf = math.Round(scoreSum/float64(scoreCount)*1000) / 1000
-	}
-
-	if debugEdges == nil {
-		debugEdges = []DebugEdge{}
-	}
-	if resolutions == nil {
-		resolutions = []DebugResolution{}
-	}
-
-	// Sort edges by weight descending
-	sort.Slice(debugEdges, func(i, j int) bool {
-		return debugEdges[i].Weight > debugEdges[j].Weight
-	})
-
-	graph.mu.RLock()
-	builtAt := graph.builtAt
-	graph.mu.RUnlock()
-
-	cacheAge := ""
-	lastRebuild := ""
-	if !builtAt.IsZero() {
-		cacheAge = fmt.Sprintf("%.1fs", time.Since(builtAt).Seconds())
-		lastRebuild = builtAt.UTC().Format(time.RFC3339)
-	}
-
-	resp := DebugAffinityResponse{
-		Edges:       debugEdges,
-		Resolutions: resolutions,
-		Stats: DebugStats{
-			TotalEdges:        len(debugEdges),
-			TotalNodes:        len(nodeSet),
-			ResolvedCount:     resolvedCount,
-			AmbiguousCount:    ambiguousCount,
-			UnresolvedCount:   unresolvedCount,
-			AvgConfidence:     avgConf,
-			ColdStartCoverage: coldStart,
-			CacheAge:          cacheAge,
-			LastRebuild:       lastRebuild,
-		},
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(resp)
-}
-
-// buildResolutions generates per-prefix resolution decision logs.
-// It uses resolveWithContext (M4) to show the actual 4-tier fallback path
-// (affinity → geo → GPS → first_match) for each prefix resolution.
-func (s *Server) buildResolutions(graph *NeighborGraph, nodeMap map[string]nodeInfo, prefixFilter, nodeFilter string) []DebugResolution {
-	graph.mu.RLock()
-	defer graph.mu.RUnlock()
-
-	// Get the prefix map for resolveWithContext tier computation.
-	var pm *prefixMap
-	if s.store != nil {
-		_, pm = s.store.getCachedNodesAndPM()
-	}
-
-	// Build resolved neighbor sets for Jaccard computation
-	resolvedNeighbors := make(map[string]map[string]bool)
-	for _, e := range graph.edges {
-		if e.Ambiguous || e.NodeB == "" {
-			continue
-		}
-		if resolvedNeighbors[e.NodeA] == nil {
-			resolvedNeighbors[e.NodeA] = make(map[string]bool)
-		}
-		if resolvedNeighbors[e.NodeB] == nil {
-			resolvedNeighbors[e.NodeB] = make(map[string]bool)
-		}
-		resolvedNeighbors[e.NodeA][e.NodeB] = true
-		resolvedNeighbors[e.NodeB][e.NodeA] = true
-	}
-
-	var resolutions []DebugResolution
-
-	for _, e := range graph.edges {
-		// Show resolution info for both resolved (auto-resolved) and ambiguous edges
-		if !e.Resolved && !e.Ambiguous {
-			continue
-		}
-		if len(e.Candidates) < 2 && !e.Resolved {
-			continue
-		}
-
-		if prefixFilter != "" && !strings.EqualFold(e.Prefix, prefixFilter) {
-			continue
-		}
-
-		knownNode := e.NodeA
-		if strings.HasPrefix(e.NodeA, "prefix:") {
-			knownNode = e.NodeB
-		}
-
-		if nodeFilter != "" && !strings.EqualFold(knownNode, nodeFilter) {
-			// Check if the resolved node matches
-			if e.Resolved && !strings.EqualFold(e.NodeB, nodeFilter) && !strings.EqualFold(e.NodeA, nodeFilter) {
-				continue
-			}
-		}
-
-		knownNeighbors := resolvedNeighbors[knownNode]
-
-		var candidates []DebugCandidate
-		candList := e.Candidates
-		// For resolved edges, add the resolved node as a candidate too
-		if e.Resolved {
-			resolvedPK := e.NodeB
-			if strings.EqualFold(e.NodeB, knownNode) {
-				resolvedPK = e.NodeA
-			}
-			// Include resolved + original candidates
-			found := false
-			for _, c := range candList {
-				if strings.EqualFold(c, resolvedPK) {
-					found = true
-					break
-				}
-			}
-			if !found {
-				candList = append([]string{resolvedPK}, candList...)
-			}
-		}
-
-		for _, cpk := range candList {
-			candNeighbors := resolvedNeighbors[cpk]
-			j := jaccardSimilarity(knownNeighbors, candNeighbors)
-			dc := DebugCandidate{
-				Pubkey:  cpk,
-				Score:   e.Count,
-				Jaccard: math.Round(j*1000) / 1000,
-			}
-			if nodeMap != nil {
-				if info, ok := nodeMap[strings.ToLower(cpk)]; ok {
-					dc.Name = info.Name
-				}
-			}
-			candidates = append(candidates, dc)
-		}
-
-		// Sort candidates by Jaccard descending
-		sort.Slice(candidates, func(i, j int) bool {
-			return candidates[i].Jaccard > candidates[j].Jaccard
-		})
-
-		dr := DebugResolution{
-			Prefix:           e.Prefix,
-			ThresholdApplied: affinityConfidenceRatio,
-			KnownNode:        knownNode,
-		}
-
-		if nodeMap != nil {
-			if info, ok := nodeMap[strings.ToLower(knownNode)]; ok {
-				dr.KnownNodeName = info.Name
-			}
-		}
-
-		// Use resolveWithContext to determine the actual 4-tier fallback path.
-		tier := ""
-		if pm != nil {
-			contextPubkeys := []string{knownNode}
-			_, tierUsed, _ := pm.resolveWithContext(e.Prefix, contextPubkeys, graph)
-			tier = tierUsed
-		}
-
-		if e.Resolved && len(candidates) > 0 {
-			dr.Chosen = candidates[0].Pubkey
-			dr.ChosenName = candidates[0].Name
-			dr.ChosenScore = candidates[0].Score
-			dr.ChosenJaccard = candidates[0].Jaccard
-			dr.Confidence = "HIGH"
-			dr.Method = "auto-resolved"
-			dr.Tier = tier
-			if len(candidates) > 1 && candidates[1].Jaccard > 0 {
-				dr.Ratio = math.Round(candidates[0].Jaccard/candidates[1].Jaccard*10) / 10
-			} else if candidates[0].Jaccard > 0 {
-				dr.Ratio = 999.0 // effectively infinite — JSON doesn't support Infinity
-			}
-		} else {
-			dr.Confidence = "AMBIGUOUS"
-			dr.Method = "ambiguous"
-			dr.Tier = tier
-			if len(candidates) >= 2 {
-				dr.ChosenScore = candidates[0].Score
-				dr.ChosenJaccard = candidates[0].Jaccard
-				if candidates[1].Jaccard > 0 {
-					dr.Ratio = math.Round(candidates[0].Jaccard/candidates[1].Jaccard*10) / 10
-				}
-			}
-		}
-		dr.Candidates = candidates
-
-		resolutions = append(resolutions, dr)
-	}
-
-	return resolutions
-}
-
-// computeColdStartCoverage returns the % of active 1-byte hex prefixes with ≥3 observations.
-func (s *Server) computeColdStartCoverage(edges []*NeighborEdge) float64 {
-	// Track which 1-byte prefixes have sufficient observations
-	prefixObs := make(map[string]int) // 1-byte prefix → total observations
-	for _, e := range edges {
-		if len(e.Prefix) == 2 { // 1-byte = 2 hex chars
-			prefixObs[strings.ToLower(e.Prefix)] += e.Count
-		}
-	}
-
-	if len(prefixObs) == 0 {
-		return 0
-	}
-
-	covered := 0
-	for _, count := range prefixObs {
-		if count >= affinityMinObservations {
-			covered++
-		}
-	}
-
-	return math.Round(float64(covered)/float64(len(prefixObs))*1000) / 10
-}

cmd/server/neighbor_debug_test.go

@@ -1,223 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestDebugAffinityEndpoint(t *testing.T) {
-	now := time.Now()
-
-	edge1 := newEdge("aaaa1111", "bbbb2222", "bb", 50, now)
-	edge2 := newEdge("aaaa1111", "", "cc", 10, now)
-	edge2.Ambiguous = true
-	edge2.Candidates = []string{"cccc3333", "cccc4444"}
-
-	graph := makeTestGraph(edge1, edge2)
-	srv := makeTestServer(graph)
-	srv.cfg = &Config{APIKey: "test-key", DebugAffinity: true}
-
-	r, _ := http.NewRequest("GET", "/api/debug/affinity", nil)
-	r.Header.Set("X-API-Key", "test-key")
-	w := httptest.NewRecorder()
-	srv.handleDebugAffinity(w, r)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-
-	var resp DebugAffinityResponse
-	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
-		t.Fatalf("decode error: %v", err)
-	}
-
-	if len(resp.Edges) != 2 {
-		t.Errorf("expected 2 edges, got %d", len(resp.Edges))
-	}
-
-	// Check stats shape
-	if resp.Stats.TotalEdges != 2 {
-		t.Errorf("expected 2 total edges in stats, got %d", resp.Stats.TotalEdges)
-	}
-	if resp.Stats.LastRebuild == "" {
-		t.Error("expected lastRebuild to be set")
-	}
-	if resp.Stats.CacheAge == "" {
-		t.Error("expected cacheAge to be set")
-	}
-}
-
-func TestDebugAffinityPrefixFilter(t *testing.T) {
-	now := time.Now()
-	edge1 := newEdge("aaaa1111", "bbbb2222", "bb", 50, now)
-	edge2 := newEdge("aaaa1111", "dddd3333", "dd", 30, now)
-
-	graph := makeTestGraph(edge1, edge2)
-	srv := makeTestServer(graph)
-	srv.cfg = &Config{APIKey: "test-key"}
-
-	r, _ := http.NewRequest("GET", "/api/debug/affinity?prefix=bb", nil)
-	r.Header.Set("X-API-Key", "test-key")
-	w := httptest.NewRecorder()
-	srv.handleDebugAffinity(w, r)
-
-	var resp DebugAffinityResponse
-	json.NewDecoder(w.Body).Decode(&resp)
-
-	if len(resp.Edges) != 1 {
-		t.Errorf("expected 1 edge with prefix filter, got %d", len(resp.Edges))
-	}
-}
-
-func TestDebugAffinityNodeFilter(t *testing.T) {
-	now := time.Now()
-	edge1 := newEdge("aaaa1111", "bbbb2222", "bb", 50, now)
-	edge2 := newEdge("cccc3333", "dddd4444", "dd", 30, now)
-
-	graph := makeTestGraph(edge1, edge2)
-	srv := makeTestServer(graph)
-	srv.cfg = &Config{APIKey: "test-key"}
-
-	r, _ := http.NewRequest("GET", "/api/debug/affinity?node=aaaa1111", nil)
-	r.Header.Set("X-API-Key", "test-key")
-	w := httptest.NewRecorder()
-	srv.handleDebugAffinity(w, r)
-
-	var resp DebugAffinityResponse
-	json.NewDecoder(w.Body).Decode(&resp)
-
-	if len(resp.Edges) != 1 {
-		t.Errorf("expected 1 edge with node filter, got %d", len(resp.Edges))
-	}
-}
-
-func TestDebugAffinityRequiresAuth(t *testing.T) {
-	graph := makeTestGraph()
-	srv := makeTestServer(graph)
-	srv.cfg = &Config{APIKey: "secret"}
-
-	r, _ := http.NewRequest("GET", "/api/debug/affinity", nil)
-	r.Header.Set("X-API-Key", "wrong-key")
-	w := httptest.NewRecorder()
-
-	// Use the requireAPIKey middleware
-	handler := srv.requireAPIKey(http.HandlerFunc(srv.handleDebugAffinity))
-	handler.ServeHTTP(w, r)
-
-	if w.Code != http.StatusUnauthorized {
-		t.Errorf("expected 401, got %d", w.Code)
-	}
-}
-
-func TestStructuredLogging(t *testing.T) {
-	// Test that the logging function in the graph actually works
-	var logMessages []string
-	g := NewNeighborGraph()
-	g.logFn = func(prefix, msg string) {
-		logMessages = append(logMessages, "[affinity] resolve "+prefix+": "+msg)
-	}
-
-	// Add some edges that would trigger disambiguation
-	now := time.Now()
-	// Add resolved edges for neighbor sets
-	g.mu.Lock()
-	// Node aaaa has neighbors: xxxx, yyyy
-	e1 := &NeighborEdge{NodeA: "aaaa", NodeB: "xxxx", Prefix: "xx", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
-	g.edges[makeEdgeKey("aaaa", "xxxx")] = e1
-	g.byNode["aaaa"] = append(g.byNode["aaaa"], e1)
-	g.byNode["xxxx"] = append(g.byNode["xxxx"], e1)
-
-	e2 := &NeighborEdge{NodeA: "aaaa", NodeB: "yyyy", Prefix: "yy", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
-	g.edges[makeEdgeKey("aaaa", "yyyy")] = e2
-	g.byNode["aaaa"] = append(g.byNode["aaaa"], e2)
-	g.byNode["yyyy"] = append(g.byNode["yyyy"], e2)
-
-	// Candidate cccc1 also has neighbor xxxx, yyyy (high Jaccard with aaaa)
-	e3 := &NeighborEdge{NodeA: "cccc1", NodeB: "xxxx", Prefix: "xx", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
-	g.edges[makeEdgeKey("cccc1", "xxxx")] = e3
-	g.byNode["cccc1"] = append(g.byNode["cccc1"], e3)
-
-	e4 := &NeighborEdge{NodeA: "cccc1", NodeB: "yyyy", Prefix: "yy", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
-	g.edges[makeEdgeKey("cccc1", "yyyy")] = e4
-	g.byNode["cccc1"] = append(g.byNode["cccc1"], e4)
-
-	// Candidate cccc2 has no neighbors (low Jaccard)
-	// Add ambiguous edge: aaaa ↔ prefix:cc with candidates [cccc1, cccc2]
-	ambigEdge := &NeighborEdge{
-		NodeA: "aaaa", NodeB: "", Prefix: "cc", Count: 5,
-		Ambiguous: true, Candidates: []string{"cccc1", "cccc2"},
-		Observers: map[string]bool{}, FirstSeen: now, LastSeen: now,
-	}
-	ambigKey := makeEdgeKey("aaaa", "prefix:cc")
-	g.edges[ambigKey] = ambigEdge
-	g.byNode["aaaa"] = append(g.byNode["aaaa"], ambigEdge)
-	g.mu.Unlock()
-
-	// Now run disambiguate — this should trigger logging
-	g.disambiguate()
-
-	if len(logMessages) == 0 {
-		t.Error("expected at least one log message from disambiguation")
-	}
-
-	found := false
-	for _, msg := range logMessages {
-		if strings.Contains(msg, "[affinity] resolve cc:") {
-			found = true
-		}
-	}
-	if !found {
-		t.Errorf("expected log message about prefix 'cc', got: %v", logMessages)
-	}
-}
-
-func TestColdStartCoverage(t *testing.T) {
-	edges := []*NeighborEdge{
-		{Prefix: "aa", Count: 5},
-		{Prefix: "bb", Count: 3},
-		{Prefix: "cc", Count: 1}, // below threshold
-	}
-
-	srv := &Server{cfg: &Config{}}
-	coverage := srv.computeColdStartCoverage(edges)
-
-	// 2 out of 3 prefixes have >=3 observations = 66.7%
-	if coverage < 66.0 || coverage > 67.0 {
-		t.Errorf("expected ~66.7%% coverage, got %.1f%%", coverage)
-	}
-}
-
-func TestDebugResponseShape(t *testing.T) {
-	edge := newEdge("aaaa1111", "bbbb2222", "bb", 50, time.Now())
-	edge.Resolved = true
-
-	graph := makeTestGraph(edge)
-	srv := makeTestServer(graph)
-	srv.cfg = &Config{APIKey: "test-key"}
-
-	r, _ := http.NewRequest("GET", "/api/debug/affinity", nil)
-	r.Header.Set("X-API-Key", "test-key")
-	w := httptest.NewRecorder()
-	srv.handleDebugAffinity(w, r)
-
-	var resp map[string]interface{}
-	json.NewDecoder(w.Body).Decode(&resp)
-
-	// Verify top-level keys
-	for _, key := range []string{"edges", "resolutions", "stats"} {
-		if _, ok := resp[key]; !ok {
-			t.Errorf("missing top-level key: %s", key)
-		}
-	}
-
-	stats := resp["stats"].(map[string]interface{})
-	for _, key := range []string{"totalEdges", "totalNodes", "resolvedCount", "ambiguousCount", "unresolvedCount", "avgConfidence", "coldStartCoverage", "cacheAge", "lastRebuild"} {
-		if _, ok := stats[key]; !ok {
-			t.Errorf("missing stats key: %s", key)
-		}
-	}
-}

cmd/server/neighbor_graph.go

@@ -2,8 +2,6 @@ package main
 
 import (
 	"encoding/json"
-	"fmt"
-	"log"
 	"math"
 	"strings"
 	"sync"
@@ -86,7 +84,6 @@ type NeighborGraph struct {
 	edges   map[edgeKey]*NeighborEdge
 	byNode  map[string][]*NeighborEdge // pubkey → edges involving this node
 	builtAt time.Time
-	logFn   func(prefix, msg string) // optional structured logging callback
 }
 
 // NewNeighborGraph creates an empty graph.
@@ -127,17 +124,7 @@ func (g *NeighborGraph) IsStale() bool {
 // BuildFromStore constructs the neighbor graph from all packets in the store.
 // The store's read-lock must NOT be held by the caller.
 func BuildFromStore(store *PacketStore) *NeighborGraph {
-	return BuildFromStoreWithLog(store, false)
-}
-
-// BuildFromStoreWithLog constructs the neighbor graph, optionally logging disambiguation decisions.
-func BuildFromStoreWithLog(store *PacketStore, enableLog bool) *NeighborGraph {
 	g := NewNeighborGraph()
-	if enableLog {
-		g.logFn = func(prefix, msg string) {
-			log.Printf("[affinity] resolve %s: %s", prefix, msg)
-		}
-	}
 
 	store.mu.RLock()
 	// Snapshot what we need under lock.
@@ -209,23 +196,25 @@ func BuildFromStoreWithLog(store *PacketStore, enableLog bool) *NeighborGraph {
 	return g
 }
 
-// extractFromNode pulls the originator pubkey from a StoreTx's DecodedJSON.
-// ADVERTs use "pubKey", other packets may use "from_node" or "from".
+// extractFromNode pulls the from_node pubkey from a StoreTx.
+// It looks in DecodedJSON for "from_node" or "from".
 func extractFromNode(tx *StoreTx) string {
 	if tx.DecodedJSON == "" {
 		return ""
 	}
+	// Fast path: look for "from_node" key.
 	var decoded map[string]interface{}
 	if err := jsonUnmarshalFast(tx.DecodedJSON, &decoded); err != nil {
 		return ""
 	}
-	// ADVERTs store the originator pubkey as "pubKey"; other packets may use
-	// "from_node" or "from".  Check all three so we never miss the originator.
-	for _, field := range []string{"pubKey", "from_node", "from"} {
-		if v, ok := decoded[field]; ok {
-			if s, ok := v.(string); ok && s != "" {
-				return s
-			}
+	if v, ok := decoded["from_node"]; ok {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	if v, ok := decoded["from"]; ok {
+		if s, ok := v.(string); ok {
+			return s
 		}
 	}
 	return ""
@@ -418,32 +407,12 @@ func (g *NeighborGraph) disambiguate() {
 		if secondBest.jaccard == 0 {
 			// If second-best is 0 and best > 0, ratio is infinite → resolve.
 			if best.jaccard > 0 {
-				if g.logFn != nil {
-					g.logFn(e.Prefix, fmt.Sprintf("%s score=%d Jaccard=%.2f vs %s score=%d Jaccard=%.2f → neighbor_affinity (ratio ∞)",
-						best.pubkey[:minLen(best.pubkey, 8)], e.Count, best.jaccard,
-						secondBest.pubkey[:minLen(secondBest.pubkey, 8)], e.Count, secondBest.jaccard))
-				}
 				g.resolveEdge(key, e, knownNode, best.pubkey)
 			}
 		} else if best.jaccard/secondBest.jaccard >= affinityConfidenceRatio {
-			ratio := best.jaccard / secondBest.jaccard
-			if g.logFn != nil {
-				g.logFn(e.Prefix, fmt.Sprintf("%s score=%d Jaccard=%.2f vs %s score=%d Jaccard=%.2f → neighbor_affinity (ratio %.1f×)",
-					best.pubkey[:minLen(best.pubkey, 8)], e.Count, best.jaccard,
-					secondBest.pubkey[:minLen(secondBest.pubkey, 8)], e.Count, secondBest.jaccard, ratio))
-			}
 			g.resolveEdge(key, e, knownNode, best.pubkey)
-		} else {
-			// Ambiguous
-			if g.logFn != nil {
-				ratio := 0.0
-				if secondBest.jaccard > 0 {
-					ratio = best.jaccard / secondBest.jaccard
-				}
-				g.logFn(e.Prefix, fmt.Sprintf("scores too close (Jaccard %.2f vs %.2f, ratio %.1f×) → ambiguous, returning %d candidates",
-					best.jaccard, secondBest.jaccard, ratio, len(e.Candidates)))
-			}
 		}
+		// Otherwise remain ambiguous.
 	}
 }
 
@@ -529,11 +498,3 @@ func parseTimestamp(s string) time.Time {
 	return time.Time{}
 }
 
-
-// minLen returns the smaller of n and len(s).
-func minLen(s string, n int) int {
-	if len(s) < n {
-		return len(s)
-	}
-	return n
-}

cmd/server/neighbor_graph_test.go

@@ -622,83 +622,6 @@ func TestBuildNeighborGraph_ADVERTOnlyConstraint(t *testing.T) {
 	}
 }
 
-// ngPubKeyJSON creates decoded JSON using the real ADVERT format ("pubKey" field).
-func ngPubKeyJSON(pubkey string) string {
-	b, _ := json.Marshal(map[string]string{"pubKey": pubkey})
-	return string(b)
-}
-
-func TestBuildNeighborGraph_AdvertPubKeyField(t *testing.T) {
-	// Real ADVERTs use "pubKey", not "from_node". Verify the builder handles it.
-	nodes := []nodeInfo{
-		{PublicKey: "99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234", Name: "Originator"},
-		{PublicKey: "r1aabbccdd001122334455667788990011223344556677889900112233445566", Name: "R1"},
-		{PublicKey: "obs0000100112233445566778899001122334455667788990011223344556677", Name: "Observer"},
-	}
-	tx := ngMakeTx(1, 4, ngPubKeyJSON("99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234"), []*StoreObs{
-		ngMakeObs("obs0000100112233445566778899001122334455667788990011223344556677", `["r1"]`, nowStr, ngFloatPtr(-8.5)),
-	})
-	store := ngTestStore(nodes, []*StoreTx{tx})
-	g := BuildFromStore(store)
-
-	edges := g.AllEdges()
-	if len(edges) < 1 {
-		t.Fatalf("expected >=1 edges from ADVERT with pubKey field, got %d", len(edges))
-	}
-
-	// Check originator↔R1 edge exists
-	found := false
-	for _, e := range edges {
-		a := e.NodeA
-		b := e.NodeB
-		orig := "99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234"
-		r1 := "r1aabbccdd001122334455667788990011223344556677889900112233445566"
-		if (a == orig && b == r1) || (a == r1 && b == orig) {
-			found = true
-		}
-	}
-	if !found {
-		t.Error("missing originator↔R1 edge when using pubKey field (real ADVERT format)")
-	}
-}
-
-func TestBuildNeighborGraph_OneByteHashPrefixes(t *testing.T) {
-	// Real-world scenario: 1-byte hash prefixes with multiple candidates.
-	// Should create edges (possibly ambiguous) rather than empty graph.
-	nodes := []nodeInfo{
-		{PublicKey: "c0dedad400000000000000000000000000000000000000000000000000000001", Name: "NodeC0-1"},
-		{PublicKey: "c0dedad900000000000000000000000000000000000000000000000000000002", Name: "NodeC0-2"},
-		{PublicKey: "a3bbccdd00000000000000000000000000000000000000000000000000000003", Name: "Originator"},
-		{PublicKey: "obs1234500000000000000000000000000000000000000000000000000000004", Name: "Observer"},
-	}
-	// ADVERT from Originator with 1-byte path hop "c0"
-	tx := ngMakeTx(1, 4, ngPubKeyJSON("a3bbccdd00000000000000000000000000000000000000000000000000000003"), []*StoreObs{
-		ngMakeObs("obs1234500000000000000000000000000000000000000000000000000000004", `["c0"]`, nowStr, ngFloatPtr(-12)),
-	})
-	store := ngTestStore(nodes, []*StoreTx{tx})
-	g := BuildFromStore(store)
-
-	edges := g.AllEdges()
-	if len(edges) == 0 {
-		t.Fatal("expected non-empty edges for 1-byte hash prefix network, got 0")
-	}
-
-	// The originator↔c0 edge should be ambiguous (2 candidates match "c0")
-	var hasAmbig bool
-	for _, e := range edges {
-		if e.Ambiguous && e.Prefix == "c0" {
-			hasAmbig = true
-			if len(e.Candidates) != 2 {
-				t.Errorf("expected 2 candidates for prefix c0, got %d", len(e.Candidates))
-			}
-		}
-	}
-	if !hasAmbig {
-		// Could be resolved if one candidate was filtered — check we got some edge
-		t.Log("no ambiguous edge found, but edges exist — acceptable if resolved")
-	}
-}
-
 func TestNeighborGraph_CacheTTL(t *testing.T) {
 	g := NewNeighborGraph()
 	if !g.IsStale() {

cmd/server/resolve_context_test.go

@@ -1,305 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http/httptest"
-	"testing"
-	"time"
-)
-
-// ─── resolveWithContext unit tests ─────────────────────────────────────────────
-
-func TestResolveWithContext_UniquePrefix(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1b2c3d4", Name: "Node-A", HasGPS: true, Lat: 1, Lon: 2},
-	})
-	ni, confidence, _ := pm.resolveWithContext("a1b2c3d4", nil, nil)
-	if ni == nil || ni.Name != "Node-A" {
-		t.Fatal("expected Node-A")
-	}
-	if confidence != "unique_prefix" {
-		t.Fatalf("expected unique_prefix, got %s", confidence)
-	}
-}
-
-func TestResolveWithContext_NoMatch(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1b2c3d4", Name: "Node-A"},
-	})
-	ni, confidence, _ := pm.resolveWithContext("ff", nil, nil)
-	if ni != nil {
-		t.Fatal("expected nil")
-	}
-	if confidence != "no_match" {
-		t.Fatalf("expected no_match, got %s", confidence)
-	}
-}
-
-func TestResolveWithContext_AffinityWins(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1aaaaaa", Name: "Node-A1"},
-		{PublicKey: "a1bbbbbb", Name: "Node-A2"},
-	})
-
-	graph := NewNeighborGraph()
-	for i := 0; i < 100; i++ {
-		graph.upsertEdge("c0c0c0c0", "a1aaaaaa", "a1", "obs1", nil, time.Now())
-	}
-
-	ni, confidence, score := pm.resolveWithContext("a1", []string{"c0c0c0c0"}, graph)
-	if ni == nil || ni.Name != "Node-A1" {
-		t.Fatalf("expected Node-A1, got %v", ni)
-	}
-	if confidence != "neighbor_affinity" {
-		t.Fatalf("expected neighbor_affinity, got %s", confidence)
-	}
-	if score <= 0 {
-		t.Fatalf("expected positive score, got %f", score)
-	}
-}
-
-func TestResolveWithContext_AffinityTooClose_FallsToGeo(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1aaaaaa", Name: "Node-A1", HasGPS: true, Lat: 10, Lon: 20},
-		{PublicKey: "a1bbbbbb", Name: "Node-A2", HasGPS: true, Lat: 11, Lon: 21},
-		{PublicKey: "c0c0c0c0", Name: "Ctx", HasGPS: true, Lat: 10.1, Lon: 20.1},
-	})
-
-	graph := NewNeighborGraph()
-	for i := 0; i < 50; i++ {
-		graph.upsertEdge("c0c0c0c0", "a1aaaaaa", "a1", "obs1", nil, time.Now())
-		graph.upsertEdge("c0c0c0c0", "a1bbbbbb", "a1", "obs1", nil, time.Now())
-	}
-
-	ni, confidence, _ := pm.resolveWithContext("a1", []string{"c0c0c0c0"}, graph)
-	if ni == nil {
-		t.Fatal("expected a result")
-	}
-	if confidence != "geo_proximity" {
-		t.Fatalf("expected geo_proximity, got %s", confidence)
-	}
-	if ni.Name != "Node-A1" {
-		t.Fatalf("expected Node-A1 (closer to context), got %s", ni.Name)
-	}
-}
-
-func TestResolveWithContext_GPSPreference(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
-		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
-	})
-
-	ni, confidence, _ := pm.resolveWithContext("a1", nil, nil)
-	if ni == nil || ni.Name != "HasGPS" {
-		t.Fatalf("expected HasGPS, got %v", ni)
-	}
-	if confidence != "gps_preference" {
-		t.Fatalf("expected gps_preference, got %s", confidence)
-	}
-}
-
-func TestResolveWithContext_FirstMatchFallback(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1aaaaaa", Name: "First"},
-		{PublicKey: "a1bbbbbb", Name: "Second"},
-	})
-
-	ni, confidence, _ := pm.resolveWithContext("a1", nil, nil)
-	if ni == nil || ni.Name != "First" {
-		t.Fatalf("expected First, got %v", ni)
-	}
-	if confidence != "first_match" {
-		t.Fatalf("expected first_match, got %s", confidence)
-	}
-}
-
-func TestResolveWithContext_NilGraphFallsToGPS(t *testing.T) {
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
-		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
-	})
-
-	ni, confidence, _ := pm.resolveWithContext("a1", []string{"someone"}, nil)
-	if ni == nil || ni.Name != "HasGPS" {
-		t.Fatalf("expected HasGPS, got %v", ni)
-	}
-	if confidence != "gps_preference" {
-		t.Fatalf("expected gps_preference, got %s", confidence)
-	}
-}
-
-func TestResolveWithContext_BackwardCompatResolve(t *testing.T) {
-	// Verify original resolve() still works unchanged
-	pm := buildPrefixMap([]nodeInfo{
-		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
-		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
-	})
-	ni := pm.resolve("a1")
-	if ni == nil || ni.Name != "HasGPS" {
-		t.Fatalf("expected HasGPS from resolve(), got %v", ni)
-	}
-}
-
-// ─── geoDistApprox ─────────────────────────────────────────────────────────────
-
-func TestGeoDistApprox_SamePoint(t *testing.T) {
-	d := geoDistApprox(37.0, -122.0, 37.0, -122.0)
-	if d != 0 {
-		t.Fatalf("expected 0, got %f", d)
-	}
-}
-
-func TestGeoDistApprox_Ordering(t *testing.T) {
-	d1 := geoDistApprox(37.0, -122.0, 37.01, -122.01)
-	d2 := geoDistApprox(37.0, -122.0, 38.0, -121.0)
-	if d1 >= d2 {
-		t.Fatal("closer point should have smaller distance")
-	}
-}
-
-// ─── handleResolveHops enhanced response (API tests) ───────────────────────────
-
-func TestResolveHopsAPI_UniquePrefix(t *testing.T) {
-	srv, router := setupTestServer(t)
-	_ = srv
-
-	// Insert a unique node
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"ff11223344", "UniqueNode", 37.0, -122.0)
-
-	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=ff11223344", nil)
-	rr := httptest.NewRecorder()
-	router.ServeHTTP(rr, req)
-
-	var result ResolveHopsResponse
-	if err := json.Unmarshal(rr.Body.Bytes(), &result); err != nil {
-		t.Fatalf("bad JSON: %v", err)
-	}
-
-	hr, ok := result.Resolved["ff11223344"]
-	if !ok {
-		t.Fatal("expected hop in resolved map")
-	}
-	if hr.Confidence != "unique_prefix" {
-		t.Fatalf("expected unique_prefix, got %s", hr.Confidence)
-	}
-}
-
-func TestResolveHopsAPI_AmbiguousNoContext(t *testing.T) {
-	srv, router := setupTestServer(t)
-
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"ee1aaaaaaa", "Node-E1", 37.0, -122.0)
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"ee1bbbbbbb", "Node-E2", 38.0, -121.0)
-
-	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=ee1", nil)
-	rr := httptest.NewRecorder()
-	router.ServeHTTP(rr, req)
-
-	var result ResolveHopsResponse
-	json.Unmarshal(rr.Body.Bytes(), &result)
-
-	hr := result.Resolved["ee1"]
-	if hr == nil {
-		t.Fatal("expected hop in resolved map")
-	}
-	if hr.Confidence != "ambiguous" {
-		t.Fatalf("expected ambiguous, got %s", hr.Confidence)
-	}
-	if len(hr.Candidates) != 2 {
-		t.Fatalf("expected 2 candidates, got %d", len(hr.Candidates))
-	}
-	for _, c := range hr.Candidates {
-		if c.AffinityScore != nil {
-			t.Fatal("expected nil affinity score without context")
-		}
-	}
-}
-
-func TestResolveHopsAPI_WithAffinityContext(t *testing.T) {
-	srv, router := setupTestServer(t)
-
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"dd1aaaaaaa", "Node-D1", 37.0, -122.0)
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"dd1bbbbbbb", "Node-D2", 38.0, -121.0)
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"c0c0c0c0c0", "Context", 37.1, -122.1)
-
-	// Invalidate node cache so the PM includes newly inserted nodes.
-	srv.store.cacheMu.Lock()
-	srv.store.nodeCacheTime = time.Time{}
-	srv.store.cacheMu.Unlock()
-
-	// Build graph with strong affinity
-	graph := NewNeighborGraph()
-	for i := 0; i < 100; i++ {
-		graph.upsertEdge("c0c0c0c0c0", "dd1aaaaaaa", "dd1", "obs1", nil, time.Now())
-	}
-	graph.builtAt = time.Now()
-	srv.neighborMu.Lock()
-	srv.neighborGraph = graph
-	srv.neighborMu.Unlock()
-
-	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=dd1&from_node=c0c0c0c0c0", nil)
-	rr := httptest.NewRecorder()
-	router.ServeHTTP(rr, req)
-
-	var result ResolveHopsResponse
-	json.Unmarshal(rr.Body.Bytes(), &result)
-
-	hr := result.Resolved["dd1"]
-	if hr == nil {
-		t.Fatal("expected hop in resolved map")
-	}
-	if hr.Confidence != "neighbor_affinity" {
-		t.Fatalf("expected neighbor_affinity, got %s", hr.Confidence)
-	}
-	if hr.BestCandidate == nil || *hr.BestCandidate != "dd1aaaaaaa" {
-		t.Fatalf("expected bestCandidate dd1aaaaaaa, got %v", hr.BestCandidate)
-	}
-
-	// Verify affinity scores present
-	hasScore := false
-	for _, c := range hr.Candidates {
-		if c.AffinityScore != nil && *c.AffinityScore > 0 {
-			hasScore = true
-		}
-	}
-	if !hasScore {
-		t.Fatal("expected at least one candidate with affinity score")
-	}
-}
-
-func TestResolveHopsAPI_ResponseShape(t *testing.T) {
-	srv, router := setupTestServer(t)
-
-	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
-		"bb1aaaaaaa", "Node-B1", 37.0, -122.0)
-
-	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=bb1a", nil)
-	rr := httptest.NewRecorder()
-	router.ServeHTTP(rr, req)
-
-	var raw map[string]json.RawMessage
-	json.Unmarshal(rr.Body.Bytes(), &raw)
-
-	if _, ok := raw["resolved"]; !ok {
-		t.Fatal("missing 'resolved' key")
-	}
-
-	var resolved map[string]map[string]interface{}
-	json.Unmarshal(raw["resolved"], &resolved)
-
-	for _, hr := range resolved {
-		if _, ok := hr["confidence"]; !ok {
-			t.Error("missing 'confidence' field in HopResolution")
-		}
-		if _, ok := hr["candidates"]; !ok {
-			t.Error("missing 'candidates' field")
-		}
-	}
-}
-
-// ─── Helpers used only in this test file ───────────────────────────────────────

cmd/server/routes.go

@@ -115,7 +115,6 @@ func (s *Server) RegisterRoutes(r *mux.Router) {
 	r.HandleFunc("/api/perf", s.handlePerf).Methods("GET")
 	r.Handle("/api/perf/reset", s.requireAPIKey(http.HandlerFunc(s.handlePerfReset))).Methods("POST")
 	r.Handle("/api/admin/prune", s.requireAPIKey(http.HandlerFunc(s.handleAdminPrune))).Methods("POST")
-	r.Handle("/api/debug/affinity", s.requireAPIKey(http.HandlerFunc(s.handleDebugAffinity))).Methods("GET")
 
 	// Packet endpoints
 	r.HandleFunc("/api/packets/timestamps", s.handlePacketTimestamps).Methods("GET")
@@ -253,7 +252,6 @@ func (s *Server) handleConfigClient(w http.ResponseWriter, r *http.Request) {
 		ExternalUrls:        s.cfg.ExternalUrls,
 		PropagationBufferMs: float64(s.cfg.PropagationBufferMs()),
 		Timestamps:          s.cfg.GetTimestampConfig(),
-		DebugAffinity:       s.cfg.DebugAffinity,
 	})
 }
 
@@ -284,26 +282,6 @@ func (s *Server) handleConfigTheme(w http.ResponseWriter, r *http.Request) {
 		"accentHover": "#6db3ff",
 		"navBg":       "#0f0f23",
 		"navBg2":      "#1a1a2e",
-		"navText":     "#ffffff",
-		"navTextMuted": "#cbd5e1",
-		"background":  "#f4f5f7",
-		"text":        "#1a1a2e",
-		"textMuted":   "#5b6370",
-		"border":      "#e2e5ea",
-		"surface1":    "#ffffff",
-		"surface2":    "#ffffff",
-		"surface3":    "#ffffff",
-		"sectionBg":   "#eef2ff",
-		"cardBg":      "#ffffff",
-		"contentBg":   "#f4f5f7",
-		"detailBg":    "#ffffff",
-		"inputBg":     "#ffffff",
-		"rowStripe":   "#f9fafb",
-		"rowHover":    "#eef2ff",
-		"selectedBg":  "#dbeafe",
-		"statusGreen": "#22c55e",
-		"statusYellow": "#eab308",
-		"statusRed":   "#ef4444",
 	}, s.cfg.Theme, theme.Theme)
 
 	nodeColors := mergeMap(map[string]interface{}{
@@ -314,60 +292,20 @@ func (s *Server) handleConfigTheme(w http.ResponseWriter, r *http.Request) {
 		"observer":  "#8b5cf6",
 	}, s.cfg.NodeColors, theme.NodeColors)
 
-	themeDark := mergeMap(map[string]interface{}{
-		"accent":      "#4a9eff",
-		"accentHover": "#6db3ff",
-		"navBg":       "#0f0f23",
-		"navBg2":      "#1a1a2e",
-		"navText":     "#ffffff",
-		"navTextMuted": "#cbd5e1",
-		"background":  "#0f0f23",
-		"text":        "#e2e8f0",
-		"textMuted":   "#a8b8cc",
-		"border":      "#334155",
-		"surface1":    "#1a1a2e",
-		"surface2":    "#232340",
-		"cardBg":      "#1a1a2e",
-		"contentBg":   "#0f0f23",
-		"detailBg":    "#232340",
-		"inputBg":     "#1e1e34",
-		"rowStripe":   "#1e1e34",
-		"rowHover":    "#2d2d50",
-		"selectedBg":  "#1e3a5f",
-		"statusGreen": "#22c55e",
-		"statusYellow": "#eab308",
-		"statusRed":   "#ef4444",
-		"surface3":    "#2d2d50",
-		"sectionBg":   "#1e1e34",
-	}, s.cfg.ThemeDark, theme.ThemeDark)
+	themeDark := mergeMap(map[string]interface{}{}, s.cfg.ThemeDark, theme.ThemeDark)
 	typeColors := mergeMap(map[string]interface{}{
-		"ADVERT":   "#22c55e",
-		"GRP_TXT":  "#3b82f6",
-		"TXT_MSG":  "#f59e0b",
-		"ACK":      "#6b7280",
-		"REQUEST":  "#a855f7",
-		"RESPONSE": "#06b6d4",
-		"TRACE":    "#ec4899",
-		"PATH":     "#14b8a6",
-		"ANON_REQ": "#f43f5e",
-		"UNKNOWN":  "#6b7280",
+		"ADVERT": "#22c55e", "GRP_TXT": "#3b82f6", "TXT_MSG": "#f59e0b",
+		"ACK": "#6b7280", "REQUEST": "#a855f7", "RESPONSE": "#06b6d4",
+		"TRACE": "#ec4899", "PATH": "#14b8a6", "ANON_REQ": "#f43f5e",
+		"UNKNOWN": "#6b7280",
 	}, s.cfg.TypeColors, theme.TypeColors)
 
-	defaultHome := map[string]interface{}{
-		"heroTitle":    "CoreScope",
-		"heroSubtitle": "Real-time MeshCore LoRa mesh network analyzer",
-		"steps": []interface{}{
-			map[string]interface{}{"emoji": "🔵", "title": "Connect via Bluetooth", "description": "Flash **BLE companion** firmware from [MeshCore Flasher](https://flasher.meshcore.co.uk/).\n- Screenless devices: default PIN `123456`\n- Screen devices: random PIN shown on display\n- If pairing fails: forget device, reboot, re-pair"},
-			map[string]interface{}{"emoji": "📻", "title": "Set the right frequency preset", "description": "**US Recommended:**\n`910.525 MHz · BW 62.5 kHz · SF 7 · CR 5`\nSelect **\"US Recommended\"** in the app or flasher."},
-			map[string]interface{}{"emoji": "📡", "title": "Advertise yourself", "description": "Tap the signal icon → **Flood** to broadcast your node to the mesh. Companions only advert when you trigger it manually."},
-			map[string]interface{}{"emoji": "🔁", "title": "Check \"Heard N repeats\"", "description": "- **\"Sent\"** = transmitted, no confirmation\n- **\"Heard 0 repeats\"** = no repeater picked it up\n- **\"Heard 1+ repeats\"** = you're on the mesh!"},
-		},
-		"footerLinks": []interface{}{
-			map[string]interface{}{"label": "📦 Packets", "url": "#/packets"},
-			map[string]interface{}{"label": "🗺️ Network Map", "url": "#/map"},
-		},
+	var home interface{}
+	if theme.Home != nil {
+		home = theme.Home
+	} else if s.cfg.Home != nil {
+		home = s.cfg.Home
 	}
-	home := mergeMap(defaultHome, s.cfg.Home, theme.Home)
 
 	writeJSON(w, ThemeResponse{
 		Branding:   branding,
@@ -1376,31 +1314,6 @@ func (s *Server) handleResolveHops(w http.ResponseWriter, r *http.Request) {
 	hops := strings.Split(hopsParam, ",")
 	resolved := map[string]*HopResolution{}
 
-	// Context for affinity-based disambiguation.
-	fromNode := r.URL.Query().Get("from_node")
-	observer := r.URL.Query().Get("observer")
-	var contextPubkeys []string
-	if fromNode != "" {
-		contextPubkeys = append(contextPubkeys, fromNode)
-	}
-	if observer != "" {
-		contextPubkeys = append(contextPubkeys, observer)
-	}
-
-	// Get the neighbor graph for affinity scoring (may be nil).
-	var graph *NeighborGraph
-	if len(contextPubkeys) > 0 {
-		graph = s.getNeighborGraph()
-	}
-
-	// Get the server's prefix map for resolveWithContext.
-	var pm *prefixMap
-	if s.store != nil {
-		s.store.mu.RLock()
-		_, pm = s.store.getCachedNodesAndPM()
-		s.store.mu.RUnlock()
-	}
-
 	for _, hop := range hops {
 		if hop == "" {
 			continue
@@ -1408,7 +1321,7 @@ func (s *Server) handleResolveHops(w http.ResponseWriter, r *http.Request) {
 		hopLower := strings.ToLower(hop)
 		rows, err := s.db.conn.Query("SELECT public_key, name, lat, lon FROM nodes WHERE LOWER(public_key) LIKE ?", hopLower+"%")
 		if err != nil {
-			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}, Confidence: "ambiguous"}
+			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}}
 			continue
 		}
 
@@ -1426,77 +1339,18 @@ func (s *Server) handleResolveHops(w http.ResponseWriter, r *http.Request) {
 		rows.Close()
 
 		if len(candidates) == 0 {
-			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}, Confidence: "no_match"}
+			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}}
 		} else if len(candidates) == 1 {
 			resolved[hop] = &HopResolution{
 				Name: candidates[0].Name, Pubkey: candidates[0].Pubkey,
 				Candidates: candidates, Conflicts: []interface{}{},
-				Confidence: "unique_prefix",
 			}
 		} else {
-			// Compute affinity scores for each candidate if we have context.
-			if graph != nil && len(contextPubkeys) > 0 {
-				now := time.Now()
-				for i := range candidates {
-					candPK := strings.ToLower(candidates[i].Pubkey)
-					bestScore := 0.0
-					for _, ctxPK := range contextPubkeys {
-						edges := graph.Neighbors(strings.ToLower(ctxPK))
-						for _, e := range edges {
-							if e.Ambiguous {
-								continue
-							}
-							otherPK := e.NodeA
-							if strings.EqualFold(otherPK, ctxPK) {
-								otherPK = e.NodeB
-							}
-							if strings.EqualFold(otherPK, candPK) {
-								sc := e.Score(now)
-								if sc > bestScore {
-									bestScore = sc
-								}
-							}
-						}
-					}
-					if bestScore > 0 {
-						s := bestScore
-						candidates[i].AffinityScore = &s
-					}
-				}
-			}
-
-			// Use resolveWithContext for 4-tier disambiguation.
-			var best *nodeInfo
-			var confidence string
-			if pm != nil {
-				best, confidence, _ = pm.resolveWithContext(hopLower, contextPubkeys, graph)
-			}
-
 			ambig := true
-			hr := &HopResolution{
+			resolved[hop] = &HopResolution{
 				Name: candidates[0].Name, Pubkey: candidates[0].Pubkey,
 				Ambiguous: &ambig, Candidates: candidates, Conflicts: hopCandidatesToConflicts(candidates),
-				Confidence: "ambiguous",
 			}
-
-			// Use the resolved node as the default (best-effort pick).
-			if best != nil {
-				hr.Name = best.Name
-				hr.Pubkey = best.PublicKey
-			}
-
-			// Only promote to bestCandidate when affinity is confident.
-			if confidence == "neighbor_affinity" && best != nil {
-				pk := best.PublicKey
-				hr.BestCandidate = &pk
-				hr.Confidence = "neighbor_affinity"
-			} else if (confidence == "geo_proximity" || confidence == "gps_preference" || confidence == "first_match") && best != nil {
-				// Propagate lower-priority tiers so the API reflects the actual
-				// resolution strategy used, rather than collapsing everything to "ambiguous".
-				hr.Confidence = confidence
-			}
-
-			resolved[hop] = hr
 		}
 	}
 	writeJSON(w, ResolveHopsResponse{Resolved: resolved})

cmd/server/routes_test.go

@@ -454,6 +454,35 @@ func TestConfigThemeEndpoint(t *testing.T) {
 	}
 }
 
+func TestConfigThemeTypeColorsDefaults(t *testing.T) {
+	_, router := setupTestServer(t)
+	req := httptest.NewRequest("GET", "/api/config/theme", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+	tc, ok := body["typeColors"].(map[string]interface{})
+	if !ok {
+		t.Fatal("expected typeColors object in theme response")
+	}
+	expectedTypes := []string{"ADVERT", "GRP_TXT", "TXT_MSG", "ACK", "REQUEST", "RESPONSE", "TRACE", "PATH", "ANON_REQ", "UNKNOWN"}
+	for _, typ := range expectedTypes {
+		val, exists := tc[typ]
+		if !exists {
+			t.Errorf("typeColors missing default for %s", typ)
+			continue
+		}
+		color, ok := val.(string)
+		if !ok || color == "" || color == "#000000" {
+			t.Errorf("typeColors[%s] should be a non-black color, got %v", typ, val)
+		}
+	}
+}
+
 func TestConfigMapEndpoint(t *testing.T) {
 	_, router := setupTestServer(t)
 	req := httptest.NewRequest("GET", "/api/config/map", nil)
@@ -1596,47 +1625,6 @@ func TestConfigThemeWithCustomConfig(t *testing.T) {
 	}
 }
 
-func TestConfigThemeHomeDefaults(t *testing.T) {
-	// When no home config is set, server should return built-in defaults
-	db := setupTestDB(t)
-	seedTestData(t, db)
-	cfg := &Config{Port: 3000} // no Home set
-	hub := NewHub()
-	srv := NewServer(db, cfg, hub)
-	router := mux.NewRouter()
-	srv.RegisterRoutes(router)
-
-	req := httptest.NewRequest("GET", "/api/config/theme", nil)
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	if w.Code != 200 {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-	var body map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	home, ok := body["home"].(map[string]interface{})
-	if !ok || home == nil {
-		t.Fatal("expected non-null home object in theme response")
-	}
-	if home["heroTitle"] != "CoreScope" {
-		t.Errorf("expected heroTitle=CoreScope, got %v", home["heroTitle"])
-	}
-	if home["heroSubtitle"] == nil {
-		t.Error("expected heroSubtitle in home defaults")
-	}
-	steps, ok := home["steps"].([]interface{})
-	if !ok || len(steps) == 0 {
-		t.Error("expected non-empty steps array in home defaults")
-	}
-	footerLinks, ok := home["footerLinks"].([]interface{})
-	if !ok || len(footerLinks) == 0 {
-		t.Error("expected non-empty footerLinks array in home defaults")
-	}
-}
-
 func TestConfigCacheWithCustomTTL(t *testing.T) {
 	db := setupTestDB(t)
 	seedTestData(t, db)

cmd/server/store.go

@@ -3304,144 +3304,6 @@ func (pm *prefixMap) resolve(hop string) *nodeInfo {
 	return &candidates[0]
 }
 
-// resolveWithContext resolves a hop prefix using the neighbor affinity graph
-// for disambiguation when multiple candidates match. It applies a 4-tier
-// priority: (1) affinity graph score, (2) geographic proximity to context
-// nodes, (3) GPS preference, (4) first match fallback.
-//
-// contextPubkeys are pubkeys of nodes that provide context for disambiguation
-// (e.g., the originator, observer, or adjacent hops in the path).
-// graph may be nil, in which case it falls back to the existing resolve().
-func (pm *prefixMap) resolveWithContext(hop string, contextPubkeys []string, graph *NeighborGraph) (*nodeInfo, string, float64) {
-	h := strings.ToLower(hop)
-	candidates := pm.m[h]
-	if len(candidates) == 0 {
-		return nil, "no_match", 0
-	}
-	if len(candidates) == 1 {
-		return &candidates[0], "unique_prefix", 1.0
-	}
-
-	// Priority 1: Affinity graph score
-	//
-	// NOTE: We use raw Score() (count × time-decay) here rather than Jaccard
-	// similarity. Jaccard is used at the graph builder level (disambiguate() in
-	// neighbor_graph.go) to resolve ambiguous edges by comparing neighbor-set
-	// overlap. Here, edges are already resolved — we just need to pick the
-	// highest-affinity candidate among them. Raw score is appropriate because
-	// it reflects both observation frequency and recency, which are the right
-	// signals for "which candidate is this hop most likely referring to."
-	if graph != nil && len(contextPubkeys) > 0 {
-		type scored struct {
-			idx   int
-			score float64
-			count int // observation count of the best-scoring edge
-		}
-		now := time.Now()
-		var scores []scored
-		for i, cand := range candidates {
-			candPK := strings.ToLower(cand.PublicKey)
-			bestScore := 0.0
-			bestCount := 0
-			for _, ctxPK := range contextPubkeys {
-				edges := graph.Neighbors(strings.ToLower(ctxPK))
-				for _, e := range edges {
-					if e.Ambiguous {
-						continue
-					}
-					otherPK := e.NodeA
-					if strings.EqualFold(otherPK, ctxPK) {
-						otherPK = e.NodeB
-					}
-					if strings.EqualFold(otherPK, candPK) {
-						s := e.Score(now)
-						if s > bestScore {
-							bestScore = s
-							bestCount = e.Count
-						}
-					}
-				}
-			}
-			if bestScore > 0 {
-				scores = append(scores, scored{i, bestScore, bestCount})
-			}
-		}
-
-		if len(scores) >= 1 {
-			// Sort descending
-			for i := 0; i < len(scores)-1; i++ {
-				for j := i + 1; j < len(scores); j++ {
-					if scores[j].score > scores[i].score {
-						scores[i], scores[j] = scores[j], scores[i]
-					}
-				}
-			}
-			best := scores[0]
-			// Require both score ratio ≥ 3× AND minimum observations (mirrors
-			// disambiguate() in neighbor_graph.go which checks affinityMinObservations).
-			if best.count >= affinityMinObservations &&
-				(len(scores) == 1 || best.score >= affinityConfidenceRatio*scores[1].score) {
-				return &candidates[best.idx], "neighbor_affinity", best.score
-			}
-			// Scores too close — fall through to lower-priority strategies
-		}
-	}
-
-	// Priority 2: Geographic proximity (if context pubkeys have GPS and candidates have GPS)
-	if len(contextPubkeys) > 0 {
-		// Find GPS positions of context nodes from the prefix map or candidates
-		// We need nodeInfo for context pubkeys — look them up
-		var contextLat, contextLon float64
-		var contextGPSCount int
-		for _, ctxPK := range contextPubkeys {
-			ctxLower := strings.ToLower(ctxPK)
-			if infos, ok := pm.m[ctxLower]; ok && len(infos) == 1 && infos[0].HasGPS {
-				contextLat += infos[0].Lat
-				contextLon += infos[0].Lon
-				contextGPSCount++
-			}
-		}
-		if contextGPSCount > 0 {
-			contextLat /= float64(contextGPSCount)
-			contextLon /= float64(contextGPSCount)
-
-			bestIdx := -1
-			bestDist := math.MaxFloat64
-			for i, cand := range candidates {
-				if !cand.HasGPS {
-					continue
-				}
-				d := geoDistApprox(contextLat, contextLon, cand.Lat, cand.Lon)
-				if d < bestDist {
-					bestDist = d
-					bestIdx = i
-				}
-			}
-			if bestIdx >= 0 {
-				return &candidates[bestIdx], "geo_proximity", 0
-			}
-		}
-	}
-
-	// Priority 3: GPS preference
-	for i := range candidates {
-		if candidates[i].HasGPS {
-			return &candidates[i], "gps_preference", 0
-		}
-	}
-
-	// Priority 4: First match fallback
-	return &candidates[0], "first_match", 0
-}
-
-// geoDistApprox returns an approximate distance between two lat/lon points
-// (equirectangular approximation, sufficient for relative comparison).
-func geoDistApprox(lat1, lon1, lat2, lon2 float64) float64 {
-	dLat := (lat2 - lat1) * math.Pi / 180
-	dLon := (lon2 - lon1) * math.Pi / 180 * math.Cos((lat1+lat2)/2*math.Pi/180)
-	return math.Sqrt(dLat*dLat + dLon*dLon)
-}
-
 func parsePathJSON(pathJSON string) []string {
 	if pathJSON == "" || pathJSON == "[]" {
 		return nil

cmd/server/types.go

@@ -873,21 +873,18 @@ type TraceResponse struct {
 // ─── Resolve Hops ──────────────────────────────────────────────────────────────
 
 type HopCandidate struct {
-	Name          interface{} `json:"name"`
-	Pubkey        string      `json:"pubkey"`
-	Lat           interface{} `json:"lat"`
-	Lon           interface{} `json:"lon"`
-	AffinityScore *float64    `json:"affinityScore"`
+	Name   interface{} `json:"name"`
+	Pubkey string      `json:"pubkey"`
+	Lat    interface{} `json:"lat"`
+	Lon    interface{} `json:"lon"`
 }
 
 type HopResolution struct {
-	Name          interface{}    `json:"name"`
-	Pubkey        interface{}    `json:"pubkey,omitempty"`
-	Ambiguous     *bool          `json:"ambiguous,omitempty"`
-	Candidates    []HopCandidate `json:"candidates"`
-	Conflicts     []interface{}  `json:"conflicts"`
-	BestCandidate *string        `json:"bestCandidate,omitempty"`
-	Confidence    string         `json:"confidence,omitempty"`
+	Name       interface{}    `json:"name"`
+	Pubkey     interface{}    `json:"pubkey,omitempty"`
+	Ambiguous  *bool          `json:"ambiguous,omitempty"`
+	Candidates []HopCandidate `json:"candidates"`
+	Conflicts  []interface{}  `json:"conflicts"`
 }
 
 type ResolveHopsResponse struct {
@@ -924,7 +921,6 @@ type ClientConfigResponse struct {
 	ExternalUrls       interface{} `json:"externalUrls"`
 	PropagationBufferMs float64         `json:"propagationBufferMs"`
 	Timestamps          TimestampConfig `json:"timestamps"`
-	DebugAffinity       bool            `json:"debugAffinity,omitempty"`
 }
 
 // ─── IATA Coords ───────────────────────────────────────────────────────────────

docs/RELEASE-NOTES-v3.4.md

@@ -1,47 +0,0 @@
-# CoreScope v3.4 Release Notes
-
-**The neighbor affinity release.** CoreScope now understands how nodes relate to each other — not just that they exist, but how strongly they're connected. This powers smarter hop resolution, richer node detail pages, and a new graph visualization in analytics.
-
----
-
-## 🎯 Features
-
-### Neighbor Affinity System (7 milestones)
-A complete neighbor relationship engine, from backend graph building to frontend visualization:
-
-- **Affinity graph builder** — computes neighbor relationships and connection strength from packet traffic (#507)
-- **Affinity API endpoints** — REST endpoints to query neighbor data (#508)
-- **Show Neighbors via affinity API** — the existing Show Neighbors feature now uses real affinity data instead of raw packet heuristics (#512, fixes #484)
-- **Affinity-aware hop resolution** — hop resolver uses neighbor affinity to pick better paths (#511)
-- **Node detail neighbors section** — dedicated neighbors panel on the node detail page (#510)
-- **Affinity debugging tools** — inspect and troubleshoot affinity calculations (#521)
-- **Neighbor graph visualization** — interactive neighbor graph in the analytics tab (#513)
-
-### Customizer v2
-- Event-driven state management replaces the old imperative approach — cleaner, more predictable theme/config updates (#503)
-
----
-
-## 🐛 Bug Fixes
-
-- **Stale parsed cache on observation packets** — observation packets now correctly invalidate the JSON parse cache (#505)
-- **Null-guard rAF callbacks** — live page no longer crashes when `requestAnimationFrame` callbacks fire after cleanup (#506)
-- **Customizer v2 phantom overrides** — fixed phantom config entries, missing defaults, and stale dark mode state (#520)
-- **Neighbor affinity empty results** — fixed pubKey field name mismatch causing empty affinity graphs (#524)
-- **Home defaults in server theme** — server-side theme config now includes home page defaults (#526)
-- **Neighbor UI crash + dark mode** — fixed Show Neighbors crash and improved dark mode contrast (#527)
-- **Home page steps + FAQ** — both steps AND FAQ now render correctly on the home page (#529)
-
----
-
-## ⚡ Performance
-
-- **Cached JSON.parse for packet data** — packet payloads are parsed once and cached, avoiding redundant `JSON.parse` calls on repeated access (#400)
-
----
-
-## Known Limitations
-
-- **Affinity graph scales with traffic volume** — networks with very low packet rates may show weak or missing neighbor relationships until enough data accumulates
-- **Debugging tools are developer-facing** — the affinity debug panel (#521) is functional but not polished for end-user consumption
-- **Customizer v2 migration** — custom themes saved under v1 may need to be re-applied after upgrade

public/analytics.js

@@ -85,7 +85,6 @@
             <button class="tab-btn" data-tab="subpaths">Route Patterns</button>
             <button class="tab-btn" data-tab="nodes">Nodes</button>
             <button class="tab-btn" data-tab="distance">Distance</button>
-            <button class="tab-btn" data-tab="neighbor-graph">Neighbor Graph</button>
           </div>
         </div>
         <div id="analyticsContent" class="analytics-content">
@@ -172,7 +171,6 @@
       case 'subpaths': await renderSubpaths(el); break;
       case 'nodes': await renderNodesTab(el); break;
       case 'distance': await renderDistanceTab(el); break;
-      case 'neighbor-graph': await renderNeighborGraphTab(el); break;
     }
     // Auto-apply column resizing to all analytics tables
     requestAnimationFrame(() => {
@@ -267,37 +265,6 @@
         </div>
       </div>
     `;
-
-    // Affinity stats widget — fetch and append if debugAffinity enabled
-    var showDebug = (window.CLIENT_CONFIG && window.CLIENT_CONFIG.debugAffinity) || localStorage.getItem('meshcore-affinity-debug') === 'true';
-    if (showDebug) {
-      var apiKey = localStorage.getItem('meshcore-api-key') || '';
-      fetch('/api/debug/affinity', { headers: { 'X-API-Key': apiKey } })
-        .then(function (r) { return r.ok ? r.json() : null; })
-        .then(function (data) {
-          if (!data || !data.stats) return;
-          var s = data.stats;
-          var total = s.resolvedCount + s.ambiguousCount + s.unresolvedCount;
-          var resolvedPct = total > 0 ? (s.resolvedCount / total * 100).toFixed(1) : '0.0';
-          var ambiguousPct = total > 0 ? (s.ambiguousCount / total * 100).toFixed(1) : '0.0';
-          var widget = document.createElement('div');
-          widget.className = 'analytics-row';
-          widget.innerHTML = '<div class="analytics-card flex-1">' +
-            '<h3>🔍 Neighbor Affinity Graph</h3>' +
-            '<div class="stats-grid">' +
-            '<div class="stat-card"><div class="stat-value">' + s.totalEdges + '</div><div class="stat-label">Total Edges</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + s.totalNodes + '</div><div class="stat-label">Total Nodes</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + s.resolvedCount + ' <span style="font-size:12px;color:var(--text-muted)">(' + resolvedPct + '%)</span></div><div class="stat-label">Resolved Prefixes</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + s.ambiguousCount + ' <span style="font-size:12px;color:var(--text-muted)">(' + ambiguousPct + '%)</span></div><div class="stat-label">Ambiguous Prefixes</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + (s.avgConfidence || 0).toFixed(3) + '</div><div class="stat-label">Avg Confidence</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + (s.coldStartCoverage || 0).toFixed(1) + '%</div><div class="stat-label">Cold-Start Coverage</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + (s.cacheAge || 'N/A') + '</div><div class="stat-label">Cache Age</div></div>' +
-            '<div class="stat-card"><div class="stat-value">' + (s.lastRebuild ? s.lastRebuild.substring(0, 19) : 'N/A') + '</div><div class="stat-label">Last Rebuild</div></div>' +
-            '</div></div>';
-          el.appendChild(widget);
-        })
-        .catch(function () {});
-    }
   }
 
   function renderPayloadPie(types) {
@@ -1832,7 +1799,7 @@
     }
   }
 
-function destroy() { _analyticsData = {}; _channelData = null; if (_ngState && _ngState.animId) { cancelAnimationFrame(_ngState.animId); } _ngState = null; }
+function destroy() { _analyticsData = {}; _channelData = null; }
 
   // Expose for testing
   if (typeof window !== 'undefined') {
@@ -1843,455 +1810,5 @@ function destroy() { _analyticsData = {}; _channelData = null; if (_ngState && _
     window._analyticsChannelTheadHtml = channelTheadHtml;
   }
 
-  // ─── Neighbor Graph Tab ─────────────────────────────────────────────────────
-
-  let _ngState = null; // neighbor graph state
-
-  async function renderNeighborGraphTab(el) {
-    el.innerHTML = `
-      <div class="analytics-card" id="ngCard">
-        <h3>🕸️ Neighbor Graph</h3>
-        <div id="ngFilters" class="ng-filters" style="display:flex;gap:12px;flex-wrap:wrap;align-items:center;margin-bottom:12px">
-          <label style="font-size:13px">Roles:
-            <span id="ngRoleChecks" style="margin-left:4px"></span>
-          </label>
-          <label style="font-size:13px">Min Score: <input type="range" id="ngMinScore" min="0" max="100" value="10" style="width:100px;vertical-align:middle">
-            <span id="ngMinScoreVal">0.10</span>
-          </label>
-          <label style="font-size:13px">Confidence:
-            <select id="ngConfidence" style="font-size:12px;padding:2px 4px">
-              <option value="all">Show All</option>
-              <option value="high">High Only</option>
-              <option value="hide-ambiguous">Hide Ambiguous</option>
-            </select>
-          </label>
-        </div>
-        <div id="ngStats" class="stat-row" style="display:flex;gap:16px;flex-wrap:wrap;margin-bottom:12px"></div>
-        <div style="position:relative;border:1px solid var(--border);border-radius:6px;overflow:hidden">
-          <canvas id="ngCanvas" width="900" height="600" style="width:100%;height:600px;cursor:grab;outline-offset:2px" role="img" aria-label="Neighbor affinity graph visualization — interactive force-directed network topology" tabindex="0"></canvas>
-          <div id="ngTooltip" style="position:absolute;display:none;background:var(--bg-secondary);border:1px solid var(--border);border-radius:4px;padding:6px 10px;font-size:12px;pointer-events:none;z-index:10;box-shadow:0 2px 8px rgba(0,0,0,0.2)"></div>
-        </div>
-        <details id="ngAccessibleList" style="margin-top:12px">
-          <summary style="cursor:pointer;font-size:13px;color:var(--text-secondary)">📋 Text-based neighbor list (accessible alternative)</summary>
-          <div id="ngTextList" style="font-size:12px;max-height:300px;overflow-y:auto;padding:8px;background:var(--bg-secondary);border-radius:4px;margin-top:4px"></div>
-        </details>
-      </div>`;
-
-    // Role checkboxes
-    const roles = ['repeater','companion','room','sensor'];
-    const rcEl = document.getElementById('ngRoleChecks');
-    roles.forEach(r => {
-      const color = (window.ROLE_COLORS || {})[r] || '#888';
-      rcEl.innerHTML += `<label style="font-size:12px;margin-right:8px"><input type="checkbox" data-role="${r}" checked> <span style="color:${esc(color)}">${esc(r)}</span></label>`;
-    });
-
-    // Load data
-    const rqs = RegionFilter.regionQueryString();
-    const sep = rqs ? '?' + rqs.slice(1) : '';
-    let graphData;
-    try {
-      graphData = await api('/analytics/neighbor-graph' + sep + (sep ? '&' : '?') + 'min_count=1&min_score=0', { ttl: CLIENT_TTL.analyticsRF });
-    } catch (e) {
-      el.innerHTML = `<div class="analytics-card"><p class="text-muted">Failed to load neighbor graph: ${esc(e.message)}</p></div>`;
-      return;
-    }
-
-    _ngState = createGraphState(graphData);
-    renderNGStats(_ngState);
-    startGraphRenderer();
-
-    // Filter listeners
-    document.getElementById('ngMinScore').addEventListener('input', function() {
-      document.getElementById('ngMinScoreVal').textContent = (this.value / 100).toFixed(2);
-      applyNGFilters();
-    });
-    document.getElementById('ngConfidence').addEventListener('change', applyNGFilters);
-    rcEl.addEventListener('change', applyNGFilters);
-  }
-
-  function createGraphState(data) {
-    const nodes = (data.nodes || []).map((n, i) => ({
-      ...n,
-      x: 450 + (Math.random() - 0.5) * 400,
-      y: 300 + (Math.random() - 0.5) * 300,
-      vx: 0, vy: 0,
-      radius: Math.max(6, Math.min(18, 6 + (n.neighbor_count || 0)))
-    }));
-    const nodeIdx = {};
-    nodes.forEach((n, i) => { nodeIdx[n.pubkey] = i; });
-    const edges = (data.edges || []).filter(e => nodeIdx[e.source] !== undefined && nodeIdx[e.target] !== undefined);
-    return {
-      allNodes: nodes, allEdges: edges,
-      nodes, edges, nodeIdx,
-      stats: data.stats || {},
-      zoom: 1, panX: 0, panY: 0,
-      dragging: null, panning: false,
-      lastMouseX: 0, lastMouseY: 0,
-      cooling: 1.0, animId: null
-    };
-  }
-
-  function applyNGFilters() {
-    if (!_ngState) return;
-    const minScore = parseInt(document.getElementById('ngMinScore').value, 10) / 100;
-    const conf = document.getElementById('ngConfidence').value;
-    const checkedRoles = new Set();
-    document.querySelectorAll('#ngRoleChecks input:checked').forEach(cb => checkedRoles.add(cb.dataset.role));
-
-    // Filter nodes by role
-    const visibleNodes = _ngState.allNodes.filter(n => {
-      const role = (n.role || 'unknown').toLowerCase();
-      return checkedRoles.has(role) || role === 'unknown' || role === 'observer';
-    });
-    const visiblePKs = new Set(visibleNodes.map(n => n.pubkey));
-
-    // Filter edges
-    _ngState.edges = _ngState.allEdges.filter(e => {
-      if (e.score < minScore) return false;
-      if (conf === 'high' && (e.ambiguous || e.score < 0.5)) return false;
-      if (conf === 'hide-ambiguous' && e.ambiguous) return false;
-      return visiblePKs.has(e.source) && visiblePKs.has(e.target);
-    });
-
-    // Only include nodes that have at least one visible edge
-    const edgeNodes = new Set();
-    _ngState.edges.forEach(e => { edgeNodes.add(e.source); edgeNodes.add(e.target); });
-    _ngState.nodes = visibleNodes.filter(n => edgeNodes.has(n.pubkey));
-
-    // Rebuild index
-    _ngState.nodeIdx = {};
-    _ngState.nodes.forEach((n, i) => { _ngState.nodeIdx[n.pubkey] = i; });
-
-    _ngState.cooling = 1.0;
-    renderNGStats(_ngState);
-  }
-
-  function renderNGStats(st) {
-    const nodes = st.nodes, edges = st.edges;
-    const totalScore = edges.reduce((s, e) => s + e.score, 0);
-    const avgScore = edges.length ? (totalScore / edges.length) : 0;
-    const ambiguous = edges.filter(e => e.ambiguous).length;
-    const resolved = edges.length ? ((edges.length - ambiguous) / edges.length * 100) : 0;
-    const statsEl = document.getElementById('ngStats');
-    if (!statsEl) return;
-    statsEl.innerHTML = `
-      <div class="stat-card"><div class="stat-value">${nodes.length}</div><div class="stat-label">Nodes</div></div>
-      <div class="stat-card"><div class="stat-value">${edges.length}</div><div class="stat-label">Edges</div></div>
-      <div class="stat-card"><div class="stat-value">${avgScore.toFixed(2)}</div><div class="stat-label">Avg Score</div></div>
-      <div class="stat-card"><div class="stat-value">${resolved.toFixed(0)}%</div><div class="stat-label">Resolved</div></div>
-      <div class="stat-card"><div class="stat-value">${ambiguous}</div><div class="stat-label">Ambiguous</div></div>`;
-
-    // Update canvas aria-label with current graph summary
-    var canvas = document.getElementById('ngCanvas');
-    if (canvas) {
-      canvas.setAttribute('aria-label', 'Neighbor affinity graph: ' + nodes.length + ' nodes, ' + edges.length + ' edges, ' + resolved.toFixed(0) + '% resolved. Use arrow keys to pan, +/- to zoom, 0 to reset.');
-    }
-
-    // Update accessible text list
-    updateNGTextList(st);
-  }
-
-  function updateNGTextList(st) {
-    var listEl = document.getElementById('ngTextList');
-    if (!listEl) return;
-    var nodes = st.nodes, edges = st.edges;
-    if (nodes.length === 0) {
-      listEl.innerHTML = '<p class="text-muted">No nodes to display.</p>';
-      return;
-    }
-    // Build adjacency for text list
-    var adj = {};
-    edges.forEach(function(e) {
-      if (!adj[e.source]) adj[e.source] = [];
-      if (!adj[e.target]) adj[e.target] = [];
-      adj[e.source].push({ pk: e.target, score: e.score, ambiguous: e.ambiguous });
-      adj[e.target].push({ pk: e.source, score: e.score, ambiguous: e.ambiguous });
-    });
-    var nodeMap = {};
-    nodes.forEach(function(n) { nodeMap[n.pubkey] = n; });
-    var html = '<table style="width:100%;border-collapse:collapse"><thead><tr><th style="text-align:left;padding:4px;border-bottom:1px solid var(--border)">Node</th><th style="text-align:left;padding:4px;border-bottom:1px solid var(--border)">Role</th><th style="text-align:left;padding:4px;border-bottom:1px solid var(--border)">Neighbors</th></tr></thead><tbody>';
-    nodes.slice().sort(function(a, b) { return (a.name || a.pubkey).localeCompare(b.name || b.pubkey); }).forEach(function(n) {
-      var neighbors = (adj[n.pubkey] || []).map(function(nb) {
-        var peer = nodeMap[nb.pk];
-        var name = peer ? (peer.name || nb.pk.slice(0, 8)) : nb.pk.slice(0, 8);
-        var conf = nb.ambiguous ? ' ⚠' : (nb.score >= 0.5 ? ' ●' : ' ○');
-        return esc(name) + conf;
-      }).join(', ');
-      html += '<tr><td style="padding:4px;border-bottom:1px solid var(--border)">' + esc(n.name || n.pubkey.slice(0, 12)) + '</td><td style="padding:4px;border-bottom:1px solid var(--border)">' + esc(n.role || 'unknown') + '</td><td style="padding:4px;border-bottom:1px solid var(--border)">' + (neighbors || '<em>none</em>') + '</td></tr>';
-    });
-    html += '</tbody></table>';
-    html += '<p style="margin-top:8px;font-size:11px;color:var(--text-secondary)">● = high confidence (score ≥ 0.5), ○ = low confidence, ⚠ = ambiguous/unresolved</p>';
-    listEl.innerHTML = html;
-  }
-
-  function startGraphRenderer() {
-    if (!_ngState) return;
-
-    // Node count guard: skip force simulation for very large graphs
-    var NODE_LIMIT = 1000;
-    if (_ngState.allNodes.length > NODE_LIMIT) {
-      var el = document.getElementById('ngCanvas');
-      if (el) {
-        el.style.display = 'none';
-        var msg = document.createElement('div');
-        msg.className = 'analytics-card';
-        msg.innerHTML = '<p class="text-muted">Graph has ' + _ngState.allNodes.length + ' nodes (limit: ' + NODE_LIMIT + '). Force simulation skipped for performance. Use filters to reduce the node count.</p>';
-        el.parentNode.insertBefore(msg, el);
-      }
-      return;
-    }
-
-    const canvas = document.getElementById('ngCanvas');
-    if (!canvas) return;
-    const ctx = canvas.getContext('2d');
-    const dpr = window.devicePixelRatio || 1;
-    canvas.width = canvas.clientWidth * dpr;
-    canvas.height = canvas.clientHeight * dpr;
-    ctx.scale(dpr, dpr);
-    const W = canvas.clientWidth, H = canvas.clientHeight;
-
-    // Interaction
-    let hoverNode = null;
-
-    function canvasToGraph(cx, cy) {
-      return { x: (cx - _ngState.panX) / _ngState.zoom, y: (cy - _ngState.panY) / _ngState.zoom };
-    }
-
-    function findNode(cx, cy) {
-      const gp = canvasToGraph(cx, cy);
-      for (let i = _ngState.nodes.length - 1; i >= 0; i--) {
-        const n = _ngState.nodes[i];
-        const dx = gp.x - n.x, dy = gp.y - n.y;
-        if (dx * dx + dy * dy <= n.radius * n.radius) return n;
-      }
-      return null;
-    }
-
-    canvas.addEventListener('mousedown', function(e) {
-      const rect = canvas.getBoundingClientRect();
-      const cx = e.clientX - rect.left, cy = e.clientY - rect.top;
-      const n = findNode(cx, cy);
-      if (n) {
-        _ngState.dragging = n;
-        n._pinned = true;
-        canvas.style.cursor = 'grabbing';
-      } else {
-        _ngState.panning = true;
-        canvas.style.cursor = 'grabbing';
-      }
-      _ngState.lastMouseX = e.clientX;
-      _ngState.lastMouseY = e.clientY;
-    });
-
-    canvas.addEventListener('mousemove', function(e) {
-      const rect = canvas.getBoundingClientRect();
-      const cx = e.clientX - rect.left, cy = e.clientY - rect.top;
-      if (_ngState.dragging) {
-        const dx = (e.clientX - _ngState.lastMouseX) / _ngState.zoom;
-        const dy = (e.clientY - _ngState.lastMouseY) / _ngState.zoom;
-        _ngState.dragging.x += dx;
-        _ngState.dragging.y += dy;
-        _ngState.lastMouseX = e.clientX;
-        _ngState.lastMouseY = e.clientY;
-        _ngState.cooling = Math.max(_ngState.cooling, 0.3);
-      } else if (_ngState.panning) {
-        _ngState.panX += e.clientX - _ngState.lastMouseX;
-        _ngState.panY += e.clientY - _ngState.lastMouseY;
-        _ngState.lastMouseX = e.clientX;
-        _ngState.lastMouseY = e.clientY;
-      } else {
-        const n = findNode(cx, cy);
-        if (n !== hoverNode) {
-          hoverNode = n;
-          canvas.style.cursor = n ? 'pointer' : 'grab';
-          const tip = document.getElementById('ngTooltip');
-          if (n && tip) {
-            tip.style.display = 'block';
-            tip.style.left = (cx + 12) + 'px';
-            tip.style.top = (cy - 8) + 'px';
-            tip.innerHTML = `<strong>${esc(n.name || n.pubkey.slice(0, 12) + '…')}</strong><br>Role: ${esc(n.role || 'unknown')}<br>Neighbors: ${n.neighbor_count || 0}`;
-          } else if (tip) {
-            tip.style.display = 'none';
-          }
-        } else if (hoverNode) {
-          const tip = document.getElementById('ngTooltip');
-          if (tip) { tip.style.left = (cx + 12) + 'px'; tip.style.top = (cy - 8) + 'px'; }
-        }
-      }
-    });
-
-    canvas.addEventListener('mouseup', function() {
-      if (_ngState.dragging) {
-        _ngState.dragging._pinned = false;
-        _ngState._wasDragging = true;
-      }
-      _ngState.dragging = null;
-      _ngState.panning = false;
-      canvas.style.cursor = hoverNode ? 'pointer' : 'grab';
-    });
-
-    canvas.addEventListener('mouseleave', function() {
-      _ngState.dragging = null;
-      _ngState.panning = false;
-      _ngState._wasDragging = false;
-      const tip = document.getElementById('ngTooltip');
-      if (tip) tip.style.display = 'none';
-      hoverNode = null;
-    });
-
-    canvas.addEventListener('click', function(e) {
-      if (_ngState._wasDragging) { _ngState._wasDragging = false; return; }
-      if (_ngState.dragging) return;
-      const rect = canvas.getBoundingClientRect();
-      const n = findNode(e.clientX - rect.left, e.clientY - rect.top);
-      if (n) location.hash = '#/nodes/' + n.pubkey;
-    });
-
-    canvas.addEventListener('keydown', function(e) {
-      const PAN_STEP = 30, ZOOM_STEP = 1.15;
-      switch (e.key) {
-        case 'ArrowLeft':  _ngState.panX += PAN_STEP; e.preventDefault(); break;
-        case 'ArrowRight': _ngState.panX -= PAN_STEP; e.preventDefault(); break;
-        case 'ArrowUp':    _ngState.panY += PAN_STEP; e.preventDefault(); break;
-        case 'ArrowDown':  _ngState.panY -= PAN_STEP; e.preventDefault(); break;
-        case '+': case '=': _ngState.zoom = Math.min(10, _ngState.zoom * ZOOM_STEP); e.preventDefault(); break;
-        case '-': case '_': _ngState.zoom = Math.max(0.1, _ngState.zoom / ZOOM_STEP); e.preventDefault(); break;
-        case '0':           _ngState.zoom = 1; _ngState.panX = 0; _ngState.panY = 0; e.preventDefault(); break;
-      }
-    });
-
-    canvas.addEventListener('wheel', function(e) {
-      e.preventDefault();
-      const rect = canvas.getBoundingClientRect();
-      const cx = e.clientX - rect.left, cy = e.clientY - rect.top;
-      const factor = e.deltaY < 0 ? 1.1 : 0.9;
-      const newZoom = Math.max(0.1, Math.min(10, _ngState.zoom * factor));
-      // Zoom towards mouse position
-      _ngState.panX = cx - (cx - _ngState.panX) * (newZoom / _ngState.zoom);
-      _ngState.panY = cy - (cy - _ngState.panY) * (newZoom / _ngState.zoom);
-      _ngState.zoom = newZoom;
-    }, { passive: false });
-
-    // Cache text color to avoid getComputedStyle every frame
-    const _labelColor = cssVar('--text-primary') || '#e0e0e0';
-
-    // Force simulation + render loop
-    // Performance: 500 nodes brute-force repulsion: avg ~4ms/frame = 250fps headroom (measured Chrome 120, M1)
-    var _perfFrameTimes = [], _perfLastTime = 0;
-    function tick() {
-      if (!document.getElementById('ngCanvas')) { _ngState.animId = null; return; }
-      var now = performance.now();
-      if (_perfLastTime) _perfFrameTimes.push(now - _perfLastTime);
-      _perfLastTime = now;
-      if (_perfFrameTimes.length === 100) {
-        var avg = _perfFrameTimes.reduce(function(a, b) { return a + b; }, 0) / 100;
-        console.log('[NeighborGraph perf] avg frame time over 100 frames: ' + avg.toFixed(2) + 'ms (' + (1000 / avg).toFixed(0) + ' fps)');
-        _perfFrameTimes = [];
-      }
-      const st = _ngState;
-      const nodes = st.nodes, edges = st.edges, idx = st.nodeIdx;
-
-      if (st.cooling > 0.001) {
-        // Repulsion (all pairs — use grid for large sets, brute force for small)
-        const k = 80; // repulsion constant
-        for (let i = 0; i < nodes.length; i++) {
-          for (let j = i + 1; j < nodes.length; j++) {
-            let dx = nodes[j].x - nodes[i].x;
-            let dy = nodes[j].y - nodes[i].y;
-            let d2 = dx * dx + dy * dy;
-            if (d2 < 1) { dx = Math.random() - 0.5; dy = Math.random() - 0.5; d2 = 1; }
-            const f = k * k / d2;
-            const fx = dx / Math.sqrt(d2) * f;
-            const fy = dy / Math.sqrt(d2) * f;
-            nodes[i].vx -= fx; nodes[i].vy -= fy;
-            nodes[j].vx += fx; nodes[j].vy += fy;
-          }
-        }
-
-        // Attraction along edges
-        const idealLen = 120;
-        for (const e of edges) {
-          const si = idx[e.source], ti = idx[e.target];
-          if (si === undefined || ti === undefined) continue;
-          const a = nodes[si], b = nodes[ti];
-          let dx = b.x - a.x, dy = b.y - a.y;
-          const d = Math.sqrt(dx * dx + dy * dy) || 1;
-          const f = (d - idealLen) * 0.05 * (0.5 + e.score * 0.5);
-          const fx = dx / d * f, fy = dy / d * f;
-          a.vx += fx; a.vy += fy;
-          b.vx -= fx; b.vy -= fy;
-        }
-
-        // Center gravity
-        for (const n of nodes) {
-          n.vx += (W / 2 - n.x) * 0.001;
-          n.vy += (H / 2 - n.y) * 0.001;
-        }
-
-        // Apply velocities with damping
-        const damping = 0.85;
-        for (const n of nodes) {
-          if (n._pinned) { n.vx = 0; n.vy = 0; continue; }
-          n.vx *= damping * st.cooling;
-          n.vy *= damping * st.cooling;
-          const speed = Math.sqrt(n.vx * n.vx + n.vy * n.vy);
-          if (speed > 10) { n.vx *= 10 / speed; n.vy *= 10 / speed; }
-          n.x += n.vx;
-          n.y += n.vy;
-        }
-        st.cooling *= 0.995;
-      }
-
-      // Render
-      ctx.save();
-      ctx.clearRect(0, 0, W, H);
-      ctx.translate(st.panX, st.panY);
-      ctx.scale(st.zoom, st.zoom);
-
-      // Edges
-      for (const e of edges) {
-        const si = idx[e.source], ti = idx[e.target];
-        if (si === undefined || ti === undefined) continue;
-        const a = nodes[si], b = nodes[ti];
-        ctx.beginPath();
-        ctx.moveTo(a.x, a.y);
-        ctx.lineTo(b.x, b.y);
-        ctx.strokeStyle = e.ambiguous ? 'rgba(255,200,0,0.4)' : 'rgba(150,150,150,0.35)';
-        ctx.lineWidth = Math.max(0.5, e.score * 4);
-        if (e.ambiguous) { ctx.setLineDash([4, 4]); } else { ctx.setLineDash([]); }
-        ctx.stroke();
-        ctx.setLineDash([]);
-      }
-
-      // Nodes
-      const roleColors = window.ROLE_COLORS || {};
-      for (const n of nodes) {
-        const color = roleColors[(n.role || '').toLowerCase()] || '#6b7280';
-        ctx.beginPath();
-        ctx.arc(n.x, n.y, n.radius, 0, Math.PI * 2);
-        ctx.fillStyle = color;
-        ctx.fill();
-        if (n === hoverNode) {
-          ctx.strokeStyle = '#fff';
-          ctx.lineWidth = 2;
-          ctx.stroke();
-        }
-        // Label
-        const label = n.name || (n.pubkey ? n.pubkey.slice(0, 8) + '…' : '');
-        if (label && st.zoom > 0.4) {
-          ctx.fillStyle = _labelColor;
-          ctx.font = '10px sans-serif';
-          ctx.textAlign = 'center';
-          ctx.fillText(label, n.x, n.y + n.radius + 12);
-        }
-      }
-
-      ctx.restore();
-      st.animId = requestAnimationFrame(tick);
-    }
-
-    _ngState.animId = requestAnimationFrame(tick);
-  }
-
   registerPage('analytics', { init, destroy });
 })();

public/customize-v2.js

@@ -6,21 +6,6 @@
 (function () {
   // ── Constants ──
 
-  var DEFAULT_HOME = {
-    heroTitle: 'CoreScope',
-    heroSubtitle: 'Real-time MeshCore LoRa mesh network analyzer',
-    steps: [
-      { emoji: '🔵', title: 'Connect via Bluetooth', description: 'Flash **BLE companion** firmware from [MeshCore Flasher](https://flasher.meshcore.co.uk/).\n- Screenless devices: default PIN `123456`\n- Screen devices: random PIN shown on display\n- If pairing fails: forget device, reboot, re-pair' },
-      { emoji: '📻', title: 'Set the right frequency preset', description: '**US Recommended:**\n`910.525 MHz · BW 62.5 kHz · SF 7 · CR 5`\nSelect **"US Recommended"** in the app or flasher.' },
-      { emoji: '📡', title: 'Advertise yourself', description: 'Tap the signal icon → **Flood** to broadcast your node to the mesh. Companions only advert when you trigger it manually.' },
-      { emoji: '🔁', title: 'Check "Heard N repeats"', description: '- **"Sent"** = transmitted, no confirmation\n- **"Heard 0 repeats"** = no repeater picked it up\n- **"Heard 1+ repeats"** = you\'re on the mesh!' }
-    ],
-    footerLinks: [
-      { label: '📦 Packets', url: '#/packets' },
-      { label: '🗺️ Network Map', url: '#/map' }
-    ]
-  };
-
   var STORAGE_KEY = 'cs-theme-overrides';
   var DARK_MODE_KEY = 'meshcore-theme';
   var LEGACY_KEYS = [
@@ -305,7 +290,6 @@
 
   /** @type {object|null} server defaults, set during init */
   var _serverDefaults = null;
-  var _initDone = false;
   var _saveStatus = 'saved'; // 'saved' | 'saving' | 'error'
   var _writeTimer = null;
 
@@ -406,10 +390,6 @@
 
   function computeEffective(serverConfig, userOverrides) {
     var effective = JSON.parse(JSON.stringify(serverConfig || {}));
-    // Defense-in-depth: if server returned home:null, use built-in defaults
-    if (!effective.home || typeof effective.home !== 'object') {
-      effective.home = JSON.parse(JSON.stringify(DEFAULT_HOME));
-    }
     if (!userOverrides || typeof userOverrides !== 'object') return effective;
     for (var key in userOverrides) {
       if (!userOverrides.hasOwnProperty(key)) continue;
@@ -598,29 +578,7 @@
           delta[sec] = _pendingOverrides[sec];
         }
       }
-      var pendingKeys = _pendingOverrides;
       _pendingOverrides = {};
-      // Spec Decision #7: don't silently prune existing overrides.
-      // Only prevent redundant NEW writes: if a value just written matches
-      // the server default, don't store it (clearOverride semantics).
-      var server = _serverDefaults || {};
-      for (var ps in pendingKeys) {
-        if (typeof pendingKeys[ps] === 'object' && pendingKeys[ps] !== null && OBJECT_SECTIONS.indexOf(ps) >= 0) {
-          var serverSec = server[ps] || {};
-          if (delta[ps]) {
-            for (var pk in pendingKeys[ps]) {
-              var ov = delta[ps][pk];
-              var sv = serverSec[pk];
-              var match = (typeof ov === 'object' || typeof sv === 'object')
-                ? JSON.stringify(ov) === JSON.stringify(sv) : ov === sv;
-              if (match) delete delta[ps][pk];
-            }
-            if (Object.keys(delta[ps]).length === 0) delete delta[ps];
-          }
-        } else if (SCALAR_SECTIONS.indexOf(ps) >= 0 && delta[ps] === server[ps]) {
-          delete delta[ps];
-        }
-      }
       writeOverrides(delta);
       _runPipeline();
       _refreshPanel();
@@ -784,33 +742,17 @@
     if (section) {
       if (!overrides[section] || !overrides[section].hasOwnProperty(key)) return false;
       var serverSection = server[section] || {};
-      var ov = overrides[section][key];
-      var sv = serverSection[key];
-      // Deep compare for arrays/objects
-      if (typeof ov === 'object' || typeof sv === 'object') {
-        return JSON.stringify(ov) !== JSON.stringify(sv);
-      }
-      return ov !== sv;
+      return overrides[section][key] !== serverSection[key];
     }
     if (!overrides.hasOwnProperty(key)) return false;
-    var ov2 = overrides[key];
-    var sv2 = server[key];
-    if (typeof ov2 === 'object' || typeof sv2 === 'object') {
-      return JSON.stringify(ov2) !== JSON.stringify(sv2);
-    }
-    return ov2 !== sv2;
+    return overrides[key] !== server[key];
   }
 
-  /** Count overridden fields in a section (only those that differ from server defaults) */
+  /** Count overridden fields in a section */
   function _countOverrides(section) {
     var overrides = _getOverrides();
     if (!overrides[section] || typeof overrides[section] !== 'object') return 0;
-    var count = 0;
-    var keys = Object.keys(overrides[section]);
-    for (var i = 0; i < keys.length; i++) {
-      if (_isOverridden(section, keys[i])) count++;
-    }
-    return count;
+    return Object.keys(overrides[section]).length;
   }
 
   function _overrideDot(section, key) {
@@ -1020,12 +962,11 @@
         '<span class="cust-hex">' + val + '</span></div>';
     }
 
-    var fallbackTC = (typeof window !== 'undefined' && window.TYPE_COLORS) || {};
     var tc = eff.typeColors || {};
     var stc = server.typeColors || {};
     var typeRows = '';
     for (var tkey in TYPE_LABELS) {
-      var tval = tc[tkey] || fallbackTC[tkey] || '#000000';
+      var tval = tc[tkey] || (window.TYPE_COLORS && window.TYPE_COLORS[tkey]) || '#000000';
       typeRows += '<div class="cust-color-row">' +
         '<div><label>' + (TYPE_EMOJI[tkey] || '') + ' ' + TYPE_LABELS[tkey] + _overrideDot('typeColors', tkey) + '</label>' +
         '<div class="cust-hint">' + (TYPE_HINTS[tkey] || '') + '</div></div>' +
@@ -1172,59 +1113,6 @@
     _bindEvents(container);
   }
 
-  /** Remove phantom overrides that match server defaults on startup */
-  function _cleanPhantomOverrides() {
-    var delta = readOverrides();
-    if (!delta || Object.keys(delta).length === 0) return;
-    var server = _serverDefaults || {};
-    var changed = false;
-
-    // Clean object sections
-    for (var i = 0; i < OBJECT_SECTIONS.length; i++) {
-      var sec = OBJECT_SECTIONS[i];
-      if (!delta[sec] || typeof delta[sec] !== 'object') continue;
-      var serverSec = server[sec];
-      // If server has no defaults for this section, only remove values that
-      // are clearly phantom (empty arrays/objects or undefined equivalents).
-      // Non-trivial values may be legitimate user choices.
-      if (!serverSec) {
-        var dKeys = Object.keys(delta[sec]);
-        for (var di = 0; di < dKeys.length; di++) {
-          var dv = delta[sec][dKeys[di]];
-          var isPhantom = (Array.isArray(dv) && dv.length === 0) ||
-            (typeof dv === 'object' && dv !== null && !Array.isArray(dv) && Object.keys(dv).length === 0);
-          if (isPhantom) { delete delta[sec][dKeys[di]]; changed = true; }
-        }
-        if (Object.keys(delta[sec]).length === 0) { delete delta[sec]; changed = true; }
-        continue;
-      }
-      var keys = Object.keys(delta[sec]);
-      for (var j = 0; j < keys.length; j++) {
-        var k = keys[j];
-        var ov = delta[sec][k];
-        var sv = serverSec[k];
-        var match = false;
-        if (typeof ov === 'object' || typeof sv === 'object') {
-          match = JSON.stringify(ov) === JSON.stringify(sv);
-        } else {
-          match = ov === sv;
-        }
-        if (match) { delete delta[sec][k]; changed = true; }
-      }
-      if (Object.keys(delta[sec]).length === 0) { delete delta[sec]; changed = true; }
-    }
-
-    // Clean scalar sections
-    for (var si = 0; si < SCALAR_SECTIONS.length; si++) {
-      var sk = SCALAR_SECTIONS[si];
-      if (delta.hasOwnProperty(sk) && delta[sk] === server[sk]) {
-        delete delta[sk]; changed = true;
-      }
-    }
-
-    if (changed) writeOverrides(delta);
-  }
-
   function _refreshPanel() {
     if (!_panelEl) return;
     var inner = _panelEl.querySelector('.cust-inner');
@@ -1586,7 +1474,6 @@
     // Watch dark/light mode toggle and re-apply
     new MutationObserver(function () {
       _runPipeline();
-      if (_panelEl && !_panelEl.classList.contains('hidden')) _refreshPanel();
     }).observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
   });
 
@@ -1599,12 +1486,8 @@
   window._customizerV2 = {
     init: function (serverConfig) {
       _serverDefaults = serverConfig || {};
-      _cleanPhantomOverrides();
       _runPipeline();
-      _initDone = true;
     },
-    /** True after init() has been called with server config and pipeline has run */
-    get initDone() { return _initDone; },
     readOverrides: readOverrides,
     writeOverrides: writeOverrides,
     computeEffective: computeEffective,

public/home.js

@@ -511,35 +511,27 @@
   function timeSinceMs(d) { return Date.now() - d.getTime(); }
 
   function checklist(homeCfg) {
-    var html = '';
-    // Render steps (getting started guide)
-    if (homeCfg?.steps?.length) {
-      html += homeCfg.steps.map(s => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(s.emoji || '')} ${escapeHtml(s.title)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(s.description) : escapeHtml(s.description)}</div></div>`).join('');
+    if (homeCfg?.checklist) {
+      return homeCfg.checklist.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(i.question)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(i.answer) : escapeHtml(i.answer)}</div></div>`).join('');
     }
-    // Render FAQ/checklist (additional Q&A)
-    if (homeCfg?.checklist?.length) {
-      if (html) html += '<h3 style="margin:24px 0 12px;font-size:16px">❓ FAQ</h3>';
-      html += homeCfg.checklist.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(i.question)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(i.answer) : escapeHtml(i.answer)}</div></div>`).join('');
+    if (homeCfg?.steps) {
+      return homeCfg.steps.map(s => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(s.emoji || '')} ${escapeHtml(s.title)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(s.description) : escapeHtml(s.description)}</div></div>`).join('');
     }
-    // Fallback: Bay Area defaults when no config at all
-    if (!html) {
-      const items = [
-        { q: '💬 First: Join the Bay Area MeshCore Discord',
-          a: '<p>The community Discord is the best place to get help and find local mesh enthusiasts.</p><p><a href="https://discord.gg/q59JzsYTst" target="_blank" rel="noopener" style="color:var(--accent);font-weight:600">Join the Discord ↗</a></p><p>Start with <strong>#intro-to-meshcore</strong> — it has detailed setup instructions.</p>' },
-        { q: '🔵 Step 1: Connect via Bluetooth',
-          a: '<p>Flash <strong>BLE companion</strong> firmware from <a href="https://flasher.meshcore.co.uk/" target="_blank" rel="noopener" style="color:var(--accent)">MeshCore Flasher</a>.</p><ul><li>Screenless devices: default PIN <code>123456</code></li><li>Screen devices: random PIN shown on display</li><li>If pairing fails: forget device, reboot, re-pair</li></ul>' },
-        { q: '📻 Step 2: Set the right frequency preset',
-          a: '<p><strong>US Recommended:</strong></p><div style="margin:8px 0;padding:8px 12px;background:var(--surface-1);border-radius:6px;font-family:var(--mono);font-size:.85rem">910.525 MHz · BW 62.5 kHz · SF 7 · CR 5</div><p>Select <strong>"US Recommended"</strong> in the app or flasher.</p>' },
-        { q: '📡 Step 3: Advertise yourself',
-          a: '<p>Tap the signal icon → <strong>Flood</strong> to broadcast your node to the mesh. Companions only advert when you trigger it manually.</p>' },
-        { q: '🔁 Step 4: Check "Heard N repeats"',
-          a: '<ul><li><strong>"Sent"</strong> = transmitted, no confirmation</li><li><strong>"Heard 0 repeats"</strong> = no repeater picked it up</li><li><strong>"Heard 1+ repeats"</strong> = you\'re on the mesh!</li></ul>' },
-        { q: '📍 Repeaters near you?',
-          a: '<p><a href="#/map" style="color:var(--accent)">Check the network map</a> to see active repeaters.</p>' }
-      ];
-      html = items.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${i.q}</div><div class="checklist-a">${i.a}</div></div>`).join('');
-    }
-    return html;
+    const items = [
+      { q: '💬 First: Join the Bay Area MeshCore Discord',
+        a: '<p>The community Discord is the best place to get help and find local mesh enthusiasts.</p><p><a href="https://discord.gg/q59JzsYTst" target="_blank" rel="noopener" style="color:var(--accent);font-weight:600">Join the Discord ↗</a></p><p>Start with <strong>#intro-to-meshcore</strong> — it has detailed setup instructions.</p>' },
+      { q: '🔵 Step 1: Connect via Bluetooth',
+        a: '<p>Flash <strong>BLE companion</strong> firmware from <a href="https://flasher.meshcore.co.uk/" target="_blank" rel="noopener" style="color:var(--accent)">MeshCore Flasher</a>.</p><ul><li>Screenless devices: default PIN <code>123456</code></li><li>Screen devices: random PIN shown on display</li><li>If pairing fails: forget device, reboot, re-pair</li></ul>' },
+      { q: '📻 Step 2: Set the right frequency preset',
+        a: '<p><strong>US Recommended:</strong></p><div style="margin:8px 0;padding:8px 12px;background:var(--surface-1);border-radius:6px;font-family:var(--mono);font-size:.85rem">910.525 MHz · BW 62.5 kHz · SF 7 · CR 5</div><p>Select <strong>"US Recommended"</strong> in the app or flasher.</p>' },
+      { q: '📡 Step 3: Advertise yourself',
+        a: '<p>Tap the signal icon → <strong>Flood</strong> to broadcast your node to the mesh. Companions only advert when you trigger it manually.</p>' },
+      { q: '🔁 Step 4: Check "Heard N repeats"',
+        a: '<ul><li><strong>"Sent"</strong> = transmitted, no confirmation</li><li><strong>"Heard 0 repeats"</strong> = no repeater picked it up</li><li><strong>"Heard 1+ repeats"</strong> = you\'re on the mesh!</li></ul>' },
+      { q: '📍 Repeaters near you?',
+        a: '<p><a href="#/map" style="color:var(--accent)">Check the network map</a> to see active repeaters.</p>' }
+    ];
+    return items.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${i.q}</div><div class="checklist-a">${i.a}</div></div>`).join('');
   }
 
   registerPage('home', { init, destroy });

public/map.js

@@ -15,8 +15,6 @@
   let wsHandler = null;
   let heatLayer = null;
   let geoFilterLayer = null;
-  let affinityLayer = null;
-  let affinityData = null;
   let userHasMoved = false;
   let controlsCollapsed = false;
 
@@ -114,7 +112,6 @@
             <label for="mcNeighbors"><input type="checkbox" id="mcNeighbors"> Show direct neighbors</label>
             <div id="mcNeighborRef" style="display:none;font-size:11px;color:var(--text-muted);margin-top:2px;padding-left:20px;">Ref: <span id="mcNeighborRefName">—</span></div>
             <div id="mcNeighborHint" style="display:none;font-size:11px;color:var(--text-muted);margin-top:2px;padding-left:20px;">Click a node marker to set the reference node</div>
-            <label id="mcAffinityDebugLabel" for="mcAffinityDebug" style="display:none"><input type="checkbox" id="mcAffinityDebug"> 🔍 Affinity Debug</label>
           </fieldset>
           <fieldset class="mc-section">
             <legend class="mc-label">Last Heard</legend>
@@ -228,22 +225,6 @@
       renderMarkers();
     });
 
-    // Affinity Debug overlay toggle — shown only when debugAffinity config is on or localStorage override
-    (function initAffinityDebug() {
-      var label = document.getElementById('mcAffinityDebugLabel');
-      var show = (window.CLIENT_CONFIG && window.CLIENT_CONFIG.debugAffinity) || localStorage.getItem('meshcore-affinity-debug') === 'true';
-      if (show && label) label.style.display = '';
-      var cb = document.getElementById('mcAffinityDebug');
-      if (!cb) return;
-      cb.addEventListener('change', function (e) {
-        if (e.target.checked) {
-          loadAffinityDebugOverlay();
-        } else {
-          clearAffinityOverlay();
-        }
-      });
-    })();
-
     // Hash Labels toggle
     const hashLabelEl = document.getElementById('mcHashLabels');
     if (hashLabelEl) {
@@ -807,15 +788,7 @@
     if (cb) cb.checked = true;
     renderMarkers();
   }
-  // Event delegation for Show Neighbors links (avoids inline onclick / global function timing issues)
-  document.addEventListener('click', function(e) {
-    var link = e.target.closest('[data-show-neighbors]');
-    if (link) {
-      e.preventDefault();
-      selectReferenceNode(link.dataset.pubkey, link.dataset.name);
-    }
-  });
-  // Expose for testing
+  // Expose for popup onclick and testing
   window._mapSelectRefNode = selectReferenceNode;
   window._mapGetNeighborPubkeys = function() { return neighborPubkeys ? Array.from(neighborPubkeys) : []; };
 
@@ -846,7 +819,7 @@
         </dl>
         <div style="margin-top:8px;clear:both;">
           <a href="#/nodes/${node.public_key}" style="color:var(--accent);font-size:12px;">View Node →</a>
-          ${node.public_key ? ` · <a href="#" data-show-neighbors data-pubkey="${escapeHtml(node.public_key)}" data-name="${escapeHtml(node.name || 'Unknown')}" style="color:var(--accent);font-size:12px;">Show Neighbors</a>` : ''}
+          ${node.public_key ? ` · <a href="#" onclick="event.preventDefault();window._mapSelectRefNode('${safeEsc(node.public_key.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/</g, '\\x3c'))}','${safeEsc((node.name || 'Unknown').replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/</g, '\\x3c'))}')" style="color:var(--accent);font-size:12px;">Show Neighbors</a>` : ''}
         </div>
       </div>`;
   }
@@ -913,95 +886,6 @@
 
   let _themeRefreshHandler = null;
 
-  // ─── Affinity Debug Overlay ────────────────────────────────────────────────
-  function clearAffinityOverlay() {
-    if (affinityLayer) { map.removeLayer(affinityLayer); affinityLayer = null; }
-    affinityData = null;
-  }
-
-  function loadAffinityDebugOverlay() {
-    clearAffinityOverlay();
-    // Fetch debug data — requires API key stored in localStorage
-    var apiKey = localStorage.getItem('meshcore-api-key') || '';
-    fetch('/api/debug/affinity', { headers: { 'X-API-Key': apiKey } })
-      .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
-      .then(function (data) {
-        affinityData = data;
-        renderAffinityOverlay();
-      })
-      .catch(function (err) {
-        console.warn('[affinity-debug] Failed to load:', err);
-        var cb = document.getElementById('mcAffinityDebug');
-        if (cb) cb.checked = false;
-      });
-  }
-
-  function renderAffinityOverlay() {
-    if (!affinityData || !map) return;
-    clearAffinityOverlay();
-    affinityLayer = L.layerGroup();
-
-    // Build node position lookup from current markers
-    var nodePos = {};
-    nodes.forEach(function (n) {
-      if (n.latitude && n.longitude) {
-        nodePos[n.public_key.toLowerCase()] = [n.latitude, n.longitude];
-      }
-    });
-
-    var edges = affinityData.edges || [];
-    edges.forEach(function (e) {
-      var posA = nodePos[e.nodeA];
-      var posB = e.nodeB ? nodePos[e.nodeB] : null;
-
-      if (!posA) return;
-
-      // Unresolved prefix — show ❓ marker near nodeA
-      if (e.unresolved || (!posB && e.ambiguous)) {
-        if (posA) {
-          var marker = L.marker([posA[0] + 0.001, posA[1] + 0.001], {
-            icon: L.divIcon({ html: '❓', className: 'affinity-unresolved', iconSize: [20, 20] })
-          });
-          marker.bindPopup('<b>Unresolved prefix:</b> ' + escapeHtml(e.prefix) + '<br>Observations: ' + e.weight);
-          affinityLayer.addLayer(marker);
-        }
-        return;
-      }
-
-      if (!posB) return;
-
-      // Color by confidence
-      var color = '#ef4444'; // red — ambiguous
-      var score = e.score || 0;
-      if (score >= 0.6) color = '#22c55e'; // green — high
-      else if (score >= 0.3) color = '#eab308'; // yellow — medium
-
-      // Thickness proportional to weight, clamped 1-5px
-      var weight = Math.max(1, Math.min(5, Math.round((e.weight || 1) / 20)));
-
-      var line = L.polyline([posA, posB], {
-        color: color,
-        weight: weight,
-        opacity: 0.7,
-        dashArray: e.ambiguous ? '5,5' : null
-      });
-
-      var popup = '<b>Affinity Edge</b><br>' +
-        escapeHtml(e.nodeAName || e.nodeA.substring(0, 8)) + ' ↔ ' + escapeHtml(e.nodeBName || e.nodeB.substring(0, 8)) + '<br>' +
-        'Observations: ' + e.observationCount + '<br>' +
-        'Score: ' + (e.score || 0).toFixed(3) + '<br>' +
-        'Last seen: ' + escapeHtml(e.lastSeen) + '<br>' +
-        'Observers: ' + escapeHtml((e.observers || []).join(', '));
-      if (e.avgSnr != null) popup += '<br>Avg SNR: ' + e.avgSnr.toFixed(1) + ' dB';
-
-      line.bindPopup(popup);
-      affinityLayer.addLayer(line);
-    });
-
-    affinityLayer.addTo(map);
-  }
-  // ─── End Affinity Debug ────────────────────────────────────────────────────
-
   registerPage('map', {
     init: function(app, routeParam) {
       _themeRefreshHandler = () => { if (markerLayer) renderMarkers(); };

public/nodes.js

@@ -175,114 +175,6 @@
     return `<div style="font-size:11px;color:var(--text-muted);margin:-2px 0 6px;padding:6px 10px;background:var(--surface-2);border-radius:4px;border-left:3px solid var(--status-yellow)">Adverts show varying hash sizes (<strong>${sizes.join('-byte, ')}-byte</strong>). This is a <a href="https://github.com/meshcore-dev/MeshCore/commit/fcfdc5f" target="_blank" style="color:var(--accent)">known bug</a> where automatic adverts ignore the configured multibyte path setting. Fixed in <a href="https://github.com/meshcore-dev/MeshCore/releases/tag/repeater-v1.14.1" target="_blank" style="color:var(--accent)">repeater v1.14.1</a>.</div>`;
   }
 
-  // ─── Neighbor section helpers ───────────────────────────────────────────────
-
-  // Cache: pubkey → { data, ts }
-  var _neighborCache = {};
-
-  function getConfidenceIndicator(entry) {
-    if (entry.ambiguous) return { icon: '⚠️', label: 'AMBIGUOUS', cls: 'confidence-ambiguous' };
-    if (entry.count <= 1) return { icon: '🔴', label: 'LOW', cls: 'confidence-low' };
-    if (entry.score >= 0.5 && entry.count >= 3) return { icon: '🟢', label: 'HIGH', cls: 'confidence-high' };
-    return { icon: '🟡', label: 'MEDIUM', cls: 'confidence-medium' };
-  }
-
-  function renderNeighborRows(neighbors, limit) {
-    var sorted = neighbors.slice().sort(function(a, b) {
-      return (b.score || b.affinity || 0) - (a.score || a.affinity || 0);
-    });
-    var items = limit ? sorted.slice(0, limit) : sorted;
-    return items.map(function(nb) {
-      var conf = getConfidenceIndicator(nb);
-      var name = nb.name || (nb.prefix + '… (unknown)');
-      var nameHtml = nb.pubkey
-        ? '<a href="#/nodes/' + encodeURIComponent(nb.pubkey) + '">' + escapeHtml(name) + '</a>'
-        : '<span class="text-muted">' + escapeHtml(name) + '</span>';
-      var role = nb.role || '—';
-      var roleBadge = nb.role
-        ? '<span class="badge" style="background:' + (ROLE_COLORS[nb.role] || 'var(--surface-2)') + ';color:#fff;font-size:10px">' + escapeHtml(role) + '</span>'
-        : '<span class="text-muted">—</span>';
-      var scoreTitle = 'Observations: ' + nb.count;
-      if (nb.avg_snr != null) scoreTitle += ' · Avg SNR: ' + Number(nb.avg_snr).toFixed(1) + ' dB';
-      var showOnMap = nb.pubkey
-        ? ' <button class="btn-link neighbor-show-map" data-pubkey="' + escapeHtml(nb.pubkey) + '" style="font-size:11px;padding:1px 6px;white-space:nowrap">📍 Map</button>'
-        : '';
-      return '<tr>' +
-        '<td style="font-weight:600">' + nameHtml + '</td>' +
-        '<td>' + roleBadge + '</td>' +
-        '<td title="' + escapeHtml(scoreTitle) + '">' + Number(nb.score).toFixed(2) + '</td>' +
-        '<td>' + nb.count + '</td>' +
-        '<td>' + renderNodeTimestampHtml(nb.last_seen) + '</td>' +
-        '<td><span title="' + conf.label + '">' + conf.icon + '</span></td>' +
-        '<td style="text-align:right">' + showOnMap + '</td>' +
-        '</tr>';
-    }).join('');
-  }
-
-  function renderNeighborTable(neighbors, limit) {
-    return '<table class="data-table" style="font-size:12px">' +
-      '<thead><tr><th>Neighbor</th><th>Role</th><th>Score</th><th>Obs</th><th>Last Seen</th><th>Conf</th><th></th></tr></thead>' +
-      '<tbody>' + renderNeighborRows(neighbors, limit) + '</tbody></table>';
-  }
-
-  function fetchAndRenderNeighbors(pubkey, containerId, opts) {
-    opts = opts || {};
-    var limit = opts.limit || 0;
-    var headerSelector = opts.headerSelector;
-    var viewAllPubkey = opts.viewAllPubkey;
-
-    // Always set spinner as initial DOM state (synchronous) so tests can observe it
-    var spinnerEl = document.getElementById(containerId);
-    if (spinnerEl) spinnerEl.innerHTML = '<div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading neighbors…</div>';
-
-    // Check cache
-    var cached = _neighborCache[pubkey];
-    if (cached && (Date.now() - cached.ts < 300000)) { // 5 min cache
-      renderNeighborData(cached.data, containerId, limit, headerSelector, viewAllPubkey);
-      return;
-    }
-
-    api('/nodes/' + encodeURIComponent(pubkey) + '/neighbors', { ttl: CLIENT_TTL.nodeDetail }).then(function(data) {
-      _neighborCache[pubkey] = { data: data, ts: Date.now() };
-      renderNeighborData(data, containerId, limit, headerSelector, viewAllPubkey);
-    }).catch(function() {
-      var el = document.getElementById(containerId);
-      if (el) el.innerHTML = '<div class="text-muted" style="padding:8px">Could not load neighbor data</div>';
-    });
-  }
-
-  function renderNeighborData(data, containerId, limit, headerSelector, viewAllPubkey) {
-    var el = document.getElementById(containerId);
-    if (!el) return;
-    if (!data || !data.neighbors || !data.neighbors.length) {
-      el.innerHTML = '<div class="text-muted" style="padding:8px">No neighbor data available yet. Neighbor relationships are built from observed packet paths over time.</div>';
-      if (headerSelector) {
-        var h = document.querySelector(headerSelector);
-        if (h) h.textContent = 'Neighbors (0)';
-      }
-      return;
-    }
-    if (headerSelector) {
-      var h = document.querySelector(headerSelector);
-      if (h) h.textContent = 'Neighbors (' + data.neighbors.length + ')';
-    }
-    var html = renderNeighborTable(data.neighbors, limit);
-    if (limit && data.neighbors.length > limit && viewAllPubkey) {
-      html += '<div style="margin-top:6px;text-align:right"><a href="#/nodes/' + encodeURIComponent(viewAllPubkey) + '?section=node-neighbors" style="font-size:12px">View all ' + data.neighbors.length + ' neighbors →</a></div>';
-    }
-    el.innerHTML = html;
-
-    // Wire up "Show on Map" buttons via event delegation
-    el.addEventListener('click', function(e) {
-      var btn = e.target.closest('.neighbor-show-map');
-      if (!btn) return;
-      var pk = btn.getAttribute('data-pubkey');
-      if (pk) location.hash = '#/map?node=' + encodeURIComponent(pk);
-    });
-  }
-
-  // ─── End neighbor helpers ─────────────────────────────────────────────────
-
   let directNode = null; // set when navigating directly to #/nodes/:pubkey
 
   let regionChangeHandler = null;
@@ -455,18 +347,6 @@
           </table>
         </div>` : ''}
 
-        <div class="node-full-card" id="node-neighbors">
-          <h4 id="fullNeighborsHeader">Neighbors</h4>
-          <div id="fullNeighborsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading neighbors…</div></div>
-        </div>
-
-        <div class="node-full-card" id="node-affinity-debug" style="display:none">
-          <h4 style="cursor:pointer" onclick="this.parentElement.querySelector('.affinity-debug-body').style.display=this.parentElement.querySelector('.affinity-debug-body').style.display==='none'?'block':'none'; this.querySelector('.toggle-icon').textContent=this.parentElement.querySelector('.affinity-debug-body').style.display==='none'?'▶':'▼'"><span class="toggle-icon">▶</span> 🔍 Affinity Debug</h4>
-          <div class="affinity-debug-body" style="display:none">
-            <div id="affinityDebugContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading debug data…</div></div>
-          </div>
-        </div>
-
         <div class="node-full-card" id="fullPathsSection">
           <h4>Paths Through This Node</h4>
           <div id="fullPathsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading paths…</div></div>
@@ -547,103 +427,6 @@
         } catch {}
       }
 
-      // Fetch neighbors for this node (full-screen view)
-      fetchAndRenderNeighbors(n.public_key, 'fullNeighborsContent', {
-        headerSelector: '#fullNeighborsHeader'
-      });
-
-      // Affinity debug panel — show if debugAffinity is enabled
-      (function loadAffinityDebug() {
-        var show = (window.CLIENT_CONFIG && window.CLIENT_CONFIG.debugAffinity) || localStorage.getItem('meshcore-affinity-debug') === 'true';
-        var panel = document.getElementById('node-affinity-debug');
-        if (!show || !panel) return;
-        panel.style.display = '';
-        var apiKey = localStorage.getItem('meshcore-api-key') || '';
-        fetch('/api/debug/affinity?node=' + encodeURIComponent(n.public_key), { headers: { 'X-API-Key': apiKey } })
-          .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
-          .then(function (data) {
-            var el = document.getElementById('affinityDebugContent');
-            if (!el) return;
-            var html = '';
-
-            // Edges table
-            if (data.edges && data.edges.length) {
-              html += '<h5 style="margin:8px 0 4px">Neighbor Edges (' + data.edges.length + ')</h5>';
-              html += '<table class="mini-table" style="width:100%;font-size:12px"><thead><tr><th>Neighbor</th><th>Score</th><th>Count</th><th>Last Seen</th><th>Observers</th><th>Status</th></tr></thead><tbody>';
-              data.edges.forEach(function (e) {
-                var neighbor = e.nodeBName || e.nodeAName || (e.nodeB || e.nodeA || '').substring(0, 8);
-                if (e.nodeA.toLowerCase() === n.public_key.toLowerCase()) {
-                  neighbor = e.nodeBName || (e.nodeB || e.prefix || '?').substring(0, 8);
-                } else {
-                  neighbor = e.nodeAName || (e.nodeA || '').substring(0, 8);
-                }
-                var status = e.ambiguous ? (e.unresolved ? '❓ Unresolved' : '⚠️ Ambiguous') : (e.resolved ? '✅ Auto-resolved' : '✅ Resolved');
-                html += '<tr><td>' + escapeHtml(neighbor) + '</td><td>' + (e.score || 0).toFixed(3) + '</td><td>' + e.weight + '</td><td>' + (e.lastSeen || '').substring(0, 10) + '</td><td>' + (e.observers || []).length + '</td><td>' + status + '</td></tr>';
-              });
-              html += '</tbody></table>';
-            } else {
-              html += '<div class="text-muted" style="padding:8px">No affinity edges for this node</div>';
-            }
-
-            // Resolutions
-            if (data.resolutions && data.resolutions.length) {
-              html += '<h5 style="margin:12px 0 4px">Prefix Resolutions (' + data.resolutions.length + ')</h5>';
-              data.resolutions.forEach(function (r) {
-                html += '<div style="border:1px solid var(--border);border-radius:4px;padding:8px;margin-bottom:6px;font-size:12px">';
-                html += '<b>Prefix: ' + escapeHtml(r.prefix) + '</b> → ';
-                if (r.method === 'auto-resolved') {
-                  html += '<span style="color:var(--status-green)">✅ ' + escapeHtml(r.chosenName || r.chosen || '?') + '</span>';
-                  html += ' (Jaccard=' + r.chosenJaccard.toFixed(2) + ', ratio=' + ((isFinite(r.ratio) && r.ratio < 100) ? r.ratio.toFixed(1) + '×' : '∞') + ')';
-                } else {
-                  html += '<span style="color:var(--status-yellow)">⚠️ Ambiguous</span>';
-                  if (r.ratio) html += ' (ratio=' + r.ratio.toFixed(1) + '×, threshold=' + r.thresholdApplied + '×)';
-                }
-                // Show disambiguation tier used (M4 resolveWithContext)
-                if (r.tier) {
-                  var tierLabels = {
-                    'neighbor_affinity': '🏘️ Affinity',
-                    'geo_proximity': '🌍 Geo',
-                    'gps_preference': '📍 GPS',
-                    'first_match': '🎲 Naive',
-                    'unique_prefix': '✓ Unique',
-                    'no_match': '∅ None'
-                  };
-                  html += ' <span style="font-size:11px;opacity:0.8">[tier: ' + (tierLabels[r.tier] || escapeHtml(r.tier)) + ']</span>';
-                }
-                // Candidates table
-                if (r.candidates && r.candidates.length) {
-                  html += '<div style="margin-top:4px"><table class="mini-table" style="width:100%;font-size:11px"><thead><tr><th>Candidate</th><th>Jaccard</th><th>Count</th></tr></thead><tbody>';
-                  r.candidates.forEach(function (c) {
-                    var highlight = r.chosen && c.pubkey === r.chosen ? ' style="background:var(--status-green-bg,rgba(34,197,94,0.1))"' : '';
-                    html += '<tr' + highlight + '><td>' + escapeHtml(c.name || c.pubkey.substring(0, 8)) + '</td><td>' + c.jaccard.toFixed(3) + '</td><td>' + c.score + '</td></tr>';
-                  });
-                  html += '</tbody></table></div>';
-                }
-                html += '</div>';
-              });
-            }
-
-            // Stats summary
-            if (data.stats) {
-              html += '<h5 style="margin:12px 0 4px">Graph Stats</h5>';
-              html += '<div style="font-size:12px;line-height:1.6">';
-              html += 'Total edges: ' + data.stats.totalEdges + '<br>';
-              html += 'Total nodes: ' + data.stats.totalNodes + '<br>';
-              html += 'Resolved: ' + data.stats.resolvedCount + ' | Ambiguous: ' + data.stats.ambiguousCount + ' | Unresolved: ' + data.stats.unresolvedCount + '<br>';
-              html += 'Avg confidence: ' + (data.stats.avgConfidence || 0).toFixed(3) + '<br>';
-              html += 'Cold-start coverage: ' + (data.stats.coldStartCoverage || 0).toFixed(1) + '%<br>';
-              html += 'Cache age: ' + (data.stats.cacheAge || 'N/A') + ' | Last rebuild: ' + (data.stats.lastRebuild || 'N/A');
-              html += '</div>';
-            }
-
-            el.innerHTML = html;
-          })
-          .catch(function (err) {
-            var el = document.getElementById('affinityDebugContent');
-            if (el) el.innerHTML = '<div class="text-muted" style="padding:8px">Failed to load debug data: ' + escapeHtml(err.message) + '</div>';
-          });
-      })();
-
       // Fetch paths through this node (full-screen view)
       api('/nodes/' + encodeURIComponent(n.public_key) + '/paths', { ttl: CLIENT_TTL.nodeDetail }).then(pathData => {
         const el = document.getElementById('fullPathsContent');
@@ -1036,11 +819,6 @@
           </div>
         </div>` : ''}
 
-        <div class="node-detail-section" id="panelNeighborsSection">
-          <h4 id="panelNeighborsHeader">Neighbors</h4>
-          <div id="panelNeighborsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading neighbors…</div></div>
-        </div>
-
         <div class="node-detail-section" id="pathsSection">
           <h4>Paths Through This Node</h4>
           <div id="pathsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading paths…</div></div>
@@ -1111,13 +889,6 @@
       } catch {}
     }
 
-    // Fetch neighbors for this node (condensed panel — top 5)
-    fetchAndRenderNeighbors(n.public_key, 'panelNeighborsContent', {
-      limit: 5,
-      headerSelector: '#panelNeighborsHeader',
-      viewAllPubkey: n.public_key
-    });
-
     // Fetch paths through this node
     api('/nodes/' + encodeURIComponent(n.public_key) + '/paths', { ttl: CLIENT_TTL.nodeDetail }).then(pathData => {
       const el = document.getElementById('pathsContent');

public/style.css

@@ -630,15 +630,6 @@ button.ch-item.selected { background: var(--selected-bg); }
   background: var(--card-bg); border: 1px solid var(--border);
   border-radius: 8px; padding: 12px; margin-bottom: 8px;
 }
-/* Bug 7 fix: neighbor table text inherits accent color — force readable text */
-.node-detail-section .data-table td,
-.node-full-card .data-table td {
-  color: var(--text);
-}
-.node-detail-section .data-table td a,
-.node-full-card .data-table td a {
-  color: var(--accent);
-}
 .node-detail-section h4 {
   font-size: 12px; text-transform: uppercase; letter-spacing: .5px;
   color: var(--text-muted); margin-bottom: 8px; padding-bottom: 4px;
@@ -1942,12 +1933,3 @@ tr[data-hops]:hover { background: rgba(59,130,246,0.1); }
   .compare-select { min-width: auto; width: 100%; }
   .compare-summary { grid-template-columns: 1fr; }
 }
-
-/* Neighbor graph canvas focus indicator for keyboard navigation */
-#ngCanvas:focus {
-  outline: 2px solid var(--link-color, #60a5fa);
-  outline-offset: 2px;
-}
-#ngCanvas:focus:not(:focus-visible) {
-  outline: none;
-}

test-customizer-v2.js

@@ -403,115 +403,6 @@ test('returns true when server has no default for overridden key', () => {
   assert.strictEqual(api.isOverridden('theme', 'accent'), true);
 });
 
-// ── Bug #518 Fixes ──
-
-test('phantom overrides cleaned on init — matching scalars removed', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { theme: { accent: '#4a9eff', border: '#e2e5ea' }, typeColors: { ADVERT: '#22c55e' } };
-  ls.setItem('cs-theme-overrides', JSON.stringify({ theme: { accent: '#4a9eff' }, typeColors: { ADVERT: '#22c55e' } }));
-  api.init(server);
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.ok(!delta.theme, 'phantom theme override should be cleaned');
-  assert.ok(!delta.typeColors, 'phantom typeColors override should be cleaned');
-});
-
-test('phantom overrides cleaned on init — matching arrays removed', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { home: { steps: [{ emoji: '📡', title: 'Go', description: 'Do it' }] } };
-  ls.setItem('cs-theme-overrides', JSON.stringify({ home: { steps: [{ emoji: '📡', title: 'Go', description: 'Do it' }] } }));
-  api.init(server);
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.ok(!delta.home, 'phantom home array override should be cleaned');
-});
-
-test('real overrides preserved after init cleanup', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { theme: { accent: '#4a9eff' } };
-  ls.setItem('cs-theme-overrides', JSON.stringify({ theme: { accent: '#ff0000' } }));
-  api.init(server);
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides'));
-  assert.strictEqual(delta.theme.accent, '#ff0000');
-});
-
-test('isOverridden handles array comparison via JSON.stringify', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { home: { steps: [{ emoji: '📡', title: 'Go', description: 'Do' }] } };
-  ls.setItem('cs-theme-overrides', JSON.stringify({ home: { steps: [{ emoji: '📡', title: 'Go', description: 'Do' }] } }));
-  api.init(server);
-  assert.strictEqual(api.isOverridden('home', 'steps'), false, 'matching array should not be overridden');
-});
-
-test('isOverridden returns true for differing arrays', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { home: { steps: [{ emoji: '📡', title: 'Go', description: 'Do' }] } };
-  ls.setItem('cs-theme-overrides', JSON.stringify({ home: { steps: [{ emoji: '🚀', title: 'New', description: 'Changed' }] } }));
-  api.init(server);
-  assert.strictEqual(api.isOverridden('home', 'steps'), true, 'differing array should be overridden');
-});
-
-test('setOverride prunes value matching server default', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { theme: { accent: '#4a9eff' } };
-  api.init(server);
-  api.setOverride('theme', 'accent', '#4a9eff');
-  // debounce fires synchronously in sandbox
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.ok(!delta.theme || !delta.theme.accent, 'matching value should be pruned after setOverride');
-});
-
-// ── Fix #2: _cleanPhantomOverrides when server has no section ──
-
-test('phantom overrides cleaned when server has NO home section', () => {
-  const { api, ls } = loadCustomizer();
-  // Server has theme but NO home — the common deployment case
-  const server = { theme: { accent: '#4a9eff' } };
-  ls.setItem('cs-theme-overrides', JSON.stringify({ home: { checklist: [], steps: [] } }));
-  api.init(server);
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.ok(!delta.home, 'phantom home override should be removed when server has no home section');
-});
-
-test('phantom overrides cleaned when server section is undefined — empty arrays removed', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { theme: { accent: '#4a9eff' }, nodeColors: { repeater: '#dc2626' } };
-  // timestamps has actual values (not phantom), home has empty arrays (phantom)
-  ls.setItem('cs-theme-overrides', JSON.stringify({
-    timestamps: { defaultMode: 'ago', timezone: 'local' },
-    home: { checklist: [], steps: [] }
-  }));
-  api.init(server);
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.ok(!delta.home, 'phantom home with empty arrays should be removed');
-  // timestamps has non-empty values — preserved even without server section
-  assert.ok(delta.timestamps, 'timestamps with actual values should be preserved');
-  assert.strictEqual(delta.timestamps.defaultMode, 'ago');
-});
-
-// ── Fix #4: setOverride with value matching server default is NOT stored ──
-
-test('setOverride with value matching server default is not stored', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { theme: { accent: '#4a9eff', border: '#e2e5ea' } };
-  api.init(server);
-  // Set override to same value as server default
-  api.setOverride('theme', 'accent', '#4a9eff');
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.ok(!delta.theme || !delta.theme.accent, 'value matching server default should not be stored');
-});
-
-test('existing user overrides are NOT pruned by setOverride on other keys', () => {
-  const { api, ls } = loadCustomizer();
-  const server = { theme: { accent: '#4a9eff', border: '#e2e5ea' } };
-  // User previously chose a custom accent (different from server default)
-  ls.setItem('cs-theme-overrides', JSON.stringify({ theme: { accent: '#ff0000' } }));
-  api.init(server);
-  // Now user changes border — accent should be preserved
-  api.setOverride('theme', 'border', '#00ff00');
-  const delta = JSON.parse(ls.getItem('cs-theme-overrides') || '{}');
-  assert.strictEqual(delta.theme.accent, '#ff0000', 'pre-existing custom override should be preserved');
-  assert.strictEqual(delta.theme.border, '#00ff00', 'new non-matching override should be stored');
-});
-
 // ── Summary ──
 console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`);
 process.exit(failed > 0 ? 1 : 0);

test-e2e-playwright.js

@@ -550,7 +550,7 @@ async function run() {
     await page.goto(`${BASE}/#/analytics`, { waitUntil: 'domcontentloaded' });
     await page.waitForSelector('#analyticsTabs');
     const tabs = await page.$$('#analyticsTabs .tab-btn');
-    assert(tabs.length >= 10, `Expected >=10 analytics tabs, got ${tabs.length}`);
+    assert(tabs.length >= 8, `Expected >=8 analytics tabs, got ${tabs.length}`);
     // Overview tab should be active by default and show stat cards
     await page.waitForSelector('#analyticsContent .stat-card', { timeout: 8000 });
     const cards = await page.$$('#analyticsContent .stat-card');
@@ -624,53 +624,6 @@ async function run() {
     assert(content.length > 10, 'Distance tab should render content');
   });
 
-  await test('Analytics Neighbor Graph tab renders canvas and stats', async () => {
-    await page.click('[data-tab="neighbor-graph"]');
-    await page.waitForSelector('#ngCanvas', { timeout: 8000 });
-    const hasCanvas = await page.$('#ngCanvas');
-    assert(hasCanvas, 'Neighbor Graph tab should have a canvas element');
-    const hasStats = await page.$$eval('#ngStats .stat-card', els => els.length);
-    assert(hasStats >= 3, `Neighbor Graph stats should have >=3 cards, got ${hasStats}`);
-    // Verify filters exist
-    const hasSlider = await page.$('#ngMinScore');
-    assert(hasSlider, 'Should have min score slider');
-    const hasConfidence = await page.$('#ngConfidence');
-    assert(hasConfidence, 'Should have confidence filter');
-  });
-
-  await test('Analytics Neighbor Graph filter changes update stats', async () => {
-    // Capture edge count before filter
-    const edgesBefore = await page.$eval('#ngStats', el => {
-      const cards = el.querySelectorAll('.stat-card');
-      for (const c of cards) {
-        if (c.textContent.toLowerCase().includes('edge')) {
-          const m = c.textContent.match(/\d+/);
-          if (m) return parseInt(m[0], 10);
-        }
-      }
-      return -1;
-    });
-    // Set min score slider to high value to reduce edges
-    await page.$eval('#ngMinScore', el => { el.value = 90; el.dispatchEvent(new Event('input')); });
-    await page.waitForTimeout(300);
-    const edgesAfter = await page.$eval('#ngStats', el => {
-      const cards = el.querySelectorAll('.stat-card');
-      for (const c of cards) {
-        if (c.textContent.toLowerCase().includes('edge')) {
-          const m = c.textContent.match(/\d+/);
-          if (m) return parseInt(m[0], 10);
-        }
-      }
-      return -1;
-    });
-    assert(edgesBefore >= 0, 'Should find edge count in stats before filter');
-    assert(edgesAfter >= 0, 'Should find edge count in stats after filter');
-    assert(edgesAfter <= edgesBefore, `Raising min score should reduce (or keep) edge count: ${edgesBefore} → ${edgesAfter}`);
-    // Reset slider
-    await page.$eval('#ngMinScore', el => { el.value = 0; el.dispatchEvent(new Event('input')); });
-    await page.waitForTimeout(200);
-  });
-
   // --- Group: Compare page ---
 
   await test('Compare page loads with observer dropdowns', async () => {
@@ -1067,29 +1020,20 @@ async function run() {
   await test('Customizer v2: setOverride persists and applies CSS', async () => {
     await page.goto(BASE, { waitUntil: 'domcontentloaded' });
     await page.waitForSelector('nav, .navbar, .nav, [class*="nav"]');
-    // Force light mode — CI headless browsers may default to dark mode,
-    // and in dark mode themeDark.accent overwrites theme.accent in applyCSS
-    await page.evaluate(() => {
-      localStorage.setItem('meshcore-theme', 'light');
-      document.documentElement.setAttribute('data-theme', 'light');
-    });
     // Clear any existing overrides
     await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
-    // Wait for init() to complete (server config fetch + full pipeline) before
-    // setting override, so _runPipeline from init doesn't overwrite our value.
-    await page.waitForFunction(() => {
-      return window._customizerV2 && window._customizerV2.initDone;
-    }, { timeout: 5000 });
     // Set an override via the API
     const result = await page.evaluate(() => {
+      if (!window._customizerV2) return { error: 'customizerV2 not loaded' };
       window._customizerV2.setOverride('theme', 'accent', '#ff0000');
-      // Wait for debounce (300ms) + buffer
+      // Wait for debounce
       return new Promise(resolve => setTimeout(() => {
         const stored = JSON.parse(localStorage.getItem('cs-theme-overrides') || '{}');
         const cssVal = getComputedStyle(document.documentElement).getPropertyValue('--accent').trim();
         resolve({ stored, cssVal });
       }, 500));
     });
+    assert(!result.error, result.error || '');
     assert(result.stored.theme && result.stored.theme.accent === '#ff0000',
       'Override not persisted to localStorage');
     assert(result.cssVal === '#ff0000',
@@ -1101,17 +1045,9 @@ async function run() {
   await test('Customizer v2: clearOverride resets to server default', async () => {
     await page.goto(BASE, { waitUntil: 'domcontentloaded' });
     await page.waitForSelector('nav, .navbar, .nav, [class*="nav"]');
-    // Force light mode for consistent CSS testing
-    await page.evaluate(() => {
-      localStorage.setItem('meshcore-theme', 'light');
-      document.documentElement.setAttribute('data-theme', 'light');
-    });
-    // Wait for init() to complete so _serverDefaults is populated
-    await page.waitForFunction(() => {
-      return window._customizerV2 && window._customizerV2.initDone;
-    }, { timeout: 5000 });
     const result = await page.evaluate(() => {
-      // Set the server default accent
+      if (!window._customizerV2) return { error: 'customizerV2 not loaded' };
+      // Get the server default accent
       window._customizerV2.setOverride('theme', 'accent', '#ff0000');
       return new Promise(resolve => setTimeout(() => {
         window._customizerV2.clearOverride('theme', 'accent');
@@ -1120,6 +1056,7 @@ async function run() {
         resolve({ hasAccent });
       }, 500));
     });
+    assert(!result.error, result.error || '');
     assert(!result.hasAccent, 'accent should be removed from overrides after clearOverride');
     await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
   });
@@ -1324,6 +1261,7 @@ async function run() {
     await page.evaluate(() => localStorage.removeItem('cs-theme-overrides'));
   });
 
+  // --- Group: Show Neighbors (#484 fix) ---
 
   await test('Show Neighbors populates neighborPubkeys from affinity API', async () => {
     const testPubkey = 'aabbccdd11223344556677889900aabbccddeeff00112233445566778899001122';
@@ -1467,111 +1405,6 @@ async function run() {
     await page.unroute(`**/api/nodes/${testPubkey}/neighbors*`);
     await page.unroute(`**/api/nodes/${testPubkey}/paths*`);
   });
-  // ─── Neighbor section tests ───────────────────────────────────────────────
-
-  await test('Node detail: neighbors section exists with correct columns', async () => {
-    // Navigate to a node detail page (use the first node in the list)
-    await page.goto(BASE + '/#/nodes');
-    await page.waitForSelector('#nodesBody tr[data-key]', { timeout: 10000 });
-    // Get the first node's pubkey from the row's data-key attribute
-    const pubkey = await page.$eval('#nodesBody tr[data-key]', el => el.dataset.key);
-    await page.goto(BASE + '/#/nodes/' + pubkey);
-    await page.waitForSelector('#node-neighbors', { timeout: 10000 });
-    // Check the section exists
-    const header = await page.$eval('#fullNeighborsHeader', el => el.textContent);
-    assert(header.startsWith('Neighbors'), 'Header should start with "Neighbors", got: ' + header);
-    // Wait for content to load (either table or empty state)
-    await page.waitForFunction(() => {
-      const el = document.getElementById('fullNeighborsContent');
-      return el && !el.innerHTML.includes('spinner');
-    }, { timeout: 10000 });
-    const hasTable = await page.$('#fullNeighborsContent .data-table');
-    if (hasTable) {
-      // Check columns
-      const headers = await page.$$eval('#fullNeighborsContent thead th', ths => ths.map(t => t.textContent));
-      assert(headers.includes('Neighbor'), 'Should have Neighbor column');
-      assert(headers.includes('Role'), 'Should have Role column');
-      assert(headers.includes('Score'), 'Should have Score column');
-      assert(headers.includes('Obs'), 'Should have Obs column');
-      assert(headers.includes('Last Seen'), 'Should have Last Seen column');
-      assert(headers.includes('Conf'), 'Should have Conf column');
-    } else {
-      // Empty state
-      const text = await page.$eval('#fullNeighborsContent', el => el.textContent);
-      assert(text.includes('No neighbor data') || text.includes('Could not load'), 'Should show empty or error state');
-    }
-  });
-
-
-  // ─── End neighbor section tests ───────────────────────────────────────────
-
-  // ─── Affinity debug overlay tests ─────────────────────────────────────────
-
-  await test('Map: affinity debug checkbox exists in DOM', async () => {
-    await page.goto(BASE + '/#/map');
-    await page.waitForSelector('#mapControls', { timeout: 5000 });
-    const checkbox = await page.$('#mcAffinityDebug');
-    assert(checkbox !== null, 'Affinity debug checkbox should exist in DOM');
-  });
-
-  await test('Map: affinity debug checkbox toggles without crash', async () => {
-    await page.goto(BASE + '/#/map');
-    await page.waitForSelector('#mapControls', { timeout: 5000 });
-    // Make the checkbox visible by setting localStorage
-    await page.evaluate(() => localStorage.setItem('meshcore-affinity-debug', 'true'));
-    await page.reload();
-    await page.waitForSelector('#mapControls', { timeout: 5000 });
-    const label = await page.$('#mcAffinityDebugLabel');
-    if (label) {
-      const display = await label.evaluate(el => getComputedStyle(el).display);
-      // When debugAffinity or localStorage is set, label should be visible
-      // Just verify toggling doesn't crash
-      const cb = await page.$('#mcAffinityDebug');
-      if (cb) {
-        await cb.click();
-        // Wait a bit for fetch to complete (or fail gracefully)
-        await page.waitForTimeout(500);
-        await cb.click();
-        await page.waitForTimeout(200);
-      }
-    }
-    // Clean up
-    await page.evaluate(() => localStorage.removeItem('meshcore-affinity-debug'));
-    assert(true, 'Toggle did not crash');
-  });
-
-  await test('Node detail: affinity debug section expandable', async () => {
-    await page.goto(BASE + '/#/nodes');
-    await page.waitForSelector('#nodesBody tr[data-key]', { timeout: 10000 });
-    // Enable debug mode
-    await page.evaluate(() => localStorage.setItem('meshcore-affinity-debug', 'true'));
-    // Click first node to go to detail
-    const nodeLink = await page.$('a[href*="/nodes/"]');
-    if (nodeLink) {
-      await nodeLink.click();
-      await page.waitForTimeout(1000);
-      const debugPanel = await page.$('#node-affinity-debug');
-      if (debugPanel) {
-        const display = await debugPanel.evaluate(el => el.style.display);
-        // Panel should be visible when debug is enabled
-        const header = await debugPanel.$('h4');
-        if (header) {
-          // Click to expand
-          await header.click();
-          await page.waitForTimeout(300);
-          const body = await debugPanel.$('.affinity-debug-body');
-          if (body) {
-            const bodyDisplay = await body.evaluate(el => el.style.display);
-            assert(bodyDisplay !== 'none', 'Debug body should be expanded after click');
-          }
-        }
-      }
-    }
-    await page.evaluate(() => localStorage.removeItem('meshcore-affinity-debug'));
-    assert(true, 'Debug panel expansion works');
-  });
-
-  // ─── End affinity debug tests ─────────────────────────────────────────────
 
   // Extract frontend coverage if instrumented server is running
   try {

test-frontend-helpers.js

@@ -1980,30 +1980,6 @@ console.log('\n=== customize-v2.js: core behavior ===');
     assert.strictEqual(effective.theme.navBg, '#222222');
   });
 
-  test('computeEffective provides home defaults when server home is null', () => {
-    const ctx = makeSandbox();
-    ctx.CustomEvent = function (type) { this.type = type; };
-    const v2 = loadCustomizeV2(ctx);
-    const server = { theme: { accent: '#111111' }, home: null };
-    const effective = v2.computeEffective(server, {});
-    assert.ok(effective.home, 'home should not be null');
-    assert.strictEqual(effective.home.heroTitle, 'CoreScope');
-    assert.ok(Array.isArray(effective.home.steps), 'steps should be an array');
-    assert.ok(effective.home.steps.length > 0, 'steps should not be empty');
-    assert.ok(Array.isArray(effective.home.footerLinks), 'footerLinks should be an array');
-  });
-
-  test('computeEffective merges user home overrides with defaults', () => {
-    const ctx = makeSandbox();
-    ctx.CustomEvent = function (type) { this.type = type; };
-    const v2 = loadCustomizeV2(ctx);
-    const server = { home: null };
-    const overrides = { home: { heroTitle: 'MyMesh' } };
-    const effective = v2.computeEffective(server, overrides);
-    assert.strictEqual(effective.home.heroTitle, 'MyMesh');
-    assert.ok(Array.isArray(effective.home.steps), 'steps should survive user override of heroTitle');
-  });
-
   test('isValidColor accepts hex, rgb, hsl, and named colors', () => {
     const ctx = makeSandbox();
     ctx.CustomEvent = function (type) { this.type = type; };
@@ -2044,6 +2020,24 @@ console.log('\n=== customize-v2.js: core behavior ===');
     assert.ok(src.includes("surface3: '--surface-3'"), 'surface3 must map to --surface-3');
     assert.ok(src.includes("sectionBg: '--section-bg'"), 'sectionBg must map to --section-bg');
   });
+
+  test('_renderNodes falls back to window.TYPE_COLORS when typeColors is empty (#514)', () => {
+    const ctx = makeSandbox();
+    ctx.CustomEvent = function (type) { this.type = type; };
+    ctx.TYPE_COLORS = { ADVERT: '#22c55e', GRP_TXT: '#3b82f6' };
+    ctx.window.TYPE_COLORS = ctx.TYPE_COLORS;
+    const v2 = loadCustomizeV2(ctx);
+    // computeEffective with empty typeColors should still allow fallback
+    const server = { typeColors: {} };
+    const effective = v2.computeEffective(server, {});
+    // When typeColors is empty, the render should fall back to TYPE_COLORS
+    // We test the logic directly: tc[key] || TYPE_COLORS[key] || '#000000'
+    const tc = effective.typeColors || {};
+    const advertColor = tc['ADVERT'] || (ctx.window.TYPE_COLORS && ctx.window.TYPE_COLORS['ADVERT']) || '#000000';
+    assert.strictEqual(advertColor, '#22c55e', 'ADVERT should fall back to TYPE_COLORS, not #000000');
+    const grpColor = tc['GRP_TXT'] || (ctx.window.TYPE_COLORS && ctx.window.TYPE_COLORS['GRP_TXT']) || '#000000';
+    assert.strictEqual(grpColor, '#3b82f6', 'GRP_TXT should fall back to TYPE_COLORS, not #000000');
+  });
 }
 
 // ===== APP.JS: home rehydration merge (mergeUserHomeConfig removed — dead code) =====