@skyhook-io/k8s-ui 1.13.3 → 1.13.4

package/src/components/resources/generic-status.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from 'vitest'
+import { getGenericResourceStatus } from './generic-status'
+
+const withStatus = (status: any) => ({ status })
+
+describe('getGenericResourceStatus', () => {
+  describe('phase', () => {
+    it('reports a known-healthy phase as healthy', () => {
+      expect(getGenericResourceStatus(withStatus({ phase: 'Running' })))
+        .toEqual({ text: 'Running', tone: 'healthy' })
+    })
+
+    it('reports a known-degraded phase as degraded and carries the message', () => {
+      expect(getGenericResourceStatus(withStatus({ phase: 'Pending', message: 'waiting for quota' })))
+        .toEqual({ text: 'Pending', tone: 'degraded', reason: 'waiting for quota' })
+    })
+
+    it('reports a known-failure phase as unhealthy', () => {
+      expect(getGenericResourceStatus(withStatus({ phase: 'Failed' })))
+        .toMatchObject({ text: 'Failed', tone: 'unhealthy' })
+    })
+
+    // The cell and drawer ladders both painted any unrecognized phase red,
+    // so every operator-specific phase name read as an outage.
+    it('prefers a known phase over conditions', () => {
+      const s = getGenericResourceStatus(withStatus({
+        phase: 'Running',
+        conditions: [{ type: 'Ready', status: 'False' }],
+      }))
+      expect(s).toEqual({ text: 'Running', tone: 'healthy' })
+    })
+
+    // An unrecognized phase says nothing about health, so a condition or a
+    // replica count that does must win. Short-circuiting on it would hide a
+    // real failure behind an operator's private vocabulary.
+    it('lets a failing condition outrank an unrecognized phase', () => {
+      expect(getGenericResourceStatus(withStatus({
+        phase: 'Rebalancing',
+        conditions: [{ type: 'Ready', status: 'False', reason: 'QuorumLost' }],
+      }))).toMatchObject({ text: 'QuorumLost', tone: 'unhealthy' })
+    })
+
+    it('lets a failing replica count outrank an unrecognized phase', () => {
+      expect(getGenericResourceStatus(withStatus({ phase: 'Rebalancing', replicas: 3 })))
+        .toEqual({ text: '0/3 Ready', tone: 'unhealthy' })
+    })
+
+    it('keeps an unrecognized phase as the last resort', () => {
+      expect(getGenericResourceStatus(withStatus({ phase: 'Rebalancing' })))
+        .toMatchObject({ text: 'Rebalancing', tone: 'unknown' })
+    })
+
+    it('prefers a bare state string to an unrecognized phase', () => {
+      expect(getGenericResourceStatus(withStatus({ phase: 'Rebalancing', state: 'Draining' })))
+        .toEqual({ text: 'Draining', tone: 'unknown' })
+    })
+  })
+
+  describe('conditions with known polarity', () => {
+    it('reads Ready=True as healthy', () => {
+      expect(getGenericResourceStatus(withStatus({ conditions: [{ type: 'Ready', status: 'True' }] })))
+        .toEqual({ text: 'Ready', tone: 'healthy' })
+    })
+
+    it('prefers the condition reason over a synthesized negative label', () => {
+      expect(getGenericResourceStatus(withStatus({
+        conditions: [{ type: 'Ready', status: 'False', reason: 'BackoffLimitExceeded', message: 'too many retries' }],
+      }))).toEqual({ text: 'BackoffLimitExceeded', tone: 'unhealthy', reason: 'too many retries' })
+    })
+
+    it('synthesizes a negative label when there is no reason', () => {
+      expect(getGenericResourceStatus(withStatus({ conditions: [{ type: 'Available', status: 'False' }] })))
+        .toMatchObject({ text: 'Not Available', tone: 'unhealthy' })
+    })
+
+    // A controller that cannot evaluate a condition has not reported a failure.
+    it('does not treat Unknown as False', () => {
+      expect(getGenericResourceStatus(withStatus({ conditions: [{ type: 'Ready', status: 'Unknown' }] })))
+        .toMatchObject({ text: 'Ready', tone: 'unknown' })
+    })
+
+    it('resolves Ready ahead of Available regardless of array order', () => {
+      expect(getGenericResourceStatus(withStatus({
+        conditions: [{ type: 'Available', status: 'False' }, { type: 'Ready', status: 'True' }],
+      }))).toEqual({ text: 'Ready', tone: 'healthy' })
+    })
+
+    // Progressing=False is the resting state of a settled resource; the drawer
+    // ladder treated it like a failed Ready and mislabeled healthy objects.
+    it('does not infer health from Progressing', () => {
+      expect(getGenericResourceStatus(withStatus({ conditions: [{ type: 'Progressing', status: 'False' }] })))
+        .toMatchObject({ tone: 'unknown' })
+    })
+  })
+
+  describe('conditions with unknown polarity', () => {
+    // gmp PodMonitoring publishes only this; every TS ladder rendered a dash.
+    it('surfaces an unrecognized condition type as text without a health claim', () => {
+      expect(getGenericResourceStatus(withStatus({
+        conditions: [{ type: 'ConfigurationCreateSuccess', status: 'True' }],
+      }))).toEqual({ text: 'ConfigurationCreateSuccess', tone: 'unknown' })
+    })
+
+    it('reads GKE ComputeClass Health as a known positive condition', () => {
+      expect(getGenericResourceStatus(withStatus({ conditions: [{ type: 'Health', status: 'True' }] })))
+        .toEqual({ text: 'Health', tone: 'healthy' })
+    })
+
+    it('skips condition entries with no type', () => {
+      expect(getGenericResourceStatus(withStatus({
+        conditions: [{ status: 'True' }, { type: 'Settled', status: 'True' }],
+      }))).toEqual({ text: 'Settled', tone: 'unknown' })
+    })
+  })
+
+  describe('bare string status fields', () => {
+    // kubefledged ImageCache publishes status.status; the ladders checked
+    // status.state only, so it rendered a dash.
+    it('falls back to status.status', () => {
+      expect(getGenericResourceStatus(withStatus({ status: 'Succeeded', reason: 'ok' })))
+        .toEqual({ text: 'Succeeded', tone: 'unknown' })
+    })
+
+    it('prefers status.state over status.status', () => {
+      expect(getGenericResourceStatus(withStatus({ state: 'Bound', status: 'other' })))
+        .toEqual({ text: 'Bound', tone: 'unknown' })
+    })
+
+    it('ignores state/status when they are not strings', () => {
+      expect(getGenericResourceStatus(withStatus({ state: { phase: 'x' } }))).toBeNull()
+    })
+  })
+
+
+  describe('known-negative conditions and replicas', () => {
+    it('reads a Degraded=True condition as degraded', () => {
+      expect(getGenericResourceStatus(withStatus({
+        conditions: [{ type: 'Degraded', status: 'True', message: 'one shard offline' }],
+      }))).toEqual({ text: 'Degraded', tone: 'degraded', reason: 'one shard offline' })
+    })
+
+    it('ignores a known-negative condition that is False', () => {
+      expect(getGenericResourceStatus(withStatus({ conditions: [{ type: 'Degraded', status: 'False' }] })))
+        .toMatchObject({ tone: 'unknown' })
+    })
+
+    it('reports full replica coverage as healthy', () => {
+      expect(getGenericResourceStatus(withStatus({ replicas: 3, readyReplicas: 3 })))
+        .toEqual({ text: '3/3 Ready', tone: 'healthy' })
+    })
+
+    it('grades partial replica coverage degraded and none unhealthy', () => {
+      expect(getGenericResourceStatus(withStatus({ replicas: 3, readyReplicas: 1 })))
+        .toEqual({ text: '1/3 Ready', tone: 'degraded' })
+      expect(getGenericResourceStatus(withStatus({ replicas: 3 })))
+        .toEqual({ text: '0/3 Ready', tone: 'unhealthy' })
+    })
+
+    it('falls back to availableReplicas when readyReplicas is absent', () => {
+      expect(getGenericResourceStatus(withStatus({ replicas: 2, availableReplicas: 2 })))
+        .toEqual({ text: '2/2 Ready', tone: 'healthy' })
+    })
+
+    // Replicas say more than a vendor condition name, and both only rank below
+    // the condition types whose polarity is actually known.
+    it('ranks replicas above an unknown-polarity condition but below Ready', () => {
+      expect(getGenericResourceStatus(withStatus({
+        replicas: 2, readyReplicas: 2,
+        conditions: [{ type: 'ConfigurationCreateSuccess', status: 'True' }],
+      }))).toEqual({ text: '2/2 Ready', tone: 'healthy' })
+
+      expect(getGenericResourceStatus(withStatus({
+        replicas: 2, readyReplicas: 2,
+        conditions: [{ type: 'Ready', status: 'False', reason: 'Stalled' }],
+      }))).toMatchObject({ text: 'Stalled', tone: 'unhealthy' })
+    })
+
+    it('ignores a zero or non-numeric replica count', () => {
+      expect(getGenericResourceStatus(withStatus({ replicas: 0 }))).toBeNull()
+      expect(getGenericResourceStatus(withStatus({ replicas: '3' }))).toBeNull()
+    })
+  })
+
+  describe('nothing to report', () => {
+    it.each([
+      ['no resource', undefined],
+      ['no status', {}],
+      // A resource whose status IS a string, not a status object — guarded, or
+      // reading .phase off a string would silently yield undefined forever.
+      ['non-object status', { status: 'ok' }],
+      ['empty status', { status: {} }],
+      ['empty conditions', { status: { conditions: [] } }],
+      ['blank phase', { status: { phase: '   ' } }],
+      ['conditions that are not an array', { status: { conditions: 'Ready' } }],
+    ])('returns null for %s', (_label, resource) => {
+      expect(getGenericResourceStatus(resource as any)).toBeNull()
+    })
+  })
+})

package/src/components/resources/generic-status.ts

@@ -0,0 +1,171 @@
+import type { HealthLevel } from './resource-utils'
+import { getGatewayPolicyStatus } from './gateway-policy-status'
+
+/**
+ * Derives a status for a resource with no dedicated renderer — a CRD Radar
+ * hasn't curated. Shared by the table cell, the column filter and sort, the
+ * drawer dispatch and the generic renderer, so a row cannot show one status
+ * and its filter dropdown offer another.
+ *
+ * Two rules it enforces:
+ *   - Polarity is only claimed for a fixed set of condition types. Any other
+ *     type is reported as text with an `unknown` tone —
+ *     `ConfigurationCreateSuccess=True` is informative, but reading health out
+ *     of an arbitrary condition name is a guess.
+ *   - `Unknown` is not `False`. A condition the controller can't evaluate is
+ *     not a failure.
+ *
+ * The Go summarizer behind MCP (pkg/ai/context/summary_crd.go) derives this
+ * separately and does not agree: it is conditions-first where this is
+ * phase-first, and reads `Unknown` as false. They differ on, for example,
+ * {phase: Running, Ready: False}.
+ */
+export interface GenericStatus {
+  /** Display text. Never empty when a GenericStatus is returned. */
+  text: string
+  tone: HealthLevel
+  /** Condition message, when one explains a non-healthy tone. */
+  reason?: string
+}
+
+// Union of the phase vocabularies the five call sites had accumulated.
+const HEALTHY_PHASES = new Set([
+  'Running', 'Active', 'Succeeded', 'Ready', 'Healthy', 'Available', 'Bound', 'Complete', 'Completed',
+])
+const DEGRADED_PHASES = new Set([
+  'Pending', 'Progressing', 'Unknown', 'Terminating', 'Waiting', 'Provisioning', 'Reconciling',
+])
+const UNHEALTHY_PHASES = new Set([
+  'Failed', 'Error', 'CrashLoopBackOff', 'ImagePullBackOff', 'ErrImagePull', 'Lost', 'Rejected',
+])
+
+/**
+ * Condition types whose polarity is a convention rather than a guess, most
+ * specific first. NOT the Go summarizer's order — it resolves Ready >
+ * Available > Synced and knows neither Healthy nor Health; see the note above
+ * on why the two are not yet aligned. `Progressing` is deliberately absent:
+ * `Progressing=False` on a settled resource is normal, so treating it like a
+ * failed `Ready` mislabels healthy objects.
+ */
+export const KNOWN_POSITIVE_CONDITIONS = ['Ready', 'Available', 'Healthy', 'Health', 'Synced'] as const
+
+/** Condition types that mean trouble when True — the mirror of the set above. */
+export const KNOWN_NEGATIVE_CONDITIONS = ['Degraded', 'Warning', 'ScalingLimited'] as const
+
+function conditionReason(cond: any): string | undefined {
+  const reason = typeof cond?.reason === 'string' ? cond.reason.trim() : ''
+  return reason || undefined
+}
+
+function conditionMessage(cond: any): string | undefined {
+  const message = typeof cond?.message === 'string' ? cond.message.trim() : ''
+  return message || undefined
+}
+
+function fromCondition(cond: any, polarityKnown: boolean): GenericStatus | null {
+  const type = typeof cond?.type === 'string' ? cond.type.trim() : ''
+  if (!type) return null
+  const state = cond?.status
+
+  if (state === 'True') {
+    return { text: type, tone: polarityKnown ? 'healthy' : 'unknown' }
+  }
+  if (state === 'False') {
+    return {
+      text: conditionReason(cond) || `Not ${type}`,
+      tone: polarityKnown ? 'unhealthy' : 'unknown',
+      reason: conditionMessage(cond),
+    }
+  }
+  // "Unknown" (or anything else): the controller could not determine this.
+  // Not a failure — report it without a health claim.
+  return { text: conditionReason(cond) || type, tone: 'unknown', reason: conditionMessage(cond) }
+}
+
+/**
+ * Derives a status for a resource with no kind-specific handling.
+ * Returns null when the object carries nothing that reads as a status —
+ * callers render their own placeholder rather than inventing one.
+ */
+export function getGenericResourceStatus(resource: any): GenericStatus | null {
+  const status = resource?.status
+  if (!status || typeof status !== 'object') return null
+
+  // Gateway API policies keep their conditions per-ancestor, one level below
+  // where the rest of this function looks. Dispatched on the shape and resolved
+  // by its own reader, because the rungs below would answer it wrongly: they
+  // take a positive condition before a negative one, and a policy that is
+  // `Accepted=True, Programmed=False` has been taken up and then failed.
+  // Returns null when the ancestors say nothing, so a policy that also
+  // publishes top-level conditions still gets read — GCPBackendPolicy declares
+  // both, and suppressing its conditions would hide a Ready=False behind an
+  // empty ancestor list.
+  const policy = getGatewayPolicyStatus(resource)
+  if (policy) return policy
+
+  const phase = typeof status.phase === 'string' ? status.phase.trim() : ''
+  if (phase) {
+    const reason = typeof status.message === 'string' && status.message.trim()
+      ? status.message.trim()
+      : typeof status.reason === 'string' && status.reason.trim()
+        ? status.reason.trim()
+        : undefined
+    if (HEALTHY_PHASES.has(phase)) return { text: phase, tone: 'healthy' }
+    if (DEGRADED_PHASES.has(phase)) return { text: phase, tone: 'degraded', reason }
+    if (UNHEALTHY_PHASES.has(phase)) return { text: phase, tone: 'unhealthy', reason }
+    // An unrecognized phase does NOT short-circuit. Its health is unknown to
+    // us, so a Ready=False condition or a failed replica count below is the
+    // better answer; the phase text is kept as the last resort. Returning here
+    // would hide a real failure behind an operator's private vocabulary.
+  }
+
+  const conditions = Array.isArray(status.conditions) ? status.conditions : []
+  for (const type of KNOWN_POSITIVE_CONDITIONS) {
+    const match = conditions.find((c: any) => c?.type === type)
+    if (match) {
+      const derived = fromCondition(match, true)
+      if (derived) return derived
+    }
+  }
+  for (const type of KNOWN_NEGATIVE_CONDITIONS) {
+    const match = conditions.find((c: any) => c?.type === type && c?.status === 'True')
+    if (match) {
+      return { text: match.type, tone: 'degraded', reason: conditionMessage(match) ?? conditionReason(match) }
+    }
+  }
+
+  // Replica counts read as a status on their own, and say more than a vendor
+  // condition name would. Ranked above the unknown-polarity fallback for that
+  // reason.
+  if (typeof status.replicas === 'number' && status.replicas > 0) {
+    const desired = status.replicas
+    const ready = typeof status.readyReplicas === 'number' ? status.readyReplicas
+      : typeof status.availableReplicas === 'number' ? status.availableReplicas
+        : 0
+    const text = `${ready}/${desired} Ready`
+    if (ready >= desired) return { text, tone: 'healthy' }
+    return { text, tone: ready > 0 ? 'degraded' : 'unhealthy' }
+  }
+
+  // No condition whose polarity we know. Report the first one as text so a CRD
+  // that only publishes its own vocabulary still says something, but without a
+  // health claim.
+  for (const cond of conditions) {
+    const derived = fromCondition(cond, false)
+    if (derived) return derived
+  }
+
+  // `state` and `status` are both used as a bare string status by CRDs that
+  // publish neither a phase nor conditions. Guarded on string because both
+  // names are also used for nested objects.
+  for (const key of ['state', 'status'] as const) {
+    const value = status[key]
+    if (typeof value === 'string' && value.trim()) {
+      return { text: value.trim(), tone: 'unknown' }
+    }
+  }
+
+  if (phase) return { text: phase, tone: 'unknown' }
+
+  return null
+}

package/src/components/resources/gpu-ecosystem-registry.test.ts

@@ -0,0 +1,63 @@
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import { describe, expect, it } from 'vitest'
+import { hasCuratedColumns } from './ResourcesView'
+
+type RegistryRow = {
+  logicalId: string
+  group: string
+  plural: string
+  kind: string
+  scope: string
+  apiVersion: string
+  scenario: string
+  crdUrl: string
+}
+
+const REGISTRY_PATH = join(__dirname, '../../../../../scripts/gpu-ecosystem-demo/resources.tsv')
+const [header, ...lines] = readFileSync(REGISTRY_PATH, 'utf8').trim().split('\n')
+
+if (header.replace(/^# /, '') !== 'logical_id\tgroup\tplural\tkind\tscope\tapi_version\tscenario\tcrd_url') {
+  throw new Error(`Unexpected GPU ecosystem registry header: ${header}`)
+}
+
+const rows: RegistryRow[] = lines.map(line => {
+  const [logicalId, group, plural, kind, scope, apiVersion, scenario, crdUrl] = line.split('\t')
+  return { logicalId, group, plural, kind, scope, apiVersion, scenario, crdUrl }
+})
+
+const rowsFor = (scenario: 'current' | 'experimental') =>
+  rows.filter(row => row.scenario === 'all' || row.scenario === scenario)
+
+describe.each(['current', 'experimental'] as const)('GPU ecosystem %s registry', scenario => {
+  const scenarioRows = rowsFor(scenario)
+
+  it('resolves to exactly 37 distinct logical resource identities', () => {
+    expect(scenarioRows).toHaveLength(37)
+    expect(new Set(scenarioRows.map(row => row.logicalId)).size).toBe(37)
+  })
+
+  it('maps every registered upstream resource to curated Radar columns', () => {
+    const uncurated = scenarioRows
+      .filter(row => !hasCuratedColumns(row.plural, row.group))
+      .map(row => `${row.plural}.${row.group}`)
+
+    expect(uncurated).toEqual([])
+  })
+
+  it('uses pinned tagged upstream CRDs', () => {
+    const unpinned = scenarioRows
+      .filter(row => !/^(v?\d|cluster-autoscaler-\d)/.test(new URL(row.crdUrl).pathname.split('/')[3] ?? ''))
+      .map(row => row.crdUrl)
+
+    expect(unpinned).toEqual([])
+  })
+})
+
+it('changes only the two inference-routing identities between scenarios', () => {
+  const current = new Map(rowsFor('current').map(row => [row.logicalId, `${row.plural}.${row.group}`]))
+  const experimental = new Map(rowsFor('experimental').map(row => [row.logicalId, `${row.plural}.${row.group}`]))
+  const changed = [...current].filter(([id, resource]) => experimental.get(id) !== resource).map(([id]) => id)
+
+  expect(changed).toEqual(['inferencepool', 'inferenceobjective'])
+})

package/src/components/resources/index.ts

@@ -44,7 +44,15 @@ export * from './resource-utils-prometheus'
 export * from './resource-utils-trivy'
 export * from './resource-utils-traefik'
 export * from './resource-utils-velero'
-export { ResourcesView, ResourcesViewDataContext } from './ResourcesView'
+export { ResourcesView, ResourcesViewDataContext, hasCuratedColumns } from './ResourcesView'
 export type { ResourceQueryResult, ExtraColumn, LargeListGuardState } from './ResourcesView'
 export { ResourcesSidebar } from './ResourcesSidebar'
 export type { ResourcesSidebarProps, SelectedKindInfo, PinnedItem } from './ResourcesSidebar'
+export {
+  sanitizePrinterTable,
+  printerTableKey,
+  printerColumnKey,
+} from './printer-columns'
+export type { PrinterColumnDef, PrinterTable } from './printer-columns'
+export { getGenericResourceStatus } from './generic-status'
+export type { GenericStatus } from './generic-status'

package/src/components/resources/istio-gateway-filter.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest'
+import { getCellFilterValue, getGatewayStatus } from './resource-utils'
+import { getGenericResourceStatus } from './generic-status'
+
+// The table renders Istio Gateway through IstioGatewayCell, which reads the
+// spec. The filter dropdown and the sort key have to read the same thing, or
+// the dropdown offers values that appear on no row and the column sorts on a
+// string the user never saw — the failure this file exists to pin.
+const gateway = (spec: any) => ({ apiVersion: 'networking.istio.io/v1', kind: 'Gateway', spec })
+
+describe('Istio Gateway filter values', () => {
+  it('reads status from the spec, not the generic derivation', () => {
+    const tls = gateway({ servers: [{ port: { number: 443 }, tls: { mode: 'SIMPLE' } }] })
+    const plain = gateway({ servers: [{ port: { number: 80 } }] })
+    const none = gateway({ servers: [] })
+    expect(getCellFilterValue(tls, 'status', 'istiogateways')).toBe('TLS')
+    expect(getCellFilterValue(plain, 'status', 'istiogateways')).toBe('Active')
+    expect(getCellFilterValue(none, 'status', 'istiogateways')).toBe('No Servers')
+  })
+
+  // Read as a Gateway API Gateway instead, the same object filters as
+  // "Unknown" — a value that appears on no row, since the cell shows Active.
+  // That divergence is what routing the normalized key fixes.
+  it('diverges from the row when read under the Gateway API key', () => {
+    const g = gateway({ servers: [{ port: { number: 80 } }] })
+    expect(getCellFilterValue(g, 'status', 'gateways')).not.toBe(
+      getCellFilterValue(g, 'status', 'istiogateways'),
+    )
+  })
+
+  it('reads the server count and selector its columns display', () => {
+    const g = gateway({ servers: [{ port: { number: 80 } }, { port: { number: 443 } }], selector: { istio: 'ingressgateway' } })
+    expect(getCellFilterValue(g, 'servers', 'istiogateways')).toBe('2')
+    expect(getCellFilterValue(g, 'selector', 'istiogateways')).toBe('istio=ingressgateway')
+  })
+
+  it('renders an absent selector the way the cell does', () => {
+    expect(getCellFilterValue(gateway({ servers: [] }), 'selector', 'istiogateways')).toBe('-')
+  })
+
+  // Those column keys are Istio's. A kind that happens to share them gets
+  // nothing rather than a value read off the wrong shape.
+  it('claims servers and selector only for Istio Gateways', () => {
+    const other = { apiVersion: 'other.io/v1', kind: 'Thing', spec: { servers: [{ port: { number: 1 } }] } }
+    expect(getCellFilterValue(other, 'servers', 'things')).toBe('')
+    expect(getCellFilterValue(other, 'selector', 'things')).toBe('')
+  })
+})
+
+describe('Kyverno Policy filter values', () => {
+  // Reachable only once `policies` normalizes to `kyvernopolicies`; the filter
+  // call sites pass the normalized key, so this is the string they see.
+  it('reads the Kyverno status rather than the generic derivation', () => {
+    const policy = {
+      apiVersion: 'kyverno.io/v1',
+      kind: 'Policy',
+      spec: { rules: [{ name: 'r' }] },
+      status: { conditions: [{ type: 'Ready', status: 'True' }] },
+    }
+    expect(getCellFilterValue(policy, 'status', 'kyvernopolicies')).not.toBe('')
+  })
+})
+
+describe('curated kinds that publish no phase', () => {
+  // Sorting used to derive its own status here rather than reuse the reader the
+  // cell uses. A Gateway has no status.phase, so the sort key came from the
+  // generic ladder — which knows neither Programmed nor Accepted and called
+  // every Gateway "Accepted". A healthy Gateway and a pending one therefore
+  // sorted equal, and neither matched the text on screen.
+  const gateway = (accepted: string, programmed: string) => ({
+    apiVersion: 'gateway.networking.k8s.io/v1',
+    kind: 'Gateway',
+    status: { conditions: [{ type: 'Accepted', status: accepted }, { type: 'Programmed', status: programmed }] },
+  })
+
+  it.each([
+    ['True', 'True', 'Programmed'],
+    ['True', 'False', 'Accepted'],
+    ['False', 'False', 'Not Accepted'],
+  ])('Accepted=%s Programmed=%s sorts and filters on the text the cell shows', (a, p, expected) => {
+    const gw = gateway(a, p)
+    expect(getGatewayStatus(gw).text).toBe(expected)
+    expect(getCellFilterValue(gw, 'status', 'gateways')).toBe(expected)
+  })
+
+  // The reason the shared reader is load-bearing rather than incidental.
+  it('distinguishes a programmed Gateway from a pending one', () => {
+    const ok = getCellFilterValue(gateway('True', 'True'), 'status', 'gateways')
+    const pending = getCellFilterValue(gateway('True', 'False'), 'status', 'gateways')
+    expect(ok).not.toBe(pending)
+    // Both collapse to one value under the generic ladder, which is what made
+    // the column stop sorting.
+    expect(getGenericResourceStatus(gateway('True', 'True'))?.text)
+      .toBe(getGenericResourceStatus(gateway('True', 'False'))?.text)
+  })
+})
+