@skyhook-io/radar-app 1.16.3 → 1.17.1

package/src/components/cnpg/recovery/restoreOperation.ts

@@ -0,0 +1,56 @@
+import { registerCNPGOperationObserver, summarizeSteps, type CNPGObservation, type CNPGObserverResult, type CNPGOpStep, type CNPGTrackedOperation } from '../operations/model'
+import { isCNPGRecoveryJob } from './restoreModel'
+
+const HEALTHY_PHASE = 'Cluster in healthy state'
+const FAILING_PHASE = /unrecoverable|unable to|cannot|error|failed/i
+
+/**
+ * The tracker's view of a restore, from what the operation tracker already
+ * reads (the Cluster and its Jobs). The Cluster page's restore panel adds the
+ * recovery Pods and their init containers from /recovery.
+ */
+export function restoreOperationObserver(op: CNPGTrackedOperation, obs: CNPGObservation): CNPGObserverResult {
+  const c = obs.cluster
+  if (!c) {
+    return obs.now - op.startedAt < 60_000
+      ? { state: 'requested', detail: `Waiting for Cluster ${op.cluster} to appear`, progressKey: 'absent' }
+      : { state: 'unobservable', detail: `Cluster ${op.cluster} is not visible with your access` }
+  }
+  const phase: string | undefined = c.status?.phase
+  const desired: number | undefined = c.spec?.instances
+  const ready: number | undefined = c.status?.readyInstances
+  const jobs = obs.ha?.jobs.state === 'ok' ? obs.ha.jobs.items.filter(isCNPGRecoveryJob) : undefined
+  const failed = jobs?.find((j) => j.phase === 'failed')
+  if (failed) return { state: 'failed', detail: `Recovery Job ${failed.name} failed${failed.reason ? `: ${failed.reason}` : ''}` }
+  if (phase && phase !== HEALTHY_PHASE && FAILING_PHASE.test(phase)) {
+    return { state: 'failed', detail: phase + (c.status?.phaseReason ? `: ${c.status.phaseReason}` : '') }
+  }
+  // A ready restored primary proves recovery finished, whether or not the
+  // caller can read the recovery Job.
+  const primaryReady = typeof ready === 'number' && ready > 0
+  const jobDone = primaryReady ? true : jobs === undefined ? null : jobs.some((j) => j.phase === 'succeeded')
+  const steps: CNPGOpStep[] = [
+    { label: 'Base backup restored and WAL replayed (recovery Job finished)', done: jobDone },
+    { label: 'Restored primary ready', done: typeof ready === 'number' ? ready > 0 : false },
+    {
+      label: `All ${desired ?? ''} instances ready and the Cluster healthy`.replace('  ', ' '),
+      done: typeof ready === 'number' && typeof desired === 'number' ? ready >= desired && phase === HEALTHY_PHASE : false,
+    },
+  ]
+  const state = summarizeSteps(steps)
+  return {
+    state: state === 'unobservable' ? 'progressing' : state,
+    steps,
+    detail: [phase, typeof ready === 'number' ? `${ready}/${desired ?? '?'} ready` : null].filter(Boolean).join(' · '),
+    progressKey: `${phase ?? ''}|${ready ?? ''}|${jobs?.map((j) => j.phase).join(',') ?? '?'}`,
+  }
+}
+
+function registerRestoreObserver(): 'restore' {
+  registerCNPGOperationObserver('restore', restoreOperationObserver)
+  return 'restore'
+}
+
+// Registered through a used export, not a bare side-effect import: the package
+// declares itself side-effect free, so a bare import would be dropped.
+export const CNPG_RESTORE_OPERATION = registerRestoreObserver()

package/src/components/cnpg/refresh.test.ts

@@ -0,0 +1,38 @@
+import { QueryClient, QueryObserver } from '@tanstack/react-query'
+import { expect, it, vi } from 'vitest'
+import { refetchCNPGDetail } from './refresh'
+
+it('refreshes active reads for the object and namespace and waits for them', async () => {
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  let finish!: (value: number) => void
+  const pending = new Promise<number>((resolve) => { finish = resolve })
+  const reads = [
+    ['cnpg', 'runtime', 'db', 'pg'], ['cnpg', 'ha', 'db', 'pg'], ['cnpg', 'storage', 'db', 'pg'],
+    ['cnpg', 'history', 'db', 'pg', '1h'], ['cnpg', 'sessions', 'db', 'pg', 'pg-1'],
+    ['cnpg', 'workspace', 'db'], ['cnpg', 'workspace', 'db,other'], ['cnpg', 'workspace', ''],
+    ['cnpg', 'capabilities', 'clusters', 'db', 'pg'], ['cnpg', 'restore-capability', 'db'],
+    ['cnpg', 'runtime', 'db', 'other'], ['cnpg', 'runtime', 'other', 'pg'], ['resource', 'pods'],
+    ['cnpg', 'workspace', 'elsewhere'], ['cnpg', 'parameters', 'db', 'pg'],
+  ]
+  const fns = reads.map((_, i) => vi.fn(() => i === 0 ? pending : Promise.resolve(i)))
+  const observers = reads.map((queryKey, i) => {
+    client.setQueryData(queryKey, -1)
+    const observer = new QueryObserver(client, { queryKey, queryFn: fns[i], staleTime: Infinity })
+    return observer.subscribe(() => {})
+  })
+  const inactive = vi.fn(async () => 1)
+  client.setQueryData(['cnpg', 'recovery', 'db', 'pg'], -1)
+  client.setQueryDefaults(['cnpg', 'recovery', 'db', 'pg'], { queryFn: inactive })
+  let done = false
+  const refresh = refetchCNPGDetail(client, { plural: 'clusters', namespace: 'db', name: 'pg', group: 'postgresql.cnpg.io' }).then(() => { done = true })
+  await Promise.resolve()
+  expect(done).toBe(false)
+  for (const i of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14]) expect(fns[i]).toHaveBeenCalledTimes(1)
+  for (const i of [10, 11, 12, 13]) expect(fns[i]).not.toHaveBeenCalled()
+  expect(inactive).not.toHaveBeenCalled()
+  finish(1)
+  await refresh
+  expect(done).toBe(true)
+  observers.forEach((off) => off())
+  client.clear()
+})

package/src/components/cnpg/refresh.ts

@@ -0,0 +1,17 @@
+import type { QueryClient } from '@tanstack/react-query'
+import type { CNPGDetailTarget } from './routes'
+
+export function refetchCNPGDetail(client: QueryClient, target: CNPGDetailTarget): Promise<void> {
+  return client.refetchQueries({
+    type: 'active',
+    predicate: ({ queryKey: key }) => {
+      if (key[0] !== 'cnpg') return false
+      if (['workspace', 'disk', 'fleet-metrics', 'operator-status'].includes(String(key[1]))) {
+        return key[2] === '' || String(key[2]).split(',').includes(target.namespace)
+      }
+      if (key[1] === 'capabilities') return key[2] === target.plural && key[3] === target.namespace && key[4] === target.name
+      if (key[1] === 'restore-capability') return key[2] === target.namespace
+      return key[2] === target.namespace && key[3] === target.name
+    },
+  })
+}

package/src/components/cnpg/refreshNotice.test.tsx

@@ -0,0 +1,29 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { RefreshFailedNotice } from '../workspace/layout'
+
+describe('RefreshFailedNotice', () => {
+  it('says a refresh failed and how old the data on screen is', () => {
+    const html = renderToStaticMarkup(
+      <RefreshFailedNotice queries={[{ isRefetchError: true, error: new Error('Gateway Timeout'), dataUpdatedAt: Date.now() - 5 * 60_000 }]} />,
+    )
+    expect(html).toContain('Last refresh failed: Gateway Timeout')
+    expect(html).toContain('showing data from 5m ago')
+  })
+  it('names the oldest of several failed reads', () => {
+    const html = renderToStaticMarkup(
+      <RefreshFailedNotice
+        queries={[
+          { isRefetchError: true, error: new Error('recent'), dataUpdatedAt: Date.now() - 60_000 },
+          { isRefetchError: true, error: new Error('older'), dataUpdatedAt: Date.now() - 3 * 3_600_000 },
+          { isRefetchError: false, error: null, dataUpdatedAt: Date.now() - 10 * 3_600_000 },
+        ]}
+      />,
+    )
+    expect(html).toContain('older')
+    expect(html).toContain('3h ago')
+  })
+  it('renders nothing while refreshes succeed', () => {
+    expect(renderToStaticMarkup(<RefreshFailedNotice queries={[{ isRefetchError: false, error: null, dataUpdatedAt: Date.now() }]} />)).toBe('')
+  })
+})

package/src/components/cnpg/routes.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
-import { cnpgDetailKindFor, cnpgDetailPath, decodeDrawerTrail, encodeDrawerTrail, parseCNPGRoute, sameResource } from './routes'
+import { cnpgClusterKindListMode, cnpgDetailKindFor, cnpgDetailPath, cnpgViewNamedForKind, parseCNPGRoute } from './routes'
+import { decodeDrawerTrail, encodeDrawerTrail, sameSelectedResource } from '../../utils/drawer-trail'
 
 describe('CNPG routes', () => {
   it('parses workspace screens and falls back to Overview for unknown or unavailable ones', () => {
@@ -30,8 +31,8 @@ describe('CNPG routes', () => {
   it('distinguishes same-named kinds from different groups', () => {
     const cnpg = { kind: 'clusters', group: 'postgresql.cnpg.io', namespace: 'a', name: 'x' }
     const capi = { kind: 'clusters', group: 'cluster.x-k8s.io', namespace: 'a', name: 'x' }
-    expect(sameResource(cnpg, capi)).toBe(false)
-    expect(sameResource(cnpg, { ...cnpg })).toBe(true)
+    expect(sameSelectedResource(cnpg, capi)).toBe(false)
+    expect(sameSelectedResource(cnpg, { ...cnpg })).toBe(true)
   })
 
   it('parses full-detail routes for every CNPG kind and the cluster-scoped placeholder', () => {
@@ -58,3 +59,33 @@ describe('CNPG routes', () => {
     expect(cnpgDetailKindFor('backups', 'velero.io')).toBeNull()
   })
 })
+
+describe('cnpgViewNamedForKind', () => {
+  it('is true only for the kind the crumb’s view is named after', () => {
+    expect(cnpgViewNamedForKind('clusters')).toBe(true)
+    expect(cnpgViewNamedForKind('backups')).toBe(true)
+    expect(cnpgViewNamedForKind('poolers')).toBe(true)
+    // Also under Backups, but not what the view is named after.
+    expect(cnpgViewNamedForKind('scheduledbackups')).toBe(false)
+    expect(cnpgViewNamedForKind('objectstores')).toBe(false)
+    expect(cnpgViewNamedForKind('databases')).toBe(false)
+    expect(cnpgViewNamedForKind('pods')).toBe(false)
+  })
+})
+
+describe('cnpgClusterKindListMode', () => {
+  const cnpg = { name: 'clusters', group: 'postgresql.cnpg.io' }
+  it('shows the Clusters view for the CloudNativePG Cluster kind when this Radar serves it', () => {
+    expect(cnpgClusterKindListMode(cnpg, 'supported', false)).toBe('view')
+  })
+  it('waits, rather than flashing the table, only while capabilities first load', () => {
+    expect(cnpgClusterKindListMode(cnpg, 'unknown', true)).toBe('wait')
+    expect(cnpgClusterKindListMode(cnpg, 'unknown', false)).toBe('table')
+  })
+  it('keeps the table on a Radar without the views, and for every other kind', () => {
+    expect(cnpgClusterKindListMode(cnpg, 'unsupported', false)).toBe('table')
+    expect(cnpgClusterKindListMode({ name: 'clusters', group: 'cluster.x-k8s.io' }, 'supported', false)).toBe('table')
+    expect(cnpgClusterKindListMode({ name: 'backups', group: 'postgresql.cnpg.io' }, 'supported', false)).toBe('table')
+    expect(cnpgClusterKindListMode(null, 'supported', false)).toBe('table')
+  })
+})

package/src/components/cnpg/routes.ts

@@ -1,10 +1,11 @@
-import type { SelectedResource } from '../../types'
+import { CNPG_KIND_BY_KEY, type CNPGWorkspaceKey } from '@skyhook-io/k8s-ui'
+import type { RadarFeatureSupport } from '../../api/radarFeatures'
 
 export type CNPGScreen = 'overview' | 'protection' | 'declarations' | 'pooling' | 'operator'
 
 export const CNPG_SCREENS: { id: CNPGScreen; label: string; path: string }[] = [
-  { id: 'overview', label: 'Overview', path: '/cnpg' },
-  { id: 'protection', label: 'Protection', path: '/cnpg/protection' },
+  { id: 'overview', label: 'Clusters', path: '/cnpg' },
+  { id: 'protection', label: 'Backups', path: '/cnpg/protection' },
   { id: 'declarations', label: 'Declarations', path: '/cnpg/declarations' },
   { id: 'pooling', label: 'Pooling', path: '/cnpg/pooling' },
   { id: 'operator', label: 'Operator', path: '/cnpg/operator' },
@@ -23,18 +24,62 @@ export interface CNPGRoute {
 }
 
 // The CNPG kinds that have a CNPG-framed full detail, with the workspace
-// destination each one lives under.
-export const CNPG_DETAIL_KINDS: Record<string, { group: string; kind: string; home: CNPGScreen; clusterScoped?: boolean }> = {
-  clusters: { group: 'postgresql.cnpg.io', kind: 'Cluster', home: 'overview' },
-  backups: { group: 'postgresql.cnpg.io', kind: 'Backup', home: 'protection' },
-  scheduledbackups: { group: 'postgresql.cnpg.io', kind: 'ScheduledBackup', home: 'protection' },
-  objectstores: { group: 'barmancloud.cnpg.io', kind: 'ObjectStore', home: 'protection' },
-  databases: { group: 'postgresql.cnpg.io', kind: 'Database', home: 'declarations' },
-  publications: { group: 'postgresql.cnpg.io', kind: 'Publication', home: 'declarations' },
-  subscriptions: { group: 'postgresql.cnpg.io', kind: 'Subscription', home: 'declarations' },
-  poolers: { group: 'postgresql.cnpg.io', kind: 'Pooler', home: 'pooling' },
-  imagecatalogs: { group: 'postgresql.cnpg.io', kind: 'ImageCatalog', home: 'operator' },
-  clusterimagecatalogs: { group: 'postgresql.cnpg.io', kind: 'ClusterImageCatalog', home: 'operator', clusterScoped: true },
+// destination each one lives under. Kind and group come from the workspace's
+// kind table, so the two never disagree.
+const CNPG_DETAIL_HOMES: Partial<Record<CNPGWorkspaceKey, CNPGScreen>> = {
+  clusters: 'overview',
+  backups: 'protection',
+  scheduledBackups: 'protection',
+  objectStores: 'protection',
+  databases: 'declarations',
+  publications: 'declarations',
+  subscriptions: 'declarations',
+  databaseRoles: 'declarations',
+  poolers: 'pooling',
+  imageCatalogs: 'operator',
+  clusterImageCatalogs: 'operator',
+}
+
+export const CNPG_DETAIL_KINDS: Record<string, { group: string; kind: string; home: CNPGScreen; clusterScoped?: boolean }> = Object.fromEntries(
+  (Object.entries(CNPG_DETAIL_HOMES) as [CNPGWorkspaceKey, CNPGScreen][]).map(([key, home]) => {
+    const k = CNPG_KIND_BY_KEY[key]
+    return [k.plural, { group: k.group, kind: k.kind, home, ...(key === 'clusterImageCatalogs' ? { clusterScoped: true } : {}) }]
+  }),
+)
+
+// The kind each view is named after.
+const CNPG_VIEW_NAMESAKES: Partial<Record<CNPGScreen, string>> = { overview: 'clusters', protection: 'backups', pooling: 'poolers' }
+
+/**
+ * Whether a kind is the one its home view is named after (Cluster in
+ * Clusters, Backup in Backups, Pooler in Pooling): the crumb then already says
+ * what the object is, so the kind badge is left out. Other kinds in the same
+ * view, such as ScheduledBackup and ObjectStore under Backups, keep it.
+ */
+export function cnpgViewNamedForKind(plural: string): boolean {
+  const home = CNPG_DETAIL_KINDS[plural]?.home
+  return !!home && CNPG_VIEW_NAMESAKES[home] === plural
+}
+
+/** The CloudNativePG Cluster kind, whose list is the Clusters view. */
+export function isCNPGClusterKind(kind: { name: string; group: string } | null | undefined): boolean {
+  return !!kind && kind.name === 'clusters' && kind.group === 'postgresql.cnpg.io'
+}
+
+/**
+ * What the CloudNativePG Cluster kind's Resources route shows: the Clusters
+ * view when this Radar serves it; a loader while capabilities load for the
+ * first time, so the table never flashes before it; otherwise the table (a
+ * Radar older than the views, or capabilities that could not be read).
+ */
+export function cnpgClusterKindListMode(
+  kind: { name: string; group: string } | null | undefined,
+  support: RadarFeatureSupport,
+  capabilitiesPending: boolean,
+): 'view' | 'wait' | 'table' {
+  if (!isCNPGClusterKind(kind)) return 'table'
+  if (support === 'supported') return 'view'
+  return support === 'unknown' && capabilitiesPending ? 'wait' : 'table'
 }
 
 export function cnpgDetailKindFor(plural: string, group: string | undefined): string | null {
@@ -77,36 +122,3 @@ export function cnpgDetailPath(target: Omit<CNPGDetailTarget, 'group'>, ctx?: st
 export function cnpgScreenPath(screen: CNPGScreen): string {
   return CNPG_SCREENS.find((s) => s.id === screen)?.path ?? '/cnpg'
 }
-
-// Drawer identity in the URL: kind:group:namespace:name, chained with "~" for
-// the in-drawer trail (last entry is the one shown). Kubernetes names and API
-// groups cannot contain ":" or "~", and the group is mandatory — CNPG's Cluster
-// and Backup collide with CAPI, KubeBlocks and Velero kinds.
-export function encodeDrawerRef(r: SelectedResource): string {
-  return [r.kind, r.group ?? '', r.namespace ?? '', r.name].join(':')
-}
-
-export function decodeDrawerRef(s: string): SelectedResource | null {
-  const parts = s.split(':')
-  if (parts.length !== 4 || !parts[0] || !parts[3]) return null
-  return { kind: parts[0], group: parts[1], namespace: parts[2], name: parts[3] }
-}
-
-export function decodeDrawerTrail(param: string | null): SelectedResource[] {
-  if (!param) return []
-  return param.split('~').map(decodeDrawerRef).filter((r): r is SelectedResource => r !== null)
-}
-
-export function encodeDrawerTrail(trail: SelectedResource[]): string {
-  return trail.map(encodeDrawerRef).join('~')
-}
-
-export function sameResource(a: SelectedResource | null | undefined, b: SelectedResource | null | undefined): boolean {
-  if (!a || !b) return false
-  return (
-    a.kind.toLowerCase() === b.kind.toLowerCase() &&
-    (a.group ?? '') === (b.group ?? '') &&
-    (a.namespace ?? '') === (b.namespace ?? '') &&
-    a.name === b.name
-  )
-}

package/src/components/cnpg/runtimeAssessment.ts

@@ -0,0 +1,198 @@
+import {
+  CNPG_SLOT_RETENTION_WARNING_BYTES,
+  cnpgFormatLag,
+  cnpgHASlotInstance,
+  cnpgReplicationTone,
+  cnpgSlotRetentionProblem,
+  cnpgStandbyNotReceivingProblem,
+  cnpgWithProblems,
+  formatGrant,
+  type CNPGFleetRow,
+  type CNPGProblem,
+  type CNPGInstanceLive,
+  type CNPGReplicationLive,
+  type CNPGSlotRetention,
+  type CNPGStandbyGap,
+} from '@skyhook-io/k8s-ui'
+import type { CNPGRuntimeResponse } from '../../api/cnpg'
+
+/** The instance-manager facts the HA section shows, from a runtime read. */
+export function cnpgInstanceLive(rt: CNPGRuntimeResponse | undefined): CNPGInstanceLive[] | undefined {
+  if (!rt || rt.permission.proxy === 'denied') return undefined
+  return rt.instances.map((i) => ({
+    pod: i.pod,
+    state: i.status.state,
+    pendingRestart: i.status.pendingRestart,
+    pendingRestartForDecrease: i.status.pendingRestartForDecrease,
+    roleDetail: i.status.roleDetail,
+    instanceManagerVersion: i.status.instanceManagerVersion,
+    timeline: i.status.timeline,
+    incomplete: i.status.incomplete,
+    reason: i.status.error ?? i.status.reason,
+  }))
+}
+
+/** Why the HA section has no instance-manager facts at all; undefined when it has them. */
+export function cnpgInstanceLiveUnavailable(rt: CNPGRuntimeResponse | undefined, error: unknown): string | undefined {
+  if (rt?.permission.proxy === 'denied') return `needs ${formatGrant(rt.permission.grant) ?? 'get pods/proxy'}`
+  if (rt) return undefined
+  return error instanceof Error ? `the runtime read failed: ${error.message}` : 'instance managers not read yet'
+}
+
+/** Why cnpgReplicationLive has no answer; undefined when it has one. */
+export function cnpgReplicationGap(rt: CNPGRuntimeResponse | undefined, error: unknown): string | undefined {
+  const unavailable = cnpgInstanceLiveUnavailable(rt, error)
+  if (unavailable) return unavailable
+  const primary = rt?.instances.find((i) => i.role === 'primary')
+  if (!primary) return 'no instance reports being the primary'
+  if (primary.status.state !== 'ok' && primary.status.state !== 'partial') {
+    return `${primary.pod} did not report (${primary.status.error ?? primary.status.reason ?? primary.status.state})`
+  }
+  if (!primary.status.replication) return `${primary.pod} did not report its replication rows`
+  return undefined
+}
+
+/** Streaming standbys and the worst replay lag, from the primary's pg_stat_replication. */
+export function cnpgReplicationLive(rt: CNPGRuntimeResponse | undefined): CNPGReplicationLive | undefined {
+  const primary = rt?.instances.find((i) => i.role === 'primary')
+  if (!primary || (primary.status.state !== 'ok' && primary.status.state !== 'partial')) return undefined
+  const reps = primary.status.replication
+  if (!reps) return undefined
+  const lags = reps.map((r) => r.replayLag).filter((v): v is number => v !== undefined)
+  return {
+    streaming: reps.filter((r) => r.state === 'streaming').length,
+    standbys: rt!.instances.filter((i) => i.role !== 'primary').length,
+    maxReplayLagSeconds: lags.length ? Math.max(...lags) : undefined,
+  }
+}
+
+const LIVE_STANDBY_SOURCE = 'The primary’s pg_stat_replication and each standby’s /pg/status, read through the instance manager'
+
+/** Instances named in the Cluster's cnpg.io/fencedInstances annotation; '*' fences all. */
+function fencedInstances(cluster: any): { all: boolean; pods: Set<string> } {
+  const raw = cluster?.metadata?.annotations?.['cnpg.io/fencedInstances']
+  try {
+    const list = raw ? JSON.parse(raw) : []
+    if (!Array.isArray(list)) return { all: false, pods: new Set() }
+    return { all: list.includes('*'), pods: new Set(list.filter((x: unknown): x is string => typeof x === 'string')) }
+  } catch {
+    return { all: false, pods: new Set() }
+  }
+}
+
+/**
+ * Standbys the live read shows receiving nothing: no row in the primary's
+ * pg_stat_replication although the standby itself answered. A fenced standby
+ * is stopped on purpose and one running pg_rewind is rejoining, so neither is
+ * a gap.
+ */
+export function cnpgLiveStandbyGaps(row: CNPGFleetRow, rt: CNPGRuntimeResponse | undefined): CNPGStandbyGap[] {
+  const primary = rt?.instances.find((i) => i.role === 'primary')
+  const reps = primary?.status.state === 'ok' ? primary.status.replication : undefined
+  if (!rt || !primary || !reps || row.hibernated) return []
+  const fenced = fencedInstances(row.cluster)
+  if (fenced.all) return []
+  const connected = new Set(reps.map((r) => r.applicationName))
+  const standbys = rt.instances.filter((i) => i.role !== 'primary')
+  const gaps = standbys.filter(
+    (i) => !connected.has(i.pod) && !fenced.pods.has(i.pod) && (i.status.state === 'ok' || i.status.state === 'partial') && i.status.roleDetail !== 'pgRewind',
+  )
+  const expected = row.instances.desired !== null ? Math.max(0, row.instances.desired - 1) : standbys.length
+  return gaps.map((i) => {
+    const evidence = ['it has no row in the primary’s pg_stat_replication']
+    if (i.status.isWalReceiverActive === false || i.status.roleDetail === 'fileBased') evidence.push('it reports no active WAL receiver')
+    if (i.status.replayPaused || i.status.roleDetail === 'replayPaused') evidence.push('its WAL replay is paused')
+    if (i.status.timeline !== undefined && primary.status.timeline !== undefined && i.status.timeline !== primary.status.timeline) {
+      evidence.push(`it is on timeline ${i.status.timeline} while the primary is on ${primary.status.timeline}`)
+    }
+    return {
+      pod: i.pod,
+      evidence,
+      measuredBy: 'the instance manager',
+      sourceDetail: LIVE_STANDBY_SOURCE,
+      noneReceiving: expected > 0 && reps.length === 0,
+    }
+  })
+}
+
+/** Inactive physical slots on the primary that hold at least the warning amount of WAL. */
+export function cnpgLiveSlotRetentions(row: CNPGFleetRow, rt: CNPGRuntimeResponse | undefined): CNPGSlotRetention[] {
+  const primary = rt?.instances.find((i) => i.role === 'primary')
+  const slots = primary && (primary.status.state === 'ok' || primary.status.state === 'partial') ? primary.status.slots : undefined
+  if (!primary || !slots) return []
+  const instances = (rt?.instances ?? []).map((i) => i.pod)
+  return slots
+    .filter((sl): sl is typeof sl & { retainedBytes: number } => sl.active === false && sl.type === 'physical' && sl.retainedBytes !== undefined && sl.retainedBytes >= CNPG_SLOT_RETENTION_WARNING_BYTES)
+    .map((sl) => ({
+      slot: sl.name,
+      pod: primary.pod,
+      bytes: sl.retainedBytes,
+      standby: cnpgHASlotInstance(row.cluster, sl.name, instances),
+      measuredBy: 'the instance manager',
+      sourceDetail: 'The primary’s /pg/status replication slots (active) and the exporter’s retained WAL',
+    }))
+}
+
+/**
+ * The fleet row with what the instance managers report: the live replication
+ * fact, standbys that receive nothing, and inactive slots. A complete live read
+ * replaces the fleet's (Prometheus) answer for what it covers, clearing a
+ * problem it disproves — a standby now connected, a slot no longer inactive.
+ */
+export function withLiveReplication(row: CNPGFleetRow, rt: CNPGRuntimeResponse | undefined): CNPGFleetRow {
+  return withLiveSlots(withLiveStandbys(row, rt), rt)
+}
+
+// Replaces the Kubernetes-only replication fact with the primary's
+// pg_stat_replication when it has been read; otherwise keeps "lag unknown".
+// Expected standbys are spec.instances − 1: a standby whose Pod is gone is
+// missing, not absent from the count.
+function withLiveStandbys(row: CNPGFleetRow, rt: CNPGRuntimeResponse | undefined): CNPGFleetRow {
+  const primary = rt?.instances.find((i) => i.role === 'primary')
+  if (!primary || primary.status.state !== 'ok' || row.instances.desired === 1 || row.hibernated) return row
+  const reps = primary.status.replication
+  if (!reps) return row
+  const streaming = reps.filter((r) => r.state === 'streaming').length
+  const lags = reps.map((r) => r.replayLag).filter((v): v is number => v !== undefined)
+  const maxLag = lags.length ? Math.max(...lags) : undefined
+  const source = 'From the primary’s pg_stat_replication via the instance manager'
+  // A standby that isn't connected has no row, so its delay isn't in the max.
+  const lagFor = (allConnected: boolean) =>
+    maxLag === undefined ? '' : ` · max replay delay ${cnpgFormatLag(maxLag)}${allConnected ? '' : ' (connected standbys only)'}`
+  const gaps = cnpgLiveStandbyGaps(row, rt)
+  const connected = new Set(reps.map((r) => r.applicationName))
+  // The fleet's standby problem for one the primary now streams to is disproven.
+  const disproven = (p: CNPGProblem) => p.reason === 'CNPGStandbyNotReceiving' && connected.has(p.subject.name)
+  const raised = gaps.map((g) => cnpgStandbyNotReceivingProblem(row, g))
+  if (row.instances.desired === null) {
+    const live = { ...row, replication: { text: `${streaming} streaming${lagFor(false)}`, tone: 'unknown' as const, source: `${source}; spec.instances is not reported, so the expected standbys are unknown`, at: primary.status.capturedAt } }
+    return cnpgWithProblems(live, raised, disproven)
+  }
+  const expected = Math.max(0, row.instances.desired - 1)
+  const lagText = lagFor(reps.length >= expected)
+  const tone = cnpgReplicationTone(streaming, expected, maxLag)
+  const text = streaming < expected ? `${streaming} of ${expected} expected standbys streaming` : `${streaming}/${expected} streaming`
+  const missing = gaps.length > 0 ? ` · ${gaps.map((g) => g.pod).join(', ')} not connected` : ''
+  const live = { ...row, replication: { text: `${text}${missing}${lagText}`, tone, source, at: primary.status.capturedAt } }
+  return cnpgWithProblems(live, raised, disproven)
+}
+
+// Slots are judged from the primary's own slot list whenever it was read,
+// whatever the replication rows say. A fleet warning is cleared only by
+// evidence against it: the slot active, measured below the threshold, or
+// absent from a complete list. An unmeasured slot or a capped, partial list
+// leaves it standing.
+function withLiveSlots(row: CNPGFleetRow, rt: CNPGRuntimeResponse | undefined): CNPGFleetRow {
+  const primary = rt?.instances.find((i) => i.role === 'primary')
+  const slots = primary && (primary.status.state === 'ok' || primary.status.state === 'partial') ? primary.status.slots : undefined
+  if (!primary || !slots) return row
+  const complete = primary.status.state === 'ok'
+  const byName = new Map(slots.map((sl) => [sl.name, sl]))
+  const disproven = (p: CNPGProblem) => {
+    if (p.reason !== 'CNPGInactiveSlot' || !p.slot) return false
+    const sl = byName.get(p.slot)
+    if (!sl) return complete
+    return sl.active === true || (sl.retainedBytes !== undefined && sl.retainedBytes < CNPG_SLOT_RETENTION_WARNING_BYTES)
+  }
+  return cnpgWithProblems(row, cnpgLiveSlotRetentions(row, rt).map((r) => cnpgSlotRetentionProblem(row, r)), disproven)
+}