perf: cache the per-frame recomputation in the explorer render path (#655)

* fix: filter dashboard warning events server-side

The cluster dashboard listed every Event and dropped non-warnings client-side. Send fieldSelector type=Warning so the API server filters instead. Cuts per-tick decode work on busy clusters.

* perf: cache table layout and visible-items scans off the render hot path

RenderTable rescanned every item for hasUnion and category/separator
bookkeeping on each call even when TableLayoutCache already held the
rest of the layout, and visibleMiddleItems refiltered, rescored, and
recollapsed the full list on every render and several times per
keystroke. Both are now memoized behind the existing fingerprint/rev
invalidation.

Fixes two pre-existing gaps that would have made the new memo return
stale data: the cluster-color and read-only mutation paths wrote into
middleItems by index without bumping middleItemsRev.

Author: janosmiko

internal/app/app.go

@@ -388,9 +388,9 @@ type Model struct {
 	middleItemsRev uint64
 	// selectionRev is bumped on every change to selectedItems so the row
 	// cache invalidates and the selection marker on non-cursor rows updates.
-	selectionRev uint64
-
-	middleTableRenderer *ui.TableRenderer
+	selectionRev            uint64
+	middleItemsVisibleCache *visibleMiddleItemsCacheEntry
+	middleTableRenderer     *ui.TableRenderer
 
 	previewDebounceGen uint64
 

internal/app/cluster_color_overlay.go

@@ -241,6 +241,7 @@ func (m Model) applyClusterColorSelection() (Model, bool) {
 	for i := range m.middleItems {
 		if m.middleItems[i].Name == ctx {
 			m.middleItems[i].ClusterColor = newColor
+			m.middleItemsRev++
 			break
 		}
 	}

internal/app/cursor.go

@@ -559,10 +559,9 @@ func (m *Model) selectedItemsList() []model.Item {
 	return selected
 }
 
-// visibleMiddleItems returns the filtered subset of middleItems when a filter
-// is active, or all middleItems otherwise. At LevelResourceTypes, it also
-// applies collapsible group logic (accordion behavior).
-func (m *Model) visibleMiddleItems() []model.Item {
+// computeVisibleMiddleItems is the uncached body of visibleMiddleItems (see
+// cursor_visible_items_cache.go).
+func (m *Model) computeVisibleMiddleItems() []model.Item {
 	items := m.middleItems
 
 	// Apply text filter first.

internal/app/cursor_visible_items_bench_test.go

@@ -0,0 +1,50 @@
+package app
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/janosmiko/lfk/internal/model"
+)
+
+// BenchmarkVisibleMiddleItemsUnchanged simulates repeated render-loop calls
+// with the same filter/nav state each time, the case a memo should serve
+// from cache instead of re-filtering, re-scoring, and re-collapsing.
+func BenchmarkVisibleMiddleItemsUnchanged(b *testing.B) {
+	b.Run("filtered", func(b *testing.B) {
+		for _, n := range []int{1000, 5000} {
+			b.Run(fmt.Sprintf("items=%d", n), func(b *testing.B) {
+				m := newTestModel()
+				m.setMiddleItems(benchItems(n))
+				m.filterText = "row-1"
+				m.filterBroadMode = true
+				b.ReportAllocs()
+				b.ResetTimer()
+				for range b.N {
+					_ = m.visibleMiddleItems()
+				}
+			})
+		}
+	})
+
+	b.Run("resourceTypesCollapse", func(b *testing.B) {
+		for _, n := range []int{1000, 5000} {
+			b.Run(fmt.Sprintf("items=%d", n), func(b *testing.B) {
+				m := newTestModel()
+				m.nav.Level = model.LevelResourceTypes
+				items := benchItems(n)
+				categories := []string{"Workloads", "Networking", "Storage"}
+				for i := range items {
+					items[i].Category = categories[i%len(categories)]
+				}
+				m.setMiddleItems(items)
+				m.expandedGroup = "Workloads"
+				b.ReportAllocs()
+				b.ResetTimer()
+				for range b.N {
+					_ = m.visibleMiddleItems()
+				}
+			})
+		}
+	})
+}

internal/app/cursor_visible_items_cache.go

@@ -0,0 +1,59 @@
+package app
+
+import (
+	"unsafe"
+
+	"github.com/janosmiko/lfk/internal/model"
+)
+
+// visibleMiddleItemsKey is the memo key for computeVisibleMiddleItems: every
+// field that changes its output.
+type visibleMiddleItemsKey struct {
+	itemsPtr          uintptr
+	itemsLen          int
+	itemsRev          uint64
+	filterText        string
+	filterBroadMode   bool
+	navLevel          model.Level
+	allGroupsExpanded bool
+	expandedGroup     string
+}
+
+// middleItemsHeaderPtr backstops itemsRev the same way TableRenderer's
+// itemsPtr backstops middleRev, against a reassignment that skips setMiddleItems.
+func middleItemsHeaderPtr(items []model.Item) uintptr {
+	if len(items) == 0 {
+		return 0
+	}
+	return uintptr(unsafe.Pointer(&items[0]))
+}
+
+// visibleMiddleItemsCacheEntry must be replaced wholesale, never mutated in
+// place: a by-value Model copy shares this pointer.
+type visibleMiddleItemsCacheEntry struct {
+	key   visibleMiddleItemsKey
+	items []model.Item
+}
+
+// visibleMiddleItems returns the filtered subset of middleItems when a filter
+// is active, or all middleItems otherwise. At LevelResourceTypes, it also
+// applies collapsible group logic (accordion behavior). Memoized: callers
+// must not mutate the returned slice.
+func (m *Model) visibleMiddleItems() []model.Item {
+	key := visibleMiddleItemsKey{
+		itemsPtr:          middleItemsHeaderPtr(m.middleItems),
+		itemsLen:          len(m.middleItems),
+		itemsRev:          m.middleItemsRev,
+		filterText:        m.filterText,
+		filterBroadMode:   m.filterBroadMode,
+		navLevel:          m.nav.Level,
+		allGroupsExpanded: m.allGroupsExpanded,
+		expandedGroup:     m.expandedGroup,
+	}
+	if c := m.middleItemsVisibleCache; c != nil && c.key == key {
+		return c.items
+	}
+	items := m.computeVisibleMiddleItems()
+	m.middleItemsVisibleCache = &visibleMiddleItemsCacheEntry{key: key, items: items}
+	return items
+}

internal/app/cursor_visible_items_cache_test.go

@@ -0,0 +1,171 @@
+package app
+
+import (
+	"testing"
+	"unsafe"
+
+	"github.com/janosmiko/lfk/internal/model"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func visibleItemsTestModel() Model {
+	m := newTestModel()
+	m.setMiddleItems([]model.Item{
+		{Name: "alpha", Namespace: "ns1", Kind: "Pod"},
+		{Name: "beta", Namespace: "ns1", Kind: "Pod"},
+		{Name: "gamma", Namespace: "ns2", Kind: "Pod"},
+	})
+	return m
+}
+
+func sameBackingArray(a, b []model.Item) bool {
+	if len(a) == 0 || len(b) == 0 {
+		return len(a) == len(b)
+	}
+	return unsafe.SliceData(a) == unsafe.SliceData(b)
+}
+
+func TestVisibleMiddleItems_MemoReusesSliceWhenInputsUnchanged(t *testing.T) {
+	m := visibleItemsTestModel()
+
+	first := m.visibleMiddleItems()
+	second := m.visibleMiddleItems()
+
+	assert.True(t, sameBackingArray(first, second),
+		"repeated calls with unchanged filter/items/nav state must reuse the memoized slice")
+}
+
+func TestVisibleMiddleItems_InvalidatesOnItemsRevChange(t *testing.T) {
+	m := visibleItemsTestModel()
+	first := m.visibleMiddleItems()
+
+	m.setMiddleItems([]model.Item{{Name: "delta", Namespace: "ns3", Kind: "Pod"}})
+	second := m.visibleMiddleItems()
+
+	assert.False(t, sameBackingArray(first, second), "setMiddleItems must invalidate the memo")
+	require.Len(t, second, 1)
+	assert.Equal(t, "delta", second[0].Name)
+}
+
+func TestVisibleMiddleItems_InvalidatesOnFilterTextChange(t *testing.T) {
+	m := visibleItemsTestModel()
+	unfiltered := m.visibleMiddleItems()
+	require.Len(t, unfiltered, 3)
+
+	m.filterText = "beta"
+	filtered := m.visibleMiddleItems()
+
+	require.Len(t, filtered, 1)
+	assert.Equal(t, "beta", filtered[0].Name)
+}
+
+func TestVisibleMiddleItems_InvalidatesOnFilterBroadModeChange(t *testing.T) {
+	m := visibleItemsTestModel()
+	m.middleItems[0].Columns = []model.KeyValue{{Key: "label", Value: "special-tag"}}
+	m.setMiddleItems(m.middleItems)
+	m.filterText = "special-tag"
+
+	m.filterBroadMode = false
+	narrow := m.visibleMiddleItems()
+	assert.Empty(t, narrow, "name-only filter must not match a column value")
+
+	m.filterBroadMode = true
+	broad := m.visibleMiddleItems()
+	require.Len(t, broad, 1, "broad mode must invalidate the memo and rescan columns")
+}
+
+func TestVisibleMiddleItems_InvalidatesOnExpandedGroupChange(t *testing.T) {
+	m := newTestModel()
+	m.nav.Level = model.LevelResourceTypes
+	m.setMiddleItems([]model.Item{
+		{Name: "pods", Category: "Workloads"},
+		{Name: "deployments", Category: "Workloads"},
+		{Name: "services", Category: "Networking"},
+	})
+	m.expandedGroup = "Workloads"
+
+	withWorkloadsExpanded := m.visibleMiddleItems()
+	names := itemNames(withWorkloadsExpanded)
+	assert.Contains(t, names, "deployments")
+
+	m.expandedGroup = "Networking"
+	withNetworkingExpanded := m.visibleMiddleItems()
+	names = itemNames(withNetworkingExpanded)
+	assert.Contains(t, names, "services")
+	assert.NotContains(t, names, "deployments",
+		"changing expandedGroup must invalidate the memo and recollapse")
+}
+
+func TestVisibleMiddleItems_InvalidatesOnAllGroupsExpandedChange(t *testing.T) {
+	m := newTestModel()
+	m.nav.Level = model.LevelResourceTypes
+	m.setMiddleItems([]model.Item{
+		{Name: "pods", Category: "Workloads"},
+		{Name: "deployments", Category: "Workloads"},
+	})
+	m.expandedGroup = "Networking" // Workloads stays collapsed
+
+	collapsed := m.visibleMiddleItems()
+	assert.NotContains(t, itemNames(collapsed), "deployments")
+
+	m.allGroupsExpanded = true
+	expanded := m.visibleMiddleItems()
+	assert.Contains(t, itemNames(expanded), "deployments")
+}
+
+func TestVisibleMiddleItems_InvalidatesOnNavLevelChange(t *testing.T) {
+	m := newTestModel()
+	m.setMiddleItems([]model.Item{
+		{Name: "pods", Category: "Workloads"},
+		{Name: "deployments", Category: "Workloads"},
+	})
+	m.expandedGroup = "Networking"
+
+	m.nav.Level = model.LevelResources
+	uncollapsed := m.visibleMiddleItems()
+	assert.Len(t, uncollapsed, 2, "collapse logic only applies at LevelResourceTypes")
+
+	m.nav.Level = model.LevelResourceTypes
+	collapsed := m.visibleMiddleItems()
+	assert.NotContains(t, itemNames(collapsed), "deployments")
+}
+
+// These two sites mutate m.middleItems[i] by index instead of reassigning
+// the slice, so they must bump middleItemsRev themselves or the memo below
+// keeps a stale ClusterColor/ReadOnly value.
+func TestClusterColorOverlay_EnterApply_BumpsMiddleItemsRev(t *testing.T) {
+	m := newClusterPickerModel(t)
+	m.setMiddleItems(m.middleItems) // establish a non-zero baseline rev
+	before := m.middleItemsRev
+
+	ret, _ := m.handleKeyClusterColorPicker()
+	m = ret.(Model)
+	m.clusterColorOverlayCursor = 0
+
+	ret, _ = m.handleClusterColorOverlayKey(keyMsg("enter"))
+	result := ret.(Model)
+
+	assert.Greater(t, result.middleItemsRev, before,
+		"applying a cluster color must bump middleItemsRev so the visibleMiddleItems memo invalidates")
+}
+
+func TestHandleKeyReadOnlyToggle_AtClusterPicker_BumpsMiddleItemsRev(t *testing.T) {
+	m := Model{
+		nav:               model.NavigationState{Level: model.LevelClusters},
+		middleItems:       []model.Item{{Name: "prod"}, {Name: "dev"}},
+		cursors:           [5]int{1, 0, 0, 0, 0},
+		tabs:              []TabState{{}},
+		itemCache:         map[string][]model.Item{},
+		cacheFingerprints: map[string]string{},
+		width:             80, height: 40,
+	}
+	m.setMiddleItems(m.middleItems) // establish a non-zero baseline rev
+	before := m.middleItemsRev
+
+	ret, _ := m.handleKeyReadOnlyToggle()
+	result := ret.(Model)
+
+	assert.Greater(t, result.middleItemsRev, before,
+		"toggling read-only must bump middleItemsRev so the visibleMiddleItems memo invalidates")
+}

internal/app/readonly.go

@@ -269,6 +269,7 @@ func (m *Model) refreshContextReadOnlyMarkers() {
 	for i := range m.middleItems {
 		m.middleItems[i].ReadOnly = m.effectiveContextReadOnly(m.middleItems[i].Name)
 	}
+	m.middleItemsRev++
 	// Keep the cache aligned so back-navigation re-shows the fresh markers.
 	m.itemCache[m.navKey()] = m.middleItems
 }
@@ -364,6 +365,7 @@ func (m Model) handleKeyReadOnlyToggle() (tea.Model, tea.Cmd) {
 		for i := range m.middleItems {
 			if m.middleItems[i].Name == sel.Name {
 				m.middleItems[i].ReadOnly = newState
+				m.middleItemsRev++
 				break
 			}
 		}

internal/ui/explorer_highlight.go

@@ -25,6 +25,12 @@ type TableLayoutCache struct {
 	ContextW, NsW, ReadyW, RestartsW, AgeW, StatusW             int
 	AnyRecentRestart                                            bool
 	ExtraCols                                                   []extraColumn
+
+	HasUnion bool
+
+	HasCategories   bool
+	CategoryForItem []string
+	HasSepForItem   []bool
 }
 
 // ActiveSelectedStyle returns SelectedStyle or a nyan rainbow style if nyan