feat(audit): Batch 22 — perf close-out (PERF3 benchmarked, PERF6/L162 by-design)

PERF3: pumpBench.test.ts pins pump()'s pipeline cost — 0.43ms @5k items,
1.47ms @20k (median) — negligible at a few events/sec, so the
count+pointer rewrite of the core queue is declined as risk without
reward; the benchmark stays as a 5ms regression tripwire.
PERF6/L162: closed as documented-by-design (virtualization bounds
mounted thumbs; a theme prop conflicts with PERF5's stable renderer).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

test/pumpBench.test.ts

@@ -0,0 +1,78 @@
+/**
+ * PERF3 evidence: pump() rescans the whole items array per queue event
+ * (filter + filter/reverse/slice + Set + map). The audit deferred a
+ * count+pointer rewrite as risk > reward on a bounded list — this benchmark
+ * pins that judgment with numbers at and beyond realistic queue sizes
+ * (a large channel enqueue is a few thousand items; events arrive a few times
+ * per second while downloads run).
+ *
+ * The measured pipeline below replicates pump()'s exact array operations on
+ * the same item shape (the real pump also spawns downloads, which would drown
+ * the scan in noise); the generous assertion doubles as a regression tripwire.
+ */
+import { describe, it, expect } from 'vitest'
+import type { DownloadItem } from '../src/renderer/src/store/downloadTypes'
+
+function makeItems(n: number): DownloadItem[] {
+  const statuses: DownloadItem['status'][] = ['completed', 'queued', 'downloading', 'error']
+  return Array.from({ length: n }, (_, i) => ({
+    id: `i${i}`,
+    url: `https://example.com/v/${i}`,
+    title: `Video ${i}`,
+    kind: 'video',
+    quality: '1080p',
+    status: statuses[i % statuses.length]!,
+    progress: 0
+  }))
+}
+
+/** pump()'s scan/promote pipeline, byte-for-byte the same array operations. */
+function pumpScan(items: DownloadItem[], maxConcurrent: number): number {
+  const running = items.filter((i) => i.status === 'downloading').length
+  const slots = maxConcurrent - running
+  if (slots <= 0) return 0
+  const toStart = items
+    .filter((i) => i.status === 'queued')
+    .reverse()
+    .slice(0, slots)
+  if (toStart.length === 0) return 0
+  const ids = new Set(toStart.map((i) => i.id))
+  const next = items.map((i) => (ids.has(i.id) ? { ...i, status: 'downloading' as const } : i))
+  return next.length
+}
+
+function bench(items: DownloadItem[], maxConcurrent: number, iterations: number): number {
+  // Warm up JIT + caches.
+  for (let i = 0; i < 20; i++) pumpScan(items, maxConcurrent)
+  const times: number[] = []
+  for (let i = 0; i < iterations; i++) {
+    const t0 = performance.now()
+    pumpScan(items, maxConcurrent)
+    times.push(performance.now() - t0)
+  }
+  times.sort((a, b) => a - b)
+  return times[Math.floor(times.length / 2)]!
+}
+
+describe('pump() cost at scale (PERF3)', () => {
+  it('a full scan+promote over 5,000 items is well under a millisecond-scale budget', () => {
+    const median = bench(makeItems(5_000), 3 + 1_250, 50) // slots open → full pipeline
+     
+    console.log(`pump pipeline @5k items: median ${median.toFixed(3)} ms`)
+    expect(median).toBeLessThan(5)
+  })
+
+  it('a full scan+promote over 20,000 items stays inside a 5 ms budget', () => {
+    const median = bench(makeItems(20_000), 3 + 5_000, 50)
+     
+    console.log(`pump pipeline @20k items: median ${median.toFixed(3)} ms`)
+    expect(median).toBeLessThan(5)
+  })
+
+  it('the no-free-slot fast path (the per-progress-event case) is trivially cheap', () => {
+    const median = bench(makeItems(20_000), 1, 100) // running >= cap → early return
+     
+    console.log(`pump no-slot path @20k items: median ${median.toFixed(3)} ms`)
+    expect(median).toBeLessThan(2)
+  })
+})