@skyhook-io/radar-app 1.16.2 → 1.16.3

package/src/components/timeline/TimelineList.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import { applyClientFilters } from '../../api/timelineSource'
 import type { TimelineEvent } from '../../types'
-import { listIncludesManaged } from './TimelineList'
+import { splitRoutineActivity } from './TimelineList'
 
+let clock = Date.parse('2024-01-01T00:00:00.000Z')
 function ev(over: Partial<TimelineEvent> & { id: string }): TimelineEvent {
+  clock += 1000
   return {
-    timestamp: '2024-01-01T00:00:00.000Z',
+    timestamp: new Date(clock).toISOString(),
     source: 'informer',
     kind: 'Deployment',
     namespace: 'ns-a',
@@ -15,42 +17,58 @@ function ev(over: Partial<TimelineEvent> & { id: string }): TimelineEvent {
   }
 }
 
-// Mirrors the host: the source filter runs first, then the UI keeps the selected kinds.
-function listRows(events: TimelineEvent[], kinds: string[]): string[] {
-  return applyClientFilters(events, { includeManaged: listIncludesManaged(false, kinds) })
-    .filter((e) => kinds.length === 0 || kinds.includes(e.kind))
-    .map((e) => e.id)
+const deploy = ev({ id: 'deploy', kind: 'Deployment' })
+const podStarted = ev({ id: 'pod-started', kind: 'Pod', source: 'k8s_event', eventType: 'Normal', reason: 'Started' })
+const podOom = ev({ id: 'pod-oom', kind: 'Pod', source: 'k8s_event', eventType: 'Warning', reason: 'OOMKilled' })
+const rsScaled = ev({ id: 'rs-scaled', kind: 'ReplicaSet' })
+const cronJobOk = ev({ id: 'cron-job-ok', kind: 'Job', owner: { kind: 'CronJob', name: 'nightly' }, healthState: 'healthy' })
+const cronJobFailed = ev({ id: 'cron-job-failed', kind: 'Job', owner: { kind: 'CronJob', name: 'nightly' }, healthState: 'unhealthy' })
+const standaloneJob = ev({ id: 'standalone-job', kind: 'Job' })
+const ALL = [deploy, podStarted, podOom, rsScaled, cronJobOk, cronJobFailed, standaloneJob]
+
+// Mirrors the host: one uncapped query through the source's client filters.
+function split(events: TimelineEvent[], kinds: string[], limit = 2000) {
+  return splitRoutineActivity(applyClientFilters(events, { kinds, includeManaged: true }), limit)
 }
+const ids = (rows: TimelineEvent[]) => rows.map((e) => e.id).sort()
+const oom = (id: string) => ev({ id, kind: 'Pod', source: 'k8s_event', eventType: 'Warning', reason: 'OOMKilled' })
+const started = (id: string) => ev({ id, kind: 'Pod', source: 'k8s_event', eventType: 'Normal', reason: 'Started' })
 
-describe('listIncludesManaged', () => {
-  it('includes managed rows when app-scoped or when any kind is selected', () => {
-    expect(listIncludesManaged(true, [])).toBe(true)
-    expect(listIncludesManaged(false, ['Pod'])).toBe(true)
-    expect(listIncludesManaged(false, ['Job'])).toBe(true)
+describe('splitRoutineActivity', () => {
+  it('keeps owner rows and child problems, holds routine child rows apart', () => {
+    const { withoutRoutine, routine } = split(ALL, [])
+    expect(ids(withoutRoutine)).toEqual(['cron-job-failed', 'deploy', 'pod-oom', 'standalone-job'])
+    expect(ids(routine)).toEqual(['cron-job-ok', 'pod-started', 'rs-scaled'])
   })
 
-  it('keeps hiding managed rows for the unfiltered list', () => {
-    expect(listIncludesManaged(false, [])).toBe(false)
-  })
-})
+  it('shows a picked kind\'s problems and holds its routine rows apart', () => {
+    const pods = split(ALL, ['Pod'])
+    expect(ids(pods.withoutRoutine)).toEqual(['pod-oom'])
+    expect(ids(pods.routine)).toEqual(['pod-started'])
 
-describe('timeline list rows', () => {
-  const events = [
-    ev({ id: 'dep', kind: 'Deployment' }),
-    ev({ id: 'pod', kind: 'Pod' }),
-    ev({ id: 'job', kind: 'Job' }),
-    ev({ id: 'cron-job', kind: 'Job', owner: { kind: 'CronJob', name: 'nightly' } }),
-  ]
+    const jobs = split(ALL, ['Job'])
+    expect(ids(jobs.withoutRoutine)).toEqual(['cron-job-failed', 'standalone-job'])
+    expect(ids(jobs.routine)).toEqual(['cron-job-ok'])
+  })
 
-  it('lists pod rows for a Pod selection', () => {
-    expect(listRows(events, ['Pod'])).toEqual(['pod'])
+  it('lists rows newest first', () => {
+    expect(split(ALL, []).withoutRoutine.map((e) => e.id)).toEqual(['standalone-job', 'cron-job-failed', 'pod-oom', 'deploy'])
   })
 
-  it('lists owned rows of an unmanaged kind for that kind', () => {
-    expect(listRows(events, ['Job']).sort()).toEqual(['cron-job', 'job'])
+  it('never lets owner rows crowd out child problems', () => {
+    const owners = [1, 2, 3].map((n) => ev({ id: `deploy-${n}`, kind: 'Deployment' }))
+    const { withoutRoutine, truncated } = split([oom('old-oom'), ...owners], [], 2)
+    expect(ids(withoutRoutine)).toEqual(['deploy-2', 'deploy-3', 'old-oom'])
+    expect(truncated).toBe(true)
   })
 
-  it('hides pod and owned rows when no kind is selected', () => {
-    expect(listRows(events, []).sort()).toEqual(['dep', 'job'])
+  it('only adds rows when routine activity is shown', () => {
+    const olderDeploy = ev({ id: 'older-deploy', kind: 'Deployment' })
+    const burst = [1, 2, 3].map((n) => started(`started-${n}`))
+    const { withoutRoutine, withRoutine, routine, routineTruncated } = split([olderDeploy, ...burst], [], 2)
+    expect(ids(withoutRoutine)).toEqual(['older-deploy'])
+    expect(ids(withRoutine)).toEqual(['older-deploy', 'started-2', 'started-3'])
+    expect(ids(routine)).toEqual(['started-2', 'started-3'])
+    expect(routineTruncated).toBe(true)
   })
 })

package/src/components/timeline/TimelineList.tsx

@@ -3,13 +3,16 @@ import {
   SEVERITY_TEXT,
   TimelineList as TimelineListUI,
   eventsForApplication,
+  isTimelineProblem,
   type ActivityTypeFilter,
   type ActivityFilterKey,
   type AppMembershipIndex,
   type TimeRange,
   type Topology,
 } from '@skyhook-io/k8s-ui'
+import type { TimelineEvent } from '../../types'
 import { useTimelineSource } from '../../context/TimelineSource'
+import { isManagedTimelineEvent } from '../../api/timelineSource'
 import { useHasLimitedAccess } from '../../contexts/CapabilitiesContext'
 import type { NavigateToResource } from '../../utils/navigation'
 import { AlertTriangle, RefreshCw } from 'lucide-react'
@@ -24,10 +27,33 @@ export type { ActivityTypeFilter, ActivityFilterKey }
 const LIST_FETCH_LIMIT = 2000
 const APP_SCOPED_FETCH_LIMIT = 10000
 
-// The source drops managed rows (Pod, ReplicaSet, Event, or any owned row) before
-// the kind filter runs, so an explicit kind selection must keep them or it lists nothing.
-export function listIncludesManaged(appScoped: boolean, kinds: string[]): boolean {
-  return appScoped || kinds.length > 0
+function isChildProblem(e: TimelineEvent): boolean {
+  return isManagedTimelineEvent(e) && isTimelineProblem(e)
+}
+
+const byNewest = (a: TimelineEvent, b: TimelineEvent) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+
+// Splits the list's rows into owner-level rows, problems on child resources,
+// and routine child activity, each newest first under its own `limit`. Separate
+// budgets keep the promises the toggle makes: a burst of owner rows can't crowd
+// out child problems, and showing routine activity only ever adds rows.
+export function splitRoutineActivity(allRows: TimelineEvent[], limit: number) {
+  const owners: TimelineEvent[] = []
+  const childProblems: TimelineEvent[] = []
+  const routine: TimelineEvent[] = []
+  for (const e of allRows) {
+    const bucket = !isManagedTimelineEvent(e) ? owners : isTimelineProblem(e) ? childProblems : routine
+    bucket.push(e)
+  }
+  const base = [...owners.slice(0, limit), ...childProblems.slice(0, limit)].sort(byNewest)
+  const shownRoutine = routine.slice(0, limit)
+  return {
+    withoutRoutine: base,
+    withRoutine: [...base, ...shownRoutine].sort(byNewest),
+    routine: shownRoutine,
+    truncated: owners.length > limit || childProblems.length > limit,
+    routineTruncated: routine.length > limit,
+  }
 }
 
 interface TimelineListProps {
@@ -39,6 +65,10 @@ interface TimelineListProps {
   initialTimeRange?: TimeRange
   showDeleted: boolean
   onShowDeletedChange: (showDeleted: boolean) => void
+  // Routine activity (normal steps of pods, replica sets and other child
+  // resources) is hidden unless the user opts in. Problems always show.
+  showRoutine: boolean
+  onShowRoutineChange: (showRoutine: boolean) => void
   // Shared filter state lifted to TimelineView so it survives the view switch.
   search: string
   onSearchChange: (value: string) => void
@@ -64,7 +94,7 @@ interface TimelineListProps {
   appScopeLoading?: boolean
 }
 
-export function TimelineList({ namespaces, onViewChange, currentView, onResourceClick, initialFilter, initialTimeRange, showDeleted, onShowDeletedChange, search, onSearchChange, activityFilter, onActivityFilterChange, kindFilter, onKindFilterChange, selectionWindow, onVisibleWindowChange, scrollToMs, focusedAppIndex, appScoped = false, topology, appScopeLoading = false }: TimelineListProps) {
+export function TimelineList({ namespaces, onViewChange, currentView, onResourceClick, initialFilter, initialTimeRange, showDeleted, onShowDeletedChange, showRoutine, onShowRoutineChange, search, onSearchChange, activityFilter, onActivityFilterChange, kindFilter, onKindFilterChange, selectionWindow, onVisibleWindowChange, scrollToMs, focusedAppIndex, appScoped = false, topology, appScopeLoading = false }: TimelineListProps) {
   const hasLimitedAccess = useHasLimitedAccess()
   const timelineSource = useTimelineSource()
   const [queryParams, setQueryParams] = useState<{ timeRange: TimeRange; kinds: string[] }>({
@@ -77,26 +107,36 @@ export function TimelineList({ namespaces, onViewChange, currentView, onResource
   }, [])
 
   const fetchLimit = appScoped ? APP_SCOPED_FETCH_LIMIT : LIST_FETCH_LIMIT
+  // The application-scoped list keeps every row: its app filter needs the pods.
+  const splitRows = !appScoped
+  // Uncapped when splitting: each part gets its own cap below. The rows come
+  // from the loaded ring, so this costs no extra fetch.
   const { data: fetchedEvents, isLoading, isError, error, refetch } = timelineSource.useEvents({
     namespaces,
     kinds: queryParams.kinds,
     timeRange: queryParams.timeRange,
     includeK8sEvents: true,
-    includeManaged: listIncludesManaged(appScoped, queryParams.kinds),
+    includeManaged: true,
     includeDeleted: showDeleted,
-    limit: fetchLimit,
+    limit: splitRows ? undefined : fetchLimit,
     fromMs: selectionWindow?.fromMs,
     toMs: selectionWindow?.toMs,
   })
+  const split = useMemo(
+    () => (splitRows && fetchedEvents ? splitRoutineActivity(fetchedEvents, fetchLimit) : undefined),
+    [splitRows, fetchedEvents, fetchLimit],
+  )
   const events = useMemo(() => {
-    const unscoped = fetchedEvents ?? []
+    const unscoped = split ? (showRoutine ? split.withRoutine : split.withoutRoutine) : fetchedEvents ?? []
     return appScoped
       ? focusedAppIndex
         ? eventsForApplication(unscoped, topology, focusedAppIndex)
         : []
       : unscoped
-  }, [appScoped, focusedAppIndex, topology, fetchedEvents])
-  const sourceTruncated = (fetchedEvents?.length ?? 0) >= fetchLimit
+  }, [appScoped, focusedAppIndex, topology, split, showRoutine, fetchedEvents])
+  const sourceTruncated = split
+    ? split.truncated || (showRoutine && split.routineTruncated)
+    : (fetchedEvents?.length ?? 0) >= fetchLimit
 
   // Full-screen error only when nothing is loaded; a failing background poll
   // with data on screen keeps rendering (data before error).
@@ -151,6 +191,10 @@ export function TimelineList({ namespaces, onViewChange, currentView, onResource
           hideRangeSelector={!!selectionWindow}
           showDeleted={showDeleted}
           onShowDeletedChange={onShowDeletedChange}
+          showRoutine={showRoutine}
+          onShowRoutineChange={split ? onShowRoutineChange : undefined}
+          routineEvents={split?.routine}
+          foldPerResource={split && !showRoutine ? isChildProblem : undefined}
           search={search}
           onSearchChange={onSearchChange}
           activityFilter={activityFilter}
@@ -163,7 +207,9 @@ export function TimelineList({ namespaces, onViewChange, currentView, onResource
           isTruncated={sourceTruncated}
           truncationMessage={appScoped && sourceTruncated
             ? `Showing application activity found in the newest ${fetchLimit.toLocaleString()} events in this range — narrow the query to see older activity`
-            : undefined}
+            : split && sourceTruncated
+              ? 'Some older activity in this range is not listed. Narrow the time range to see it.'
+              : undefined}
         />
       </div>
     </div>

package/src/components/timeline/TimelineView.tsx

@@ -125,6 +125,7 @@ export interface PersistedTimelineState {
   viewMode: TimelineViewMode
   mode: TimelineMode
   showDeleted: boolean
+  showRoutine: boolean
   pinnedOnly: boolean
   search: string
   activityFilter: ActivityFilterKey[]
@@ -237,6 +238,7 @@ export function writeTimelineParams(
   set('activity', s.activityFilter.length ? s.activityFilter.join(',') : null)
   set('kinds', s.kindFilter.length ? s.kindFilter.join(',') : null)
   set('deleted', s.showDeleted ? null : '0')
+  set('routine', s.showRoutine ? '1' : null)
   set('pinnedOnly', s.pinnedOnly ? '1' : null)
   set('q', s.search.length ? s.search : null)
   set('grouping', s.grouping !== DEFAULT_GROUPING ? s.grouping : null)
@@ -309,6 +311,7 @@ export function TimelineView({ namespaces, onResourceClick, initialViewMode, ini
   // and so the fetch can exclude deletes at the source rather than only hiding
   // them client-side.
   const [showDeleted, setShowDeleted] = useState(() => searchParams.get('deleted') !== '0')
+  const [showRoutine, setShowRoutine] = useState(() => searchParams.get('routine') === '1')
   // ?pinnedOnly=1 is inert without pins: honoring it with no stored pins would
   // arm a filter that hides everything. Gate the read on stored pins so the param
   // can never arm on its own — ordering-proof, independent of when the empty-pins
@@ -634,6 +637,8 @@ export function TimelineView({ namespaces, onResourceClick, initialViewMode, ini
     setMode((prev) => (timeModeEqual(prev, nextMode) ? prev : nextMode))
     const nextDeleted = sp.get('deleted') !== '0'
     setShowDeleted((prev) => (prev === nextDeleted ? prev : nextDeleted))
+    const nextRoutine = sp.get('routine') === '1'
+    setShowRoutine((prev) => (prev === nextRoutine ? prev : nextRoutine))
     // Same guard as the lazy init: the param can only arm the filter when pins
     // exist, so a mount that runs this after the empty-pins reset can't re-arm it.
     const nextPinnedOnly = sp.get('pinnedOnly') === '1' && pinnedLanes.length > 0
@@ -658,7 +663,7 @@ export function TimelineView({ namespaces, onResourceClick, initialViewMode, ini
     const current = searchParamsRef.current
     const target = writeTimelineParams(
       current,
-      { viewMode, mode, showDeleted, pinnedOnly, search: debouncedSearch, activityFilter, kindFilter, grouping, sort, selectedEventId },
+      { viewMode, mode, showDeleted, showRoutine, pinnedOnly, search: debouncedSearch, activityFilter, kindFilter, grouping, sort, selectedEventId },
       { isRetained: isRetained || isLocal, requiresNamespaceFilter: scopeRequiresNamespaceFilter },
     )
     const targetStr = target.toString()
@@ -672,7 +677,7 @@ export function TimelineView({ namespaces, onResourceClick, initialViewMode, ini
     const replace = !didMountUrlSyncRef.current || onlyHighFreqDiffer(currentStr, targetStr)
     didMountUrlSyncRef.current = true
     setSearchParamsRef.current(target, { replace })
-  }, [viewMode, mode, showDeleted, pinnedOnly, debouncedSearch, activityFilter, kindFilter, grouping, sort, selectedEventId, isRetained, isLocal, scopeRequiresNamespaceFilter])
+  }, [viewMode, mode, showDeleted, showRoutine, pinnedOnly, debouncedSearch, activityFilter, kindFilter, grouping, sort, selectedEventId, isRetained, isLocal, scopeRequiresNamespaceFilter])
 
   // Fetch all activity - zoom controls what's visible in the UI. This ring feeds
   // the swimlanes and the local strip's histogram, so it also runs in list mode
@@ -1032,6 +1037,8 @@ export function TimelineView({ namespaces, onResourceClick, initialViewMode, ini
       initialTimeRange={initialTimeRange}
       showDeleted={showDeleted}
       onShowDeletedChange={setShowDeleted}
+      showRoutine={showRoutine}
+      onShowRoutineChange={setShowRoutine}
       search={search}
       onSearchChange={setSearch}
       activityFilter={activityFilter}

package/src/components/timeline/TimelineView.urlparams.test.ts

@@ -75,6 +75,7 @@ function parseState(
     viewMode,
     mode: parseTimeMode(params, opts.isRetained, opts.maxRangeDays),
     showDeleted: params.get('deleted') !== '0',
+    showRoutine: params.get('routine') === '1',
     pinnedOnly: params.get('pinnedOnly') === '1' && opts.hasPins,
     search: params.get('q') ?? '',
     activityFilter,
@@ -89,6 +90,7 @@ const defaultState: PersistedTimelineState = {
   viewMode: DEFAULT_VIEW,
   mode: live(DEFAULT_LIVE_WIDTH_MS),
   showDeleted: true,
+  showRoutine: false,
   pinnedOnly: false,
   search: '',
   activityFilter: [],
@@ -158,6 +160,7 @@ describe('writeTimelineParams', () => {
       viewMode: 'list',
       mode: live(6 * 60 * 60 * 1000),
       showDeleted: false,
+      showRoutine: true,
       pinnedOnly: true,
       search: 'nginx',
       activityFilter: ['warnings', 'unhealthy'],
@@ -175,6 +178,7 @@ describe('writeTimelineParams', () => {
       ['kinds', 'Pod,Deployment'],
       ['pinnedOnly', '1'],
       ['q', 'nginx'],
+      ['routine', '1'],
       ['sort', 'recent'],
       ['view', 'list'],
       ['window', '21600000'],
@@ -265,6 +269,7 @@ describe('parse(write(state)) round-trip', () => {
       viewMode: 'list',
       mode: live(6 * 60 * 60 * 1000),
       showDeleted: false,
+      showRoutine: true,
       pinnedOnly: true,
       search: 'nginx',
       activityFilter: ['warnings', 'unhealthy'],
@@ -338,6 +343,7 @@ describe('onlyHighFreqDiffer (history replace vs push)', () => {
     expect(onlyHighFreqDiffer('', 'activity=warnings')).toBe(false)
     expect(onlyHighFreqDiffer('', 'kinds=Pod')).toBe(false)
     expect(onlyHighFreqDiffer('', 'deleted=0')).toBe(false)
+    expect(onlyHighFreqDiffer('', 'routine=1')).toBe(false)
     expect(onlyHighFreqDiffer('', 'pinnedOnly=1')).toBe(false)
   })
 

package/src/components/whats-new/WhatsNew.test.ts

@@ -1,50 +1,125 @@
 import { describe, expect, it } from 'vitest'
 import { Megaphone } from 'lucide-react'
-import { nextSeenVersion, whatsNewToShow } from './WhatsNew'
-import { latestReleaseNotesFor, releaseLine, RELEASE_NOTES, releaseNotesFor, type ReleaseNotes } from './releaseNotes'
+import { nextSeenVersion, whatsNewToOpen } from './WhatsNew'
+import {
+  AUTO_OPEN_SCORE,
+  composeReleaseNotes,
+  latestReleaseNotesFor,
+  MAX_CARDS,
+  MAX_LINES,
+  releaseLine,
+  RELEASE_NOTES,
+  releaseNotesFor,
+  unreadReleases,
+  type ReleaseNotes,
+} from './releaseNotes'
 import { compareVersions } from '../../utils/version'
 
-const entry = (version: string): ReleaseNotes => ({
+const highlight = (id: string, importance: number) => ({ id, icon: Megaphone, title: id, description: 'd', importance })
+
+const entry = (version: string, importances: number[] = [9, 9, 9], improvements: string[] = []): ReleaseNotes => ({
   version,
-  releaseUrl: 'https://github.com/skyhook-io/radar/releases',
-  highlights: [{ id: 'x', icon: Megaphone, title: 'X', description: 'Y' }],
-  improvements: [],
+  highlights: importances.map((importance, i) => highlight(`${version}-${i}`, importance)),
+  improvements,
 })
 
 const catalog = [entry('v1.15.0'), entry('v2.0.0')]
 
-const show = (current: string, lastSeen: string | null, prior = true) =>
-  whatsNewToShow(current, lastSeen, prior, catalog)?.version ?? null
+const unread = (current: string, lastSeen: string | null, prior = true, list = catalog) =>
+  unreadReleases(current, lastSeen, prior, list).map(n => n.version)
 
-describe('whatsNewToShow', () => {
-  it('shows when the notes are newer than the last version seen', () => {
-    expect(show('v2.0.0', 'v1.15.0')).toBe('v2.0.0')
-    expect(show('v2.0.0', 'v2.0.0')).toBeNull()
-    expect(show('2.0.0', 'v2.0.0')).toBeNull()
+describe('unreadReleases', () => {
+  it('lists the releases after the last one seen, newest first', () => {
+    expect(unread('v2.0.0', 'v1.14.0')).toEqual(['v2.0.0', 'v1.15.0'])
+    expect(unread('v2.0.0', 'v1.15.0')).toEqual(['v2.0.0'])
+    expect(unread('v2.0.0', 'v2.0.0')).toEqual([])
+    expect(unread('2.0.0', 'v2.0.0')).toEqual([])
   })
 
-  it('shows the newest earlier notes when the running release has none of its own', () => {
-    expect(show('v1.15.1', 'v1.14.1')).toBe('v1.15.0')
-    expect(show('v2.3.4', 'v1.15.2')).toBe('v2.0.0')
+  it('covers a patch of a release with notes, and nothing above the running version', () => {
+    expect(unread('v1.15.1', 'v1.14.1')).toEqual(['v1.15.0'])
+    expect(unread('v2.3.4', 'v1.15.2')).toEqual(['v2.0.0'])
   })
 
-  it('stays closed once a later release was seen, including after a downgrade', () => {
-    expect(show('v1.15.2', 'v1.15.1')).toBeNull()
-    expect(show('v1.15.0', 'v2.0.0')).toBeNull()
+  it('is empty once a later release was seen, including after a downgrade', () => {
+    expect(unread('v1.15.2', 'v1.15.1')).toEqual([])
+    expect(unread('v1.15.0', 'v2.0.0')).toEqual([])
   })
 
-  it('stays closed on a fresh install, and shows for installs that predate the seen record', () => {
-    expect(show('v2.0.0', null, false)).toBeNull()
-    expect(show('v2.0.0', null, true)).toBe('v2.0.0')
+  it('is empty on a fresh install, and covers everything for installs that predate the seen record', () => {
+    expect(unread('v2.0.0', null, false)).toEqual([])
+    expect(unread('v2.0.0', null, true)).toEqual(['v2.0.0', 'v1.15.0'])
   })
 
   it('treats a record that is not a version as an install with nothing seen', () => {
-    expect(show('v2.0.0', 'vdev', false)).toBe('v2.0.0')
+    expect(unread('v2.0.0', 'vdev', false)).toEqual(['v2.0.0', 'v1.15.0'])
+  })
+
+  it('is empty when no notes exist at or below the running version', () => {
+    expect(unread('v1.14.9', 'v1.14.0')).toEqual([])
+    expect(unread('dev', 'v1.14.1')).toEqual([])
+  })
+
+  it('orders by version whatever the catalog order', () => {
+    expect(unread('v2.0.0', null, true, [entry('v1.15.0'), entry('v2.0.0'), entry('v1.16.0')])).toEqual(['v2.0.0', 'v1.16.0', 'v1.15.0'])
+  })
+})
+
+describe('composeReleaseNotes', () => {
+  it('ranks highlights by importance, weighting older releases down', () => {
+    const notes = composeReleaseNotes([entry('v1.17.0', [6]), entry('v1.16.0', [9]), entry('v1.15.0', [10])])
+    expect(notes.highlights.map(h => [h.id, h.score])).toEqual([
+      ['v1.16.0-0', 6.75],
+      ['v1.17.0-0', 6],
+      ['v1.15.0-0', 5],
+    ])
+  })
+
+  it('breaks ties toward the newer release, then the authored order', () => {
+    const notes = composeReleaseNotes([entry('v1.16.0', [3, 6]), entry('v1.15.0', [8])])
+    expect(notes.highlights.map(h => h.id)).toEqual(['v1.16.0-1', 'v1.15.0-0', 'v1.16.0-0'])
+  })
+
+  it('keeps the authored order of a single release with equal importance', () => {
+    expect(composeReleaseNotes([entry('v1.16.0', [5, 5, 5])]).highlights.map(h => h.id)).toEqual(['v1.16.0-0', 'v1.16.0-1', 'v1.16.0-2'])
+  })
+
+  it('shows at most three releases and says when older ones were left out', () => {
+    const four = [entry('v1.18.0'), entry('v1.17.0'), entry('v1.16.0'), entry('v1.15.0')]
+    const notes = composeReleaseNotes(four)
+    expect(notes.versions).toEqual(['v1.18.0', 'v1.17.0', 'v1.16.0'])
+    expect(notes.complete).toBe(false)
+    expect(notes.highlights.some(h => h.version === 'v1.15.0')).toBe(false)
+    expect(composeReleaseNotes(four.slice(0, 3)).complete).toBe(true)
+  })
+
+  it('turns highlights past the cards into lines ahead of the improvements, within the line cap', () => {
+    const notes = composeReleaseNotes([
+      entry('v1.16.0', [7, 7, 7, 7, 7, 2], ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']),
+      entry('v1.15.0', [1], ['old']),
+    ])
+    expect(notes.highlights).toHaveLength(MAX_CARDS)
+    expect(notes.lines).toHaveLength(MAX_LINES)
+    expect(notes.lines.slice(0, 2).map(l => l.text)).toEqual(['v1.16.0-5', 'v1.15.0-0'])
+    expect(notes.lines.map(l => l.text)).not.toContain('old')
+  })
+
+  it('scores the dialog by the cards it shows', () => {
+    expect(composeReleaseNotes([entry('v1.16.0', [4, 4, 4, 4, 4, 10])]).score).toBe(10 + 4 * 4)
+  })
+})
+
+describe('whatsNewToOpen', () => {
+  it('opens when the unseen releases show enough, and not for a quiet release', () => {
+    const list = [entry('v1.15.0', [9, 8, 7, 7, 7]), entry('v1.16.0', [6, 5, 4])]
+    expect(whatsNewToOpen('v1.15.0', 'v1.14.1', true, list)?.score).toBe(38)
+    expect(whatsNewToOpen('v1.16.0', 'v1.15.0', true, list)).toBeNull()
+    expect(whatsNewToOpen('v1.16.0', 'v1.14.1', true, list)?.score).toBeGreaterThanOrEqual(AUTO_OPEN_SCORE)
   })
 
-  it('stays closed when no notes exist at or below the running version', () => {
-    expect(show('v1.14.9', 'v1.14.0')).toBeNull()
-    expect(show('dev', 'v1.14.1')).toBeNull()
+  it('stays closed when nothing is unseen', () => {
+    expect(whatsNewToOpen('v2.0.0', 'v2.0.0', true, catalog)).toBeNull()
+    expect(whatsNewToOpen('v2.0.0', null, false, catalog)).toBeNull()
   })
 })
 
@@ -91,13 +166,17 @@ describe('the shipped catalog', () => {
     expect(new Set(versions).size).toBe(versions.length)
     for (const notes of RELEASE_NOTES) {
       expect(notes.version, notes.version).toMatch(/^v\d+\.\d+\.\d+$/)
-      expect(notes.highlights.length, `${notes.version} needs a lead highlight`).toBeGreaterThan(0)
+      expect(notes.highlights.length, `${notes.version} needs a highlight`).toBeGreaterThan(0)
       expect(new Set(notes.highlights.map(h => h.id)).size, `${notes.version} highlight ids`).toBe(notes.highlights.length)
+      expect(new Set(notes.improvements).size, `${notes.version} improvements`).toBe(notes.improvements.length)
+      const top = notes.highlights.reduce((best, h) => (h.importance > best.importance ? h : best))
       for (const h of notes.highlights) {
+        expect(h.description.length, `${notes.version}/${h.id}: description fits a card`).toBeLessThanOrEqual(150)
+        if (h.leadDescription) expect(h.id, `${notes.version}/${h.id}: only the release's top highlight can lead`).toBe(top.id)
+        expect(Number.isInteger(h.importance) && h.importance >= 1 && h.importance <= 10, `${notes.version}/${h.id}: importance is 1-10`).toBe(true)
         expect(!!h.path === !!h.cta, `${notes.version}/${h.id}: path and cta go together`).toBe(true)
         if (h.path) expect(h.path, `${notes.version}/${h.id}`).toMatch(/^\//)
       }
-      expect(notes.releaseUrl, notes.version).toMatch(/^https:\/\//)
     }
   })
 })