@skyhook-io/k8s-ui 1.13.0 → 1.13.4

package/src/types/core.ts

@@ -59,6 +59,55 @@ export interface WorkloadWritePermissions {
   rollouts: boolean
 }
 
+export type WorkloadContainerType = 'container' | 'initContainer'
+
+export interface WorkloadContainerImage {
+  type: WorkloadContainerType
+  name: string
+  image: string
+}
+
+export interface WorkloadImageTarget {
+  group: string
+  resource: string
+  kind: string
+  namespace: string
+  name: string
+}
+
+export type WorkloadUpdateBehaviorType =
+  | 'rolling'
+  | 'recreate'
+  | 'paused'
+  | 'onDelete'
+  | 'partitioned'
+  | 'canary'
+  | 'blueGreen'
+
+export interface WorkloadUpdateBehavior {
+  type: WorkloadUpdateBehaviorType
+  partition?: number
+  autoPromote?: boolean
+  gated?: boolean
+}
+
+export interface WorkloadImageInventory {
+  target: WorkloadImageTarget
+  containers: WorkloadContainerImage[]
+  behavior: WorkloadUpdateBehavior
+}
+
+export interface WorkloadImageUpdate {
+  type: WorkloadContainerType
+  name: string
+  previousImage: string
+  image: string
+}
+
+export interface SetWorkloadImagesResult extends WorkloadImageInventory {
+  object: Record<string, unknown>
+}
+
 export interface IntegrationCapability {
   state: CapacityIntegrationState
   reasonCode?: string
@@ -112,6 +161,7 @@ export interface CloudConnectCapability {
 export interface FeatureCapabilities {
   yamlReview?: boolean
   yamlSchemas?: boolean
+  workloadImages?: boolean
 }
 
 // DeploymentMode is the closed set of topologies Radar can run in.
@@ -304,6 +354,7 @@ export interface PodSummary {
 // K8s Event (from SSE stream)
 export interface K8sEvent {
   kind: string
+  group?: string
   namespace: string
   name: string
   operation: 'add' | 'update' | 'delete'
@@ -455,12 +506,15 @@ export interface ClusterInfo {
 // Context info for context switching
 export interface ContextInfo {
   name: string
+  /** Original context name inside its source file. Set for isolated sources
+   *  so display code need not infer backend-added collision qualifiers. */
+  originalName?: string
   cluster: string
   user: string
   namespace: string
   isCurrent: boolean
-  /** Source kubeconfig label (e.g. "kube-cluster-paris"). Set by backend
-   *  only when 2+ kubeconfig files are loaded; empty otherwise. */
+  /** Source kubeconfig label (e.g. "kube-cluster-paris"). Set by the backend
+   *  for contexts loaded through the isolated source registry. */
   source?: string
 }
 
@@ -622,6 +676,7 @@ export type HPADiagnosisState =
   | 'metrics_unavailable'
   | 'metrics_incomplete'
   | 'unable_to_scale'
+  | 'scaled_to_zero'
   | 'disabled'
   | 'pinned'
   | 'stale'
@@ -680,6 +735,7 @@ export interface APIResource {
   name: string // Plural name (e.g., "deployments")
   namespaced: boolean
   isCrd: boolean
+  featured?: boolean
   verbs: string[]
 }
 
@@ -1273,8 +1329,8 @@ export interface AggregatedFlow {
 
 // Cluster info for traffic detection
 export interface TrafficClusterInfo {
-  platform: string // gke, eks, aks, generic
-  cni: string // cilium, calico, flannel, vpc-cni, azure-cni
+  platform: string // rke2, gke, eks, aks, minikube, kind, docker-desktop, openshift, rancher, generic
+  cni: string // cilium, canal, calico, flannel, vpc-cni, azure-cni, gke-native, unknown
   dataplaneV2: boolean
   clusterName?: string
   k8sVersion?: string
@@ -1431,6 +1487,8 @@ export interface WorkloadPodInfo {
   stepID?: string
   stepName?: string
   stepPhase?: string
+  revisionIdentity?: string
+  updatedRevision?: boolean
 }
 
 // SSE event types for workload log streaming

package/src/utils/api-resources.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { categorizeResources, findAPIResourceForRoute, formatGroupName, shortenGroupName } from './api-resources'
+import { categorizeResources, findAPIResourceForRoute, formatGroupName, isCoreBatchJob, shortenGroupName } from './api-resources'
 
 describe('findAPIResourceForRoute', () => {
   const resources = [
@@ -45,6 +45,7 @@ describe('formatGroupName', () => {
     expect(formatGroupName('sql.cnrm.cloud.google.com')).toBe('Config Connector')
     expect(formatGroupName('crd.k8s.amazonaws.com')).toBe('AWS VPC CNI')
     expect(formatGroupName('acid.zalan.do')).toBe('Zalando Postgres')
+    expect(formatGroupName('llm-d.ai')).toBe('llm-d')
   })
 
   it('formats unmapped API groups without exposing raw domain strings', () => {
@@ -86,4 +87,42 @@ describe('categorizeResources', () => {
     expect(networking?.resources.some(r => r.kind === 'WidgetRoute')).toBe(false)
     expect(networkingAPIs?.resources.map(r => r.kind)).toEqual(['WidgetRoute'])
   })
+
+  it('surfaces only the discovered Kubernetes 1.37 APIs in the generic category', () => {
+    const resources = [
+      { group: 'scheduling.k8s.io', version: 'v1beta1', kind: 'Workload', name: 'workloads', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'scheduling.k8s.io', version: 'v1beta1', kind: 'PodGroup', name: 'podgroups', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'scheduling.k8s.io', version: 'v1alpha3', kind: 'CompositePodGroup', name: 'compositepodgroups', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'certificates.k8s.io', version: 'v1', kind: 'PodCertificateRequest', name: 'podcertificaterequests', namespaced: true, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'certificates.k8s.io', version: 'v1', kind: 'ClusterTrustBundle', name: 'clustertrustbundles', namespaced: false, isCrd: false, featured: true, verbs: ['get', 'list', 'watch'] },
+      { group: 'authentication.k8s.io', version: 'v1', kind: 'TokenReview', name: 'tokenreviews', namespaced: false, isCrd: false, verbs: ['list'] },
+    ]
+
+    const category = categorizeResources(resources).find(c => c.name === 'Other Kubernetes APIs')
+    expect(category?.resources.map((resource) => resource.kind)).toEqual([
+      'ClusterTrustBundle',
+      'CompositePodGroup',
+      'PodCertificateRequest',
+      'PodGroup',
+      'Workload',
+    ])
+    expect(category?.resources.some(resource => resource.kind === 'TokenReview')).toBe(false)
+  })
+
+  it('does not invent disabled 1.37 APIs or merge colliding CRDs', () => {
+    const categories = categorizeResources([
+      { group: 'kueue.x-k8s.io', version: 'v1beta1', kind: 'Workload', name: 'workloads', namespaced: true, isCrd: true, verbs: ['list'] },
+    ])
+
+    expect(categories.find(c => c.name === 'Other Kubernetes APIs')).toBeUndefined()
+    expect(categories.find(c => c.name === 'Kueue')?.resources.map(resource => resource.kind)).toEqual(['Workload'])
+  })
+})
+
+describe('isCoreBatchJob', () => {
+  it('distinguishes Kubernetes Jobs from same-kind custom resources', () => {
+    expect(isCoreBatchJob('Job', 'batch')).toBe(true)
+    expect(isCoreBatchJob('jobs')).toBe(true)
+    expect(isCoreBatchJob('Job', 'batch.volcano.sh')).toBe(false)
+  })
 })

package/src/utils/api-resources.ts

@@ -14,7 +14,6 @@ const STORAGE_KINDS = ['PersistentVolumeClaim', 'PersistentVolume', 'StorageClas
 const ACCESS_CONTROL_KINDS = ['ServiceAccount', 'Role', 'ClusterRole', 'RoleBinding', 'ClusterRoleBinding']
 const CLUSTER_KINDS = ['Node', 'Namespace', 'Event']
 const CORE_CATEGORY_NAMES = new Set(['Workloads', 'Networking', 'Configuration', 'Storage', 'Access Control', 'Cluster'])
-
 // Core resources that must always be present (fallback if API discovery misses them)
 export const CORE_RESOURCES: APIResource[] = [
   { group: '', version: 'v1', kind: 'Pod', name: 'pods', namespaced: true, isCrd: false, verbs: ['list', 'get', 'watch'] },
@@ -66,6 +65,11 @@ export function findAPIResourceForRoute(
     ?? resources?.find(matchesRoute)
 }
 
+export function isCoreBatchJob(kind: string, group?: string): boolean {
+  const normalizedKind = kind.toLowerCase()
+  return (normalizedKind === 'job' || normalizedKind === 'jobs') && (!group || group === 'batch')
+}
+
 // Resources that should be hidden from the sidebar
 const HIDDEN_KINDS = ['PodMetrics', 'NodeMetrics']
 
@@ -100,6 +104,7 @@ export function categorizeResources(resources: APIResource[]): ResourceCategory[
   const storage = coreResources.filter(r => STORAGE_KINDS.includes(r.kind))
   const accessControl = coreResources.filter(r => ACCESS_CONTROL_KINDS.includes(r.kind))
   const cluster = coreResources.filter(r => CLUSTER_KINDS.includes(r.kind))
+  const otherKubernetesAPIs = coreResources.filter(r => r.featured)
 
   const crds = uniqueResources.filter(r => r.isCrd)
   const crdGroups = new Map<string, APIResource[]>()
@@ -115,6 +120,7 @@ export function categorizeResources(resources: APIResource[]): ResourceCategory[
   addToCategory('Storage', storage)
   addToCategory('Access Control', accessControl)
   addToCategory('Cluster', cluster)
+  addToCategory('Other Kubernetes APIs', otherKubernetesAPIs)
 
   for (const [group, groupResources] of crdGroups) {
     addToCategory(formatGroupName(group), groupResources)
@@ -215,7 +221,11 @@ export function formatGroupName(group: string): string {
     'jobset.x-k8s.io': 'JobSet',
     'inference.networking.k8s.io': 'Inference Gateway',
     'inference.networking.x-k8s.io': 'Inference Gateway',
+    'llm-d.ai': 'llm-d',
     'nvidia.com': 'NVIDIA GPU Operator',
+    'apps.nvidia.com': 'NVIDIA NIM',
+    'amd.com': 'AMD GPU Operator',
+    'trainer.kubeflow.org': 'Kubeflow',
     'scheduling.run.ai': 'KAI Scheduler',
     'kai.scheduler': 'KAI Scheduler',
     'kaito.sh': 'KAITO',

package/src/utils/applications.ts

@@ -1,4 +1,5 @@
 import type { ResourceRef } from '../types/core'
+import { rolloutActivityLevel, type WorkloadRolloutActivity } from './workload-rollout'
 
 // Shared model for the Applications surface — host-agnostic. The OSS single-
 // cluster view and (eventually) the Cloud fleet view both build on these types
@@ -26,9 +27,58 @@ export interface AppWorkload {
   desired: number;
   restarts: number;
   reason?: string;
+  rollout?: WorkloadRolloutActivity;
   batch?: AppBatchSummary;
 }
 
+export interface AppRolloutSummary {
+  count: number
+  label: string
+  detail: string
+  details: string[]
+  health: AppHealth
+}
+
+export function rolloutDisplayHealth(activity: WorkloadRolloutActivity, workloadHealth: string): AppHealth {
+  const rolloutHealth: AppHealth = rolloutActivityLevel(activity)
+  const servingHealth = healthOf(workloadHealth)
+  return servingHealth === 'healthy' || servingHealth === 'neutral'
+    ? rolloutHealth
+    : worstHealth([rolloutHealth, servingHealth])
+}
+
+export function rolloutSummaryForApps(apps: AppRow[]): AppRolloutSummary | null {
+  const entries = apps.flatMap((app) => app.workloads
+    .filter((workload) => workload.rollout && (workload.rollout.active || workload.rollout.phase === 'stalled'))
+    .map((workload) => ({ app, workload, rollout: workload.rollout! })))
+  if (entries.length === 0) return null
+  const rank = (phase: WorkloadRolloutActivity['phase']) => {
+    if (phase === 'stalled') return 3
+    if (phase === 'paused') return 2
+    return 1
+  }
+  const worst = entries.reduce((current, entry) => rank(entry.rollout.phase) > rank(current.rollout.phase) ? entry : current)
+  const health = entries.reduce<AppHealth>(
+    (current, entry) => worstHealth([current, rolloutDisplayHealth(entry.rollout, entry.workload.health)]),
+    'neutral',
+  )
+  const stalled = entries.filter((entry) => entry.rollout.phase === 'stalled').length
+  const label = entries.length === 1
+    ? worst.rollout.label
+    : stalled > 0
+      ? stalled === entries.length
+        ? `${stalled} stalled`
+        : `${stalled} stalled · ${entries.length - stalled} waiting`
+      : `${entries.length} updating`
+  const details = entries.map(({ app, workload, rollout }) => {
+    const prefix = apps.length > 1 ? `${app.name} / ` : ''
+    return `${prefix}${workload.name}: ${rollout.label}${rollout.detail ? ` — ${rollout.detail}` : ''}`
+  })
+  const visibleDetails = details.slice(0, 8)
+  const detail = `${visibleDetails.join(' · ')}${details.length > visibleDetails.length ? ` · +${details.length - visibleDetails.length} more` : ''}`
+  return { count: entries.length, label, detail, details, health }
+}
+
 export interface AppBatchSummary {
   schedule?: string;
   suspended?: boolean;

package/src/utils/bulk-workload-actions.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest'
 import {
   canBulkRestartKind,
   canBulkScaleKind,
+  canPatchWorkloadKind,
+  canSetWorkloadImages,
   intersectWorkloadWrites,
 } from './bulk-workload-actions'
 import type { Capabilities, WorkloadWritePermissions } from '../types/core'
@@ -28,6 +30,24 @@ describe('bulk workload action gating', () => {
     expect(canBulkRestartKind({ name: 'rollouts', group: 'argoproj.io' }, all)).toBe(true)
   })
 
+  it('shares exact group and kind checks with detail patch actions', () => {
+    const all = writes({ deployments: true, daemonSets: true, statefulSets: true, rollouts: true })
+
+    expect(canPatchWorkloadKind({ name: 'deployments', group: 'apps' }, all)).toBe(true)
+    expect(canPatchWorkloadKind({ name: 'rollouts', group: 'argoproj.io' }, all)).toBe(true)
+    expect(canPatchWorkloadKind({ name: 'deployments', group: 'example.com' }, all)).toBe(false)
+    expect(canPatchWorkloadKind({ name: 'services', group: '' }, all)).toBe(false)
+    expect(canPatchWorkloadKind({ name: 'deployments', group: 'apps' }, undefined)).toBe(false)
+  })
+
+  it('requires an explicit server advertisement for image updates', () => {
+    const all = writes({ deployments: true })
+
+    expect(canSetWorkloadImages({ name: 'deployments', group: 'apps' }, all, true)).toBe(true)
+    expect(canSetWorkloadImages({ name: 'deployments', group: 'apps' }, all, false)).toBe(false)
+    expect(canSetWorkloadImages({ name: 'deployments', group: 'apps' }, undefined, true)).toBe(false)
+  })
+
   it('requires the apps group for built-in workload restart', () => {
     const all = writes({ deployments: true, daemonSets: true, statefulSets: true })
 

package/src/utils/bulk-workload-actions.ts

@@ -8,6 +8,13 @@ export type BulkWorkloadKindInfo = {
 export function canBulkRestartKind(
   kind: BulkWorkloadKindInfo | null | undefined,
   writes: WorkloadWritePermissions | undefined,
+): boolean {
+  return canPatchWorkloadKind(kind, writes)
+}
+
+export function canPatchWorkloadKind(
+  kind: BulkWorkloadKindInfo | null | undefined,
+  writes: WorkloadWritePermissions | undefined,
 ): boolean {
   switch (kind?.name.toLowerCase()) {
     case 'deployments':
@@ -23,6 +30,14 @@ export function canBulkRestartKind(
   }
 }
 
+export function canSetWorkloadImages(
+  kind: BulkWorkloadKindInfo | null | undefined,
+  writes: WorkloadWritePermissions | undefined,
+  supported: boolean,
+): boolean {
+  return supported && canPatchWorkloadKind(kind, writes)
+}
+
 export function canBulkScaleKind(
   kind: BulkWorkloadKindInfo | null | undefined,
   writes: WorkloadWritePermissions | undefined,

package/src/utils/clipboard.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { copyText } from './clipboard'
+
+function fallbackDocument(copied: boolean) {
+  const document = {
+    createElement: vi.fn(() => textarea),
+    body: { appendChild: vi.fn() },
+    execCommand: vi.fn(() => copied),
+    activeElement: null as unknown,
+  }
+  const textarea = {
+    value: '',
+    style: {} as CSSStyleDeclaration,
+    setAttribute: vi.fn(),
+    select: vi.fn(() => { document.activeElement = textarea }),
+    setSelectionRange: vi.fn(),
+    remove: vi.fn(),
+  }
+  return { document, textarea }
+}
+
+describe('copyText', () => {
+  it('uses the synchronous fallback when the Clipboard API is unavailable on HTTP', async () => {
+    const { document } = fallbackDocument(true)
+
+    await expect(copyText('busybox', undefined, document as unknown as Document)).resolves.toBe(true)
+
+    expect(document.execCommand).toHaveBeenCalledWith('copy')
+  })
+
+  it('falls back to a synchronous copy command when the Clipboard API rejects', async () => {
+    const clipboard = { writeText: vi.fn().mockRejectedValue(new DOMException('Blocked', 'NotAllowedError')) }
+    const { document, textarea } = fallbackDocument(true)
+
+    await expect(copyText('busybox', clipboard, document as unknown as Document)).resolves.toBe(true)
+
+    expect(clipboard.writeText).toHaveBeenCalledWith('busybox')
+    expect(document.body.appendChild).toHaveBeenCalledWith(textarea)
+    expect(textarea.value).toBe('busybox')
+    expect(textarea.select).toHaveBeenCalledOnce()
+    expect(document.execCommand).toHaveBeenCalledWith('copy')
+    expect(textarea.remove).toHaveBeenCalledOnce()
+  })
+
+  it('restores focus to the previously active element without scrolling', async () => {
+    const { document } = fallbackDocument(true)
+    const previouslyFocused = { focus: vi.fn(), isConnected: true }
+    document.activeElement = previouslyFocused
+
+    await expect(copyText('busybox', undefined, document as unknown as Document)).resolves.toBe(true)
+
+    expect(previouslyFocused.focus).toHaveBeenCalledWith({ preventScroll: true })
+  })
+
+  it('leaves focus alone when a copy handler focused something else', async () => {
+    const { document, textarea } = fallbackDocument(true)
+    const previouslyFocused = { focus: vi.fn(), isConnected: true }
+    document.activeElement = previouslyFocused
+    const somethingElse = {}
+    textarea.select.mockImplementation(() => { document.activeElement = somethingElse })
+
+    await expect(copyText('busybox', undefined, document as unknown as Document)).resolves.toBe(true)
+
+    expect(previouslyFocused.focus).not.toHaveBeenCalled()
+  })
+
+  it('does not refocus an element that left the DOM during the copy', async () => {
+    const { document } = fallbackDocument(true)
+    const previouslyFocused = { focus: vi.fn(), isConnected: false }
+    document.activeElement = previouslyFocused
+
+    await expect(copyText('busybox', undefined, document as unknown as Document)).resolves.toBe(true)
+
+    expect(previouslyFocused.focus).not.toHaveBeenCalled()
+  })
+
+  it('does not create a fallback element when the Clipboard API succeeds', async () => {
+    const clipboard = { writeText: vi.fn().mockResolvedValue(undefined) }
+    const { document } = fallbackDocument(true)
+
+    await expect(copyText('busybox', clipboard, document as unknown as Document)).resolves.toBe(true)
+
+    expect(document.createElement).not.toHaveBeenCalled()
+  })
+})

package/src/utils/clipboard.ts

@@ -0,0 +1,50 @@
+type ClipboardWriter = Pick<Clipboard, 'writeText'>
+
+/**
+ * Copy text from a user gesture, including pages served from an insecure origin.
+ * The async Clipboard API is unavailable or rejects on plain HTTP, while the
+ * legacy command remains permitted when it runs synchronously from the click.
+ */
+export async function copyText(
+  text: string,
+  clipboard: ClipboardWriter | undefined = typeof navigator === 'undefined' ? undefined : navigator.clipboard,
+  doc: Document | undefined = typeof document === 'undefined' ? undefined : document,
+): Promise<boolean> {
+  if (clipboard?.writeText) {
+    try {
+      await clipboard.writeText(text)
+      return true
+    } catch {
+      // Fall through for insecure origins and denied Clipboard API access.
+    }
+  }
+
+  if (!doc?.body) return false
+
+  const previouslyFocused = doc.activeElement as { focus?: (options?: FocusOptions) => void; isConnected?: boolean } | null
+  const textarea = doc.createElement('textarea')
+  textarea.value = text
+  textarea.readOnly = true
+  textarea.setAttribute('aria-hidden', 'true')
+  textarea.style.position = 'fixed'
+  textarea.style.opacity = '0'
+  textarea.style.pointerEvents = 'none'
+
+  try {
+    doc.body.appendChild(textarea)
+    textarea.select()
+    textarea.setSelectionRange(0, text.length)
+    return doc.execCommand('copy')
+  } catch {
+    return false
+  } finally {
+    // Restore focus only when the textarea still owns it — a copy handler may
+    // have legitimately focused something else — and without scrolling a
+    // now-offscreen element back into view.
+    const textareaOwnsFocus = doc.activeElement === (textarea as unknown as Element)
+    textarea.remove()
+    if (textareaOwnsFocus && previouslyFocused?.isConnected !== false) {
+      previouslyFocused?.focus?.({ preventScroll: true })
+    }
+  }
+}

package/src/utils/extended-resources.ts

@@ -2,7 +2,7 @@
 // the GPU views. Keep all effective-request math here — K8s semantics for
 // extended resources are subtle and must not be reimplemented per call site.
 
-import { parseMemoryToBytes } from './format'
+import { parseQuantityToNumber } from './format'
 
 const STANDARD_NODE_RESOURCES = new Set(['cpu', 'memory', 'pods', 'ephemeral-storage'])
 
@@ -48,14 +48,11 @@ export function getEffectiveResources(resources: any): Record<string, string> {
 }
 
 // K8s quantity → number. Counts are usually plain integers, but quantities may
-// legally carry suffixes: "3000m" is 3, "3k" is 3000.
+// legally carry suffixes: "3000m" is 3, "3k" is 3000. The shared quantity
+// parser is the one place that knows the suffix table.
 function asCount(value: unknown): number {
   if (typeof value === 'number') return Number.isFinite(value) ? value : 0
-  const s = String(value ?? '').trim()
-  if (!s) return 0
-  if (/^\d+(\.\d+)?m$/.test(s)) return Number(s.slice(0, -1)) / 1000
-  const n = parseMemoryToBytes(s)
-  return Number.isFinite(n) ? n : 0
+  return parseQuantityToNumber(String(value ?? ''))
 }
 
 function containerGpuCount(container: any): number {

package/src/utils/format.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { formatCPUString, formatMemoryString, parseMemoryToBytes } from './format'
+import { formatCPUString, formatMemoryString, parseMemoryToBytes, parseQuantityToNumber } from './format'
 
 describe('formatCPUString', () => {
   it('renders exact zero as zero, not a fabricated near-zero', () => {
@@ -32,4 +32,86 @@ describe('parseMemoryToBytes', () => {
     expect(parseMemoryToBytes('-1Ki')).toBe(-1024)
     expect(parseMemoryToBytes('1Ki')).toBe(1024)
   })
+
+  // Aggregate cluster memory reaches suffixes a single node never carries —
+  // "1Pi" must not fall through to the bare-number fallback and read as 1 byte.
+  it('parses the large suffixes an aggregate capacity can carry', () => {
+    expect(parseMemoryToBytes('1Pi')).toBe(1024 ** 5)
+    expect(parseMemoryToBytes('1Ei')).toBe(1024 ** 6)
+    expect(parseMemoryToBytes('1P')).toBe(1000 ** 5)
+    expect(parseMemoryToBytes('1E')).toBe(1000 ** 6)
+  })
+})
+
+describe('parseQuantityToNumber', () => {
+  // The reported bug. A Quantity's canonical form collapses trailing zeros into
+  // an SI suffix, so a node started with --max-pods=1000 reports "1k". Read as
+  // a raw integer that is 1, and a node running 216 pods rendered as 216 / 1
+  // with the usage bar pegged at 21600%.
+  it('reads a pod capacity of 1000 as 1000, not 1', () => {
+    expect(parseQuantityToNumber('1k')).toBe(1000)
+    expect((216 / parseQuantityToNumber('1k')) * 100).toBeCloseTo(21.6)
+  })
+
+  it('only collapses zeros in groups of three, so nearby counts are unchanged', () => {
+    expect(parseQuantityToNumber('2k')).toBe(2000)
+    expect(parseQuantityToNumber('1020')).toBe(1020)
+    expect(parseQuantityToNumber('990')).toBe(990)
+    expect(parseQuantityToNumber('216')).toBe(216)
+  })
+
+  it('handles the sub-unit decimal suffixes a count can legally carry', () => {
+    expect(parseQuantityToNumber('3000m')).toBe(3)
+    expect(parseQuantityToNumber('1500m')).toBe(1.5)
+    expect(parseQuantityToNumber('1000000u')).toBe(1)
+    expect(parseQuantityToNumber('1000000000n')).toBe(1)
+  })
+
+  it('handles the whole decimal SI range', () => {
+    expect(parseQuantityToNumber('5M')).toBe(5e6)
+    expect(parseQuantityToNumber('5G')).toBe(5e9)
+    expect(parseQuantityToNumber('5T')).toBe(5e12)
+    expect(parseQuantityToNumber('5P')).toBe(5e15)
+    expect(parseQuantityToNumber('5E')).toBe(5e18)
+  })
+
+  it('handles binary suffixes in powers of 1024', () => {
+    expect(parseQuantityToNumber('1Ki')).toBe(1024)
+    expect(parseQuantityToNumber('2Gi')).toBe(2 * 1024 ** 3)
+    expect(parseQuantityToNumber('1Ei')).toBe(1024 ** 6)
+  })
+
+  // "1E3" is the exponent form (1000), while "1E" is exa. Deciding the exponent
+  // first is what keeps the two apart.
+  it('reads the decimal-exponent form without confusing it for exa', () => {
+    expect(parseQuantityToNumber('1e3')).toBe(1000)
+    expect(parseQuantityToNumber('1E3')).toBe(1000)
+    expect(parseQuantityToNumber('1.5e3')).toBe(1500)
+    expect(parseQuantityToNumber('1e-3')).toBe(0.001)
+    expect(parseQuantityToNumber('1E')).toBe(1e18)
+  })
+
+  it('preserves the sign', () => {
+    expect(parseQuantityToNumber('-1k')).toBe(-1000)
+    expect(parseQuantityToNumber('+1k')).toBe(1000)
+  })
+
+  // A number this cannot read is reported as unknown so the caller can fall back,
+  // rather than becoming a plausible-looking wrong number on screen.
+  it('yields zero for input it cannot parse rather than guessing', () => {
+    expect(parseQuantityToNumber('1z')).toBe(0)
+    expect(parseQuantityToNumber('1KB')).toBe(0)
+    expect(parseQuantityToNumber('abc')).toBe(0)
+    expect(parseQuantityToNumber('')).toBe(0)
+    expect(parseQuantityToNumber('   ')).toBe(0)
+    expect(parseQuantityToNumber(null)).toBe(0)
+    expect(parseQuantityToNumber(undefined)).toBe(0)
+  })
+
+  it('passes through numbers the API already decoded, and rejects non-finite ones', () => {
+    expect(parseQuantityToNumber(216)).toBe(216)
+    expect(parseQuantityToNumber(0)).toBe(0)
+    expect(parseQuantityToNumber(Number.NaN)).toBe(0)
+    expect(parseQuantityToNumber(Number.POSITIVE_INFINITY)).toBe(0)
+  })
 })