@skyhook-io/k8s-ui 1.14.9 → 1.14.11

package/src/components/resources/resource-utils-ray.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { getRayCronJobTimeZone, getRayCronJobStatus } from './resource-utils-ray'
+import { getRayCronJobTimeZone, getRayCronJobStatus, getRayServiceStatus } from './resource-utils-ray'
 import { getCellFilterValue } from './resource-utils'
 
 describe('getRayCronJobTimeZone', () => {
@@ -34,3 +34,60 @@ describe('getCellFilterValue for raycronjobs timeZone', () => {
       .toBe('Europe/Berlin')
   })
 })
+
+
+describe('RayService observed lifecycle', () => {
+  const data = (conditions: any[], spec = {}) => ({ metadata: { generation: 3 }, spec, status: { observedGeneration: 3, conditions } })
+  it('prioritizes observed rollback over upgrade without hiding readiness in the detail', () => {
+    expect(getRayServiceStatus(data(['Ready', 'UpgradeInProgress', 'RollbackInProgress'].map(type => ({ type, status: 'True' })))).text).toBe('RollingBack')
+  })
+  it('does not treat requested suspension as completed teardown', () => {
+    expect(getRayServiceStatus(data([], { suspend: true })).text).toBe('Suspension requested')
+    expect(getRayServiceStatus(data([{ type: 'Ready', status: 'True' }], { suspend: true })).text).toBe('Ready')
+    expect(getRayServiceStatus(data([{ type: 'Suspending', status: 'True' }], { suspend: false })).text).toBe('Suspending')
+    expect(getRayServiceStatus(data([{ type: 'Suspended', status: 'True' }])).text).toBe('Suspended')
+  })
+  it('retains stale and unknown observations without using deprecated Running as proof', () => {
+    expect(getRayServiceStatus(data([{ type: 'Ready', status: 'False', observedGeneration: 2 }])).text).toBe('NotReady')
+    for (const [status, label] of [['True', 'Ready'], ['False', 'NotReady'], ['Unknown', 'Unknown']]) {
+      const resource = data([{ type: 'Ready', status }])
+      resource.status.observedGeneration = 2
+      expect(getRayServiceStatus(resource).text).toBe(status === 'True' ? `${label} (stale)` : label)
+    }
+    for (const condition of [{ type: 'Suspending', status: 'True' }, { type: 'Ready', status: 'False', reason: 'ValidationFailed' }, { type: 'Ready', status: 'False', reason: 'InitializingTimeout' }]) {
+      const resource = data([condition], { suspend: false })
+      resource.status.observedGeneration = 2
+      expect(getRayServiceStatus(resource).text).toBe(condition.reason || condition.type)
+    }
+    const suspended = data([{ type: 'Suspended', status: 'True' }], { suspend: true })
+    suspended.status.observedGeneration = 2
+    expect(getRayServiceStatus(suspended).text).toBe('Suspended')
+    expect(getRayServiceStatus({ status: { serviceStatus: 'Running', conditions: [{ type: 'Ready', status: 'Unknown' }] } }).text).toBe('Unknown')
+    expect(getRayServiceStatus({ status: { serviceStatus: 'Running' } }).text).toBe('Unknown')
+  })
+})
+
+import { getRayClusterStatus, getRayClusterWorkers, rayClusterWorkerCounts } from './resource-utils-ray'
+
+describe('RayCluster readiness', () => {
+  const root = (status: any = {}, spec = {}) => ({ metadata: { generation: 2 }, spec, status: { observedGeneration: 2, conditions: [{ type: 'HeadPodReady', status: 'True' }], ...status } })
+  it('distinguishes running from ready and does not bless unready excess workers', () => {
+    expect(getRayClusterStatus(root({ readyWorkerReplicas: 1, availableWorkerReplicas: 2, desiredWorkerReplicas: 2 })).level).toBe('degraded')
+    expect(getRayClusterStatus(root({ readyWorkerReplicas: 1, availableWorkerReplicas: 2, desiredWorkerReplicas: 1 })).level).toBe('degraded')
+    expect(getRayClusterStatus(root({ readyWorkerReplicas: 2, availableWorkerReplicas: 2, desiredWorkerReplicas: 2 })).text).toBe('Ready')
+    expect(getRayClusterWorkers(root({ readyWorkerReplicas: 1, availableWorkerReplicas: 2, desiredWorkerReplicas: 2 }))).toBe('1/2')
+  })
+  it('decodes native omitted zeros only after a witnessed reconciliation', () => {
+    expect(rayClusterWorkerCounts(root())).toEqual({ ready: 0, running: 0, desired: 0 })
+    expect(getRayClusterStatus(root()).text).toBe('Ready')
+    expect(getRayClusterWorkers({})).toBe('?/?')
+    expect(getRayClusterStatus(root({ observedGeneration: undefined })).text).toBe('Head ready')
+  })
+  it('separates suspension intent and historical observations from health', () => {
+    expect(getRayClusterStatus(root({}, { suspend: true })).text).toBe('Suspension requested')
+    expect(getRayClusterStatus(root({ conditions: [{ type: 'RayClusterSuspended', status: 'True' }] })).text).toBe('Suspended')
+    expect(getRayClusterStatus(root({ observedGeneration: 1 })).level).toBe('unknown')
+    expect(getRayClusterStatus(root({ state: 'ready', conditions: [] })).level).toBe('unknown')
+    expect(getRayClusterStatus(root({ conditions: [{ type: 'RayClusterProvisioned', status: 'True' }] })).level).toBe('neutral')
+  })
+})

package/src/components/resources/resource-utils-ray.ts

@@ -7,60 +7,35 @@ import { healthColors, formatAge } from './resource-utils'
 // RAYCLUSTER UTILITIES
 // ============================================================================
 
-export function getRayClusterStatus(resource: any): StatusBadge {
-  const state = resource.status?.state
-  const conditions = resource.status?.conditions || []
-
-  const suspendingCond = conditions.find((c: any) => c.type === 'RayClusterSuspending')
-  if (suspendingCond?.status === 'True') {
-    return { text: 'Suspending', color: healthColors.degraded, level: 'degraded' }
-  }
-
-  const suspendedCond = conditions.find((c: any) => c.type === 'RayClusterSuspended')
-  if (suspendedCond?.status === 'True') {
-    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
-  }
-
-  if (resource.spec?.suspend === true || state === 'suspended') {
-    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
-  }
-
-  const replicaFailureCond = conditions.find((c: any) => c.type === 'RayClusterReplicaFailure')
-  if (replicaFailureCond?.status === 'True') {
-    return { text: replicaFailureCond.reason || 'ReplicaFailure', color: healthColors.unhealthy, level: 'unhealthy' }
-  }
-
-  if (state === 'failed') {
-    return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
-  }
-
-  const headReadyCond = conditions.find((c: any) => c.type === 'HeadPodReady')
-  if (headReadyCond?.status === 'False') {
-    return { text: headReadyCond.reason || 'HeadNotReady', color: healthColors.degraded, level: 'degraded' }
-  }
-  if (headReadyCond?.status === 'True') {
-    const availableWorkers = resource.status?.availableWorkerReplicas ?? 0
-    const desiredWorkers = resource.status?.desiredWorkerReplicas ?? 0
-    if (availableWorkers >= desiredWorkers) {
-      return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
-    }
-    return { text: `Workers ${availableWorkers}/${desiredWorkers}`, color: healthColors.degraded, level: 'degraded' }
-  }
-
-  if (conditions.length === 0 && state === 'ready') {
-    return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
-  }
-
-  const provisionedCond = conditions.find((c: any) => c.type === 'RayClusterProvisioned')
-  if (provisionedCond?.status === 'True') {
-    return { text: 'Provisioned', color: healthColors.neutral, level: 'neutral' }
-  }
-
-  if (resource.status) {
-    return { text: 'Provisioning', color: healthColors.degraded, level: 'degraded' }
-  }
+export function rayClusterWorkerCounts(resource: any): { ready?: number; running?: number; desired?: number } {
+  const status = resource.status ?? {}
+  // Native integer counters omit zero; observedGeneration witnesses their shared status write.
+  const count = (key: string) => status[key] ?? (status.observedGeneration > 0 ? 0 : undefined)
+  return { ready: count('readyWorkerReplicas'), running: count('availableWorkerReplicas'), desired: count('desiredWorkerReplicas') }
+}
 
-  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+export function getRayClusterStatus(resource: any): StatusBadge {
+  const conditions = resource.status?.conditions ?? []
+  const condition = (type: string) => conditions.find((c: any) => c.type === type)
+  const badge = (text: string, level: StatusBadge['level']): StatusBadge => ({ text, level, color: healthColors[level!] })
+  if (isRayObservationStale(resource.metadata?.generation, resource.status?.observedGeneration)) return badge('Status stale', 'unknown')
+  if (condition('RayClusterSuspending')?.status === 'True') return badge('Suspending', 'degraded')
+  if (condition('RayClusterSuspended')?.status === 'True') return badge('Suspended', 'neutral')
+  if (resource.spec?.suspend === true) return badge('Suspension requested', 'neutral')
+  const failure = condition('RayClusterReplicaFailure')
+  if (failure?.status === 'True') return badge(failure.reason || 'Replica failure', 'unhealthy')
+  if (resource.status?.state === 'failed') return badge('Failed', 'unhealthy')
+  const head = condition('HeadPodReady')
+  if (head?.status === 'False') return badge(head.reason || 'Head not ready', 'degraded')
+  if (head?.status === 'True') {
+    const { ready, running, desired } = rayClusterWorkerCounts(resource)
+    if (ready == null || desired == null) return badge('Head ready', 'neutral')
+    if (ready >= desired && (running == null || ready >= running)) return badge('Ready', 'healthy')
+    if (ready >= desired && running != null && running > ready) return badge(`${running - ready} workers unready`, 'degraded')
+    return badge(`Workers ${ready}/${desired} ready`, 'degraded')
+  }
+  if (condition('RayClusterProvisioned')?.status === 'True') return badge('Provisioned', 'neutral')
+  return badge('Unknown', 'unknown')
 }
 
 export function getRayClusterVersion(resource: any): string {
@@ -68,11 +43,8 @@ export function getRayClusterVersion(resource: any): string {
 }
 
 export function getRayClusterWorkers(resource: any): string {
-  const status = resource.status
-  if (!status) return '-'
-  const available = status.availableWorkerReplicas ?? 0
-  const desired = status.desiredWorkerReplicas ?? 0
-  return `${available}/${desired}`
+  const { ready, desired } = rayClusterWorkerCounts(resource)
+  return `${ready ?? '?'}/${desired ?? '?'}`
 }
 
 export function getRayClusterHeadService(resource: any): string {
@@ -137,41 +109,35 @@ export function getRayJobClusterName(resource: any): string {
 // RAYSERVICE UTILITIES
 // ============================================================================
 
-export function getRayServiceStatus(resource: any): StatusBadge {
-  const conditions = resource.status?.conditions || []
-
-  const suspendingCond = conditions.find((c: any) => c.type === 'Suspending')
-  if (suspendingCond?.status === 'True') {
-    return { text: 'Suspending', color: healthColors.degraded, level: 'degraded' }
-  }
-
-  const suspendedCond = conditions.find((c: any) => c.type === 'Suspended')
-  if (suspendedCond?.status === 'True' || resource.spec?.suspend === true) {
-    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
-  }
-
-  const upgradeCond = conditions.find((c: any) => c.type === 'UpgradeInProgress')
-  if (upgradeCond?.status === 'True') {
-    return { text: 'Upgrading', color: healthColors.degraded, level: 'degraded' }
-  }
-
-  const rollbackCond = conditions.find((c: any) => c.type === 'RollbackInProgress')
-  if (rollbackCond?.status === 'True') {
-    return { text: 'RollingBack', color: healthColors.degraded, level: 'degraded' }
-  }
+export function isRayObservationStale(generation?: number, observedGeneration?: number): boolean {
+  return generation != null && observedGeneration != null && observedGeneration < generation
+}
 
-  const readyCond = conditions.find((c: any) => c.type === 'Ready')
-  if (readyCond?.status === 'True') {
-    return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
-  }
-  if (readyCond?.status === 'False') {
-    return { text: readyCond.reason || 'NotReady', color: healthColors.degraded, level: 'degraded' }
-  }
+// KubeRay can freeze observedGeneration during validation failures and suspension.
+export function isRayServiceConditionStale(resource: any, condition: any): boolean {
+  return condition?.status === 'True' && ['Ready', 'UpgradeInProgress', 'RollbackInProgress'].includes(condition.type)
+    && isRayObservationStale(resource.metadata?.generation, resource.status?.observedGeneration)
+}
 
-  if (resource.status?.serviceStatus === 'Running') {
-    return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+export function getRayServiceStatus(resource: any): StatusBadge {
+  const conditions = resource.status?.conditions ?? []
+  const labels: Record<string, string> = { Suspending: 'Suspending', Suspended: 'Suspended', RollbackInProgress: 'RollingBack', UpgradeInProgress: 'Upgrading' }
+  for (const type of ['Suspending', 'Suspended', 'RollbackInProgress', 'UpgradeInProgress', 'Ready']) {
+    const condition = conditions.find((c: any) => c.type === type)
+    if (!condition || (type !== 'Ready' && condition.status !== 'True')) continue
+    const label = type === 'Ready' ? (condition.status === 'True' ? 'Ready' : condition.status === 'False' ? condition.reason || 'NotReady' : 'Unknown') : labels[type]
+    if (isRayServiceConditionStale(resource, condition)) {
+      return { text: `${label} (stale)`, color: healthColors.unknown, level: 'unknown' }
+    }
+    if (type === 'Ready') {
+      if (condition.status === 'True') return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
+      if (condition.status === 'False') return { text: condition.reason || 'NotReady', color: healthColors.degraded, level: 'degraded' }
+      return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+    }
+    const level = type === 'Suspended' ? 'neutral' : 'degraded'
+    return { text: labels[type], color: healthColors[level], level }
   }
-
+  if (resource.spec?.suspend === true) return { text: 'Suspension requested', color: healthColors.neutral, level: 'neutral' }
   return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
 }
 

package/src/components/shared/ResourceRendererDispatch.test.tsx

@@ -944,17 +944,64 @@ describe('GPU ecosystem kind collisions', () => {
 })
 
 describe('GPU ecosystem status edge cases', () => {
-  it('JobSet with minimal status is Pending, not Running', () => {
+  it('dispatches the current JobSet API to typed detail', () => {
+    const html = renderKind('jobsets', {
+      apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      kind: 'JobSet',
+      metadata: { name: 'training', namespace: 'ml' },
+      spec: { replicatedJobs: [{ name: 'workers', replicas: 2, template: { spec: {} } }] },
+      status: { replicatedJobsStatus: [{ name: 'workers', active: 1, ready: 1, succeeded: 0, failed: 0, suspended: 0 }] },
+    }, 'ml')
+
+    expect(html).toContain('JobSet status')
+    expect(html).toContain('Replicated jobs (1)')
+    expect(html).not.toContain('Specification')
+  })
+
+  it.each(['jobset.x-k8s.io/v1alpha1', 'batch.example.io/v1'])(
+    'keeps unsupported or foreign JobSet collisions generic for %s',
+    (apiVersion) => {
+      const data = {
+        apiVersion,
+        kind: 'JobSet',
+        metadata: { name: 'foreign', namespace: 'ml' },
+        spec: { collisionProbe: COLLISION_PROBE },
+      }
+      const html = renderKind('jobsets', data, 'ml')
+
+      expect(html).toContain(COLLISION_PROBE)
+      expect(html).not.toContain('JobSet status')
+      expect(getResourceStatus('jobsets', data)).toBeNull()
+    },
+  )
+
+  it('JobSet distinguishes observed inactivity from active child Jobs', () => {
     const fresh = getResourceStatus('jobsets', {
       apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      kind: 'JobSet',
       status: { replicatedJobsStatus: [{ name: 'w', active: 0, ready: 0 }] },
     })
     const live = getResourceStatus('jobsets', {
       apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      kind: 'JobSet',
       status: { replicatedJobsStatus: [{ name: 'w', active: 1, ready: 1 }] },
     })
     expect(fresh?.text).toBe('Pending')
-    expect(live?.text).toBe('Running')
+    expect(live?.text).toBe('Active')
+  })
+
+  it('keeps a wrong-kind object generic even at the supported JobSet API version', () => {
+    const data = {
+      apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      kind: 'OtherSet',
+      metadata: { name: 'collision', namespace: 'ml' },
+      spec: { collisionProbe: COLLISION_PROBE },
+    }
+    const html = renderKind('jobsets', data, 'ml')
+
+    expect(html).toContain(COLLISION_PROBE)
+    expect(html).not.toContain('JobSet status')
+    expect(getResourceStatus('jobsets', data)).toBeNull()
   })
 
   it('InferencePool with only an empty-parentRef default entry reads Not referenced', () => {
@@ -965,3 +1012,71 @@ describe('GPU ecosystem status edge cases', () => {
     expect(pool?.text).toBe('Not referenced')
   })
 })
+
+describe('Kueue Workload detail dispatch', () => {
+  it.each(['kueue.x-k8s.io/v1beta1', 'kueue.x-k8s.io/v1beta2'])('renders %s with curated admission detail', (apiVersion) => {
+    expect(renderKind('workloads', { apiVersion, kind: 'Workload', spec: { podSets: [] } })).toContain('No PodSets declared')
+  })
+  it.each(['example.com/v1', 'fake.kueue.x-k8s.io/v1', undefined])('leaves %s generic', (apiVersion) => {
+    const data = { apiVersion, kind: 'Workload', spec: { uniqueForeignField: 'visible' } }
+    const html = renderKind('workloads', data)
+    expect(html).not.toContain('No PodSets declared')
+    expect(html).toContain('visible')
+    expect(getResourceStatus('workloads', data)).toBeNull()
+  })
+})
+
+describe('Kueue queue detail dispatch', () => {
+  it.each(['localqueues', 'clusterqueues'])('curates supported %s and preserves foreign and future versions', (kind) => {
+    for (const version of ['v1beta1', 'v1beta2']) {
+      expect(renderKind(kind, { apiVersion: `kueue.x-k8s.io/${version}`, spec: {} })).toContain('Queue Status')
+    }
+    for (const apiVersion of ['example.com/v1', 'fake.kueue.x-k8s.io/v1', 'kueue.x-k8s.io/v99']) {
+      const html = renderKind(kind, { apiVersion, spec: { foreignField: 'preserved-value' } })
+      expect(html).not.toContain('Queue Status')
+      expect(html).toContain('preserved-value')
+    }
+  })
+})
+
+describe('Kueue provisioning detail identity', () => {
+  it('dispatches supported versions only, preserving foreign same-kind generic rendering', () => {
+    for (const [kind, group, versions, title] of [
+      ['admissionchecks', 'kueue.x-k8s.io', ['v1beta1', 'v1beta2'], 'Check Controller'],
+      ['provisioningrequests', 'autoscaling.x-k8s.io', ['v1beta1', 'v1'], 'Requested Pod Sets'],
+    ] as const) {
+      for (const version of versions) {
+        const html = renderKind(kind, { apiVersion: `${group}/${version}`, spec: { controllerName: 'test-controller', provisioningClassName: 'test-class' } })
+        expect(html).toContain(title)
+        expect(html).not.toContain('This resource type doesn')
+        expect(html).not.toContain('Configuration')
+      }
+      expect(renderKind(kind, { apiVersion: 'foreign.io/v1', spec: {} })).not.toContain(title)
+      expect(renderKind(kind, { apiVersion: `${group}/v99`, spec: {} })).not.toContain(title)
+    }
+  })
+})
+
+describe('RayService native detail identity', () => {
+  it('renders the exact supported version once and leaves foreign/future resources generic', () => {
+    const data = { apiVersion: 'ray.io/v1', kind: 'RayService', spec: { customField: 'preserved-value' } }
+    const html = renderKind('rayservices', data)
+    expect(html).toContain('Serving and Rollout')
+    expect(html).not.toContain('preserved-value')
+    expect(html).not.toContain('No specialized view')
+    for (const apiVersion of ['foreign.io/v1', 'fake.ray.io/v1', 'ray.io/v99', 'ray.io/v1alpha1']) {
+      const foreign = { ...data, apiVersion }
+      expect(renderKind('rayservices', foreign)).not.toContain('Serving and Rollout')
+      expect(renderKind('rayservices', foreign)).toContain('preserved-value')
+      expect(getResourceStatus('rayservices', foreign)).toBeNull()
+    }
+  })
+})
+
+it('uses native RayCluster detail only for ray.io/v1', () => {
+  for (const apiVersion of ['ray.io/v1', 'foreign.io/v1', 'ray.io/v9']) {
+    const html = renderKind('rayclusters', { apiVersion, kind: 'RayCluster', metadata: { name: 'cluster', namespace: 'ml' }, spec: { rayVersion: '2.55.0' } }, 'ml')
+    expect(html.includes('Runtime Health')).toBe(apiVersion === 'ray.io/v1')
+    if (apiVersion !== 'ray.io/v1') expect(html).toContain('2.55.0')
+  }
+})

package/src/components/shared/ResourceRendererDispatch.tsx

@@ -68,9 +68,9 @@ import {
 } from '../resources/resource-utils-kyverno-exceptions'
 import { getResourceClaimStatus, getResourceClaimTemplateStatus, getDeviceClassStatus, getResourceSliceStatus } from '../resources/resource-utils-dra'
 import { getNvidiaClusterPolicyStatus, getNvidiaDriverStatus } from '../resources/resource-utils-nvidia'
-import { getClusterQueueStatus, getLocalQueueStatus, getKueueWorkloadStatus, getResourceFlavorStatus, getAdmissionCheckStatus, getProvisioningRequestStatus } from '../resources/resource-utils-kueue'
+import { isKueueQueueResource, getClusterQueueStatus, getLocalQueueStatus, getKueueWorkloadStatus, getResourceFlavorStatus, getAdmissionCheckStatus, getProvisioningRequestStatus } from '../resources/resource-utils-kueue'
 import { getRayClusterStatus, getRayJobStatus, getRayServiceStatus, getRayCronJobStatus } from '../resources/resource-utils-ray'
-import { getLeaderWorkerSetStatus, getJobSetStatus } from '../resources/resource-utils-jobset-lws'
+import { getLeaderWorkerSetStatus, getJobSetStatus, isJobSetV1Alpha2 } from '../resources/resource-utils-jobset-lws'
 import { getInferenceServiceStatus, getServingRuntimeStatus, getInferenceGraphStatus, getTrainedModelStatus, getLLMInferenceServiceStatus } from '../resources/resource-utils-kserve'
 import { getInferencePoolStatus, getInferenceObjectiveStatus } from '../resources/resource-utils-inference-gateway'
 import { getVolcanoJobStatus, getVolcanoQueueStatus, getVolcanoPodGroupStatus, getJobFlowStatus, getJobTemplateStatus } from '../resources/resource-utils-volcano'
@@ -114,6 +114,14 @@ import {
   ConfigMapRenderer,
   SecretRenderer,
   JobRenderer,
+  JobSetRenderer,
+  KueueWorkloadRenderer,
+  RayServiceRenderer,
+  RayClusterRenderer,
+  AdmissionCheckRenderer,
+  ProvisioningRequestRenderer,
+  LocalQueueRenderer,
+  ClusterQueueRenderer,
   CronJobRenderer,
   CronWorkflowRenderer,
   HPARenderer,
@@ -304,6 +312,9 @@ import type { ScalerDiagnosis } from '../resources/renderers/WorkloadRenderer'
  * When an override is not provided, the base (shared) renderer is used.
  */
 export interface RendererOverrides {
+  RayClusterRenderer?: React.ComponentType<{ data: any; onNavigate?: (ref: ResourceRef) => void }>
+  RayServiceRenderer?: React.ComponentType<{ data: any; onNavigate?: (ref: ResourceRef) => void }>
+  KueueWorkloadRenderer?: React.ComponentType<{ data: any; onNavigate?: (ref: ResourceRef) => void }>
   PodRenderer?: React.ComponentType<{
     data: any; onCopy: CopyHandler; copied: string | null
     onNavigate?: (ref: ResourceRef) => void
@@ -400,6 +411,10 @@ export interface RendererOverrides {
   // Namespace RBAC summary: host fetches /api/rbac/namespace/{ns} so the
   // namespace page can show bindings configured here without falling
   // through to GenericRenderer.
+  CAPIClusterRenderer?: React.ComponentType<{
+    data: any
+    onNavigate?: (ref: ResourceRef) => void
+  }>
   NamespaceRenderer?: React.ComponentType<{
     data: any
     onNavigate?: (ref: ResourceRef) => void
@@ -429,6 +444,8 @@ export interface RendererOverrides {
 const KNOWN_KINDS = new Set([
   'pods', 'deployments', 'statefulsets', 'daemonsets', 'replicasets',
   'services', 'endpointslices', 'ingresses', 'configmaps', 'secrets', 'jobs', 'cronjobs', 'cronworkflows',
+  'jobsets',
+  'rayclusters', 'rayservices', 'workloads', 'localqueues', 'clusterqueues', 'admissionchecks', 'provisioningrequests',
   'hpas', 'horizontalpodautoscalers', 'nodes', 'persistentvolumeclaims',
   'rollouts', 'analysisruns', 'analysistemplates', 'clusteranalysistemplates', 'experiments', 'certificates', 'workflows', 'persistentvolumes',
   'storageclasses', 'certificaterequests', 'clusterissuers', 'issuers',
@@ -681,9 +698,10 @@ export function ResourceRendererDispatch({
   const isGroupGatedKind =
     kind === 'clusters' || kind === 'backups' || kind === 'scheduledbackups' || kind === 'poolers'
     || kind === 'objectstores' || kind === 'databases' || kind === 'publications'
-    || kind === 'subscriptions' || kind === 'imagecatalogs' || kind === 'clusterimagecatalogs'
+    || kind === 'subscriptions' || kind === 'imagecatalogs' || kind === 'clusterimagecatalogs' || kind === 'jobsets'
     || kind === 'policies' || kind === 'rollouts' || kind === 'experiments'
-    || kind === 'machines' || kind === 'machinesets'
+    || kind === 'rayclusters' || kind === 'rayservices' || kind === 'admissionchecks' || kind === 'provisioningrequests'
+    || kind === 'machines' || kind === 'machinesets' || kind === 'workloads' || kind === 'localqueues' || kind === 'clusterqueues'
   const isCNPGApiVersion = isApiGroup(data?.apiVersion, CNPG_GROUP)
   const groupGatedMatched =
     (kind === 'clusters' && (isCNPGApiVersion || isApiGroup(data?.apiVersion, 'cluster.x-k8s.io')))
@@ -703,6 +721,13 @@ export function ResourceRendererDispatch({
     || (kind === 'experiments' && isApiGroup(data?.apiVersion, 'argoproj.io'))
     || ((kind === 'machines' || kind === 'machinesets')
       && isApiGroup(data?.apiVersion, 'cluster.x-k8s.io'))
+    || (kind === 'rayclusters' && data?.apiVersion === 'ray.io/v1')
+    || (kind === 'rayservices' && data?.apiVersion === 'ray.io/v1')
+    || (kind === 'jobsets' && isJobSetV1Alpha2(data))
+    || (kind === 'workloads' && isApiGroup(data?.apiVersion, 'kueue.x-k8s.io'))
+    || (kind === 'admissionchecks' && isKueueQueueResource(data))
+    || (kind === 'provisioningrequests' && ['autoscaling.x-k8s.io/v1', 'autoscaling.x-k8s.io/v1beta1'].includes(data?.apiVersion))
+    || ((kind === 'localqueues' || kind === 'clusterqueues') && isKueueQueueResource(data))
   const groupGatedFallthrough = isGroupGatedKind && !groupGatedMatched
 
   const calicoApiVersionMatched = isCalicoApiVersion(data?.apiVersion)
@@ -723,6 +748,9 @@ export function ResourceRendererDispatch({
 
   const isKnownKind = KNOWN_KINDS.has(kind) || isCrossplaneMR || isCrossplaneClaim || isCrossplaneXR
 
+  const RayClusterComp = rendererOverrides?.RayClusterRenderer ?? RayClusterRenderer
+  const RayServiceComp = rendererOverrides?.RayServiceRenderer ?? RayServiceRenderer
+  const KueueWorkloadComp = rendererOverrides?.KueueWorkloadRenderer ?? KueueWorkloadRenderer
   const PodComp = rendererOverrides?.PodRenderer ?? PodRenderer
   const KarpenterNodePoolComp = rendererOverrides?.KarpenterNodePoolRenderer ?? KarpenterNodePoolRenderer
   const WorkloadComp = rendererOverrides?.WorkloadRenderer ?? WorkloadRenderer
@@ -748,6 +776,7 @@ export function ResourceRendererDispatch({
   const RoleComp = rendererOverrides?.RoleRenderer ?? RoleRenderer
   const RoleBindingComp = rendererOverrides?.RoleBindingRenderer ?? RoleBindingRenderer
   const NamespaceComp = rendererOverrides?.NamespaceRenderer ?? NamespaceRenderer
+  const CAPIClusterComp = rendererOverrides?.CAPIClusterRenderer ?? CAPIClusterRenderer
   const HPAComp = rendererOverrides?.HPARenderer ?? HPARenderer
   const PVCComp = rendererOverrides?.PVCRenderer ?? PVCRenderer
   const RolloutComp = rendererOverrides?.RolloutRenderer ?? RolloutRenderer
@@ -790,6 +819,14 @@ export function ResourceRendererDispatch({
         {kind === 'configmaps' && <ConfigMapRenderer data={data} relationships={relationships} onNavigate={onNavigate} />}
         {kind === 'secrets' && <SecretRenderer data={data} relationships={relationships} onNavigate={onNavigate} certificateInfo={certificateInfo} resourceData={data} onSaveSecretValue={onSaveSecretValue} isSaving={isSavingSecret} />}
         {kind === 'jobs' && !nonCoreJobFallthrough && <JobRenderer data={data} />}
+        {kind === 'rayclusters' && data?.apiVersion === 'ray.io/v1' && <RayClusterComp data={data} onNavigate={onNavigate} />}
+        {kind === 'rayservices' && data?.apiVersion === 'ray.io/v1' && <RayServiceComp data={data} onNavigate={onNavigate} />}
+        {kind === 'workloads' && isApiGroup(data?.apiVersion, 'kueue.x-k8s.io') && <KueueWorkloadComp data={data} onNavigate={onNavigate} />}
+        {kind === 'admissionchecks' && isKueueQueueResource(data) && <AdmissionCheckRenderer data={data} onNavigate={onNavigate} />}
+        {kind === 'provisioningrequests' && ['autoscaling.x-k8s.io/v1', 'autoscaling.x-k8s.io/v1beta1'].includes(data?.apiVersion) && <ProvisioningRequestRenderer data={data} onNavigate={onNavigate} />}
+        {kind === 'localqueues' && isKueueQueueResource(data) && <LocalQueueRenderer data={data} onNavigate={onNavigate} />}
+        {kind === 'clusterqueues' && isKueueQueueResource(data) && <ClusterQueueRenderer data={data} onNavigate={onNavigate} />}
+        {kind === 'jobsets' && isJobSetV1Alpha2(data) && <JobSetRenderer data={data} />}
         {kind === 'cronjobs' && <CronJobRenderer data={data} onNavigate={onNavigate} />}
         {kind === 'cronworkflows' && <CronWorkflowRenderer data={data} onNavigate={onNavigate} />}
         {(kind === 'hpas' || kind === 'horizontalpodautoscalers') && <HPAComp data={data} onNavigate={onNavigate} hpaDiagnosis={hpaDiagnosis} />}
@@ -892,7 +929,7 @@ export function ResourceRendererDispatch({
         {kind === 'clusterexternalsecrets' && <ClusterExternalSecretRenderer data={data} onNavigate={onNavigate} />}
         {(kind === 'secretstores' || kind === 'clustersecretstores') && <SecretStoreRenderer data={data} />}
         {kind === 'clusters' && isApiGroup(data?.apiVersion, CNPG_GROUP) && <CNPGClusterComp data={data} onNavigate={onNavigate} />}
-        {kind === 'clusters' && isApiGroup(data?.apiVersion, 'cluster.x-k8s.io') && <CAPIClusterRenderer data={data} onNavigate={onNavigate} />}
+        {kind === 'clusters' && isApiGroup(data?.apiVersion, 'cluster.x-k8s.io') && <CAPIClusterComp data={data} onNavigate={onNavigate} />}
         {kind === 'scheduledbackups' && isApiGroup(data?.apiVersion, CNPG_GROUP) && <CNPGScheduledBackupRenderer data={data} onNavigate={onNavigate} />}
         {kind === 'poolers' && isApiGroup(data?.apiVersion, CNPG_GROUP) && <CNPGPoolerRenderer data={data} onNavigate={onNavigate} />}
         {/* Cluster API (CAPI) */}
@@ -1083,14 +1120,14 @@ export function getResourceStatus(kind: string, data: any): { text: string; colo
   if (k === 'clusterqueues' && data?.apiVersion?.startsWith('kueue.x-k8s.io/')) return getClusterQueueStatus(data)
   if (k === 'localqueues' && data?.apiVersion?.startsWith('kueue.x-k8s.io/')) return getLocalQueueStatus(data)
   if (k === 'resourceflavors' && data?.apiVersion?.startsWith('kueue.x-k8s.io/')) return getResourceFlavorStatus(data)
-  if (k === 'admissionchecks' && data?.apiVersion?.startsWith('kueue.x-k8s.io/')) return getAdmissionCheckStatus(data)
-  if (k === 'provisioningrequests' && data?.apiVersion?.startsWith('autoscaling.x-k8s.io/')) return getProvisioningRequestStatus(data)
-  if (k === 'rayclusters' && data?.apiVersion?.startsWith('ray.io/')) return getRayClusterStatus(data)
+  if (k === 'admissionchecks' && isKueueQueueResource(data)) return getAdmissionCheckStatus(data)
+  if (k === 'provisioningrequests' && ['autoscaling.x-k8s.io/v1', 'autoscaling.x-k8s.io/v1beta1'].includes(data?.apiVersion)) return getProvisioningRequestStatus(data)
+  if (k === 'rayclusters' && data?.apiVersion === 'ray.io/v1') return getRayClusterStatus(data)
   if (k === 'rayjobs' && data?.apiVersion?.startsWith('ray.io/')) return getRayJobStatus(data)
-  if (k === 'rayservices' && data?.apiVersion?.startsWith('ray.io/')) return getRayServiceStatus(data)
+  if (k === 'rayservices' && data?.apiVersion === 'ray.io/v1') return getRayServiceStatus(data)
   if (k === 'raycronjobs' && data?.apiVersion?.startsWith('ray.io/')) return getRayCronJobStatus(data)
   if (k === 'leaderworkersets' && data?.apiVersion?.startsWith('leaderworkerset.x-k8s.io/')) return getLeaderWorkerSetStatus(data)
-  if (k === 'jobsets' && data?.apiVersion?.startsWith('jobset.x-k8s.io/')) return getJobSetStatus(data)
+  if (k === 'jobsets' && isJobSetV1Alpha2(data)) return getJobSetStatus(data)
   if (k === 'inferenceservices' && data?.apiVersion?.startsWith('serving.kserve.io/')) return getInferenceServiceStatus(data)
   if ((k === 'servingruntimes' || k === 'clusterservingruntimes') && data?.apiVersion?.startsWith('serving.kserve.io/')) return getServingRuntimeStatus(data)
   if (k === 'inferencegraphs' && data?.apiVersion?.startsWith('serving.kserve.io/')) return getInferenceGraphStatus(data)

package/src/components/timeline/TimelineList.tsx

@@ -30,6 +30,7 @@ import { isChangeEvent, isHistoricalEvent } from '../../types'
 import { getHealthBadgeColor, SEVERITY_BADGE } from '../../utils/badge-colors'
 import { ResourceRefBadge } from '../ui/drawer-components'
 import type { NavigateToResource } from '../../utils/navigation'
+import { builtinGroupForKind } from '../../utils/api-resources'
 import { kindToPluralWithGroup, refToSelectedResource, apiVersionToGroup } from '../../utils/navigation'
 import { pluralize } from '../../utils/pluralize'
 
@@ -602,8 +603,10 @@ function ActivityCard({ item, expanded, onToggle, onResourceClick, compact, sele
             {/* Resource info */}
             <div className="flex items-center gap-2 flex-wrap">
               <button
+                disabled={!item.apiVersion && builtinGroupForKind(item.kind) === undefined}
                 onClick={(e) => {
                   e.stopPropagation()
+                  if (!item.apiVersion && builtinGroupForKind(item.kind) === undefined) return
                   onResourceClick?.({
                     kind: kindToPluralWithGroup(
                       item.kind,
@@ -786,8 +789,10 @@ function AggregatedActivityCard({ first, last, count, reason, expanded, onToggle
             {/* Resource info */}
             <div className="flex items-center gap-2 flex-wrap">
               <button
+                disabled={!first.apiVersion && builtinGroupForKind(first.kind) === undefined}
                 onClick={(e) => {
                   e.stopPropagation()
+                  if (!first.apiVersion && builtinGroupForKind(first.kind) === undefined) return
                   onResourceClick?.({
                     kind: kindToPluralWithGroup(
                       first.kind,

package/src/components/timeline/TimelineSwimlanes.test.tsx

@@ -324,6 +324,21 @@ describe('EventDetailPanel cluster mode (a ×N pill exposes every member)', () =
   // Ordered most-severe-first, as the drawer opens it (Warning → delete → add → update).
   const ordered = [...clusterEvents].sort((a, b) => eventSeverityRank(b) - eventSeverityRank(a))
 
+  it('does not link an ambiguous event through the detail badge', () => {
+    const event = mk('ambiguous', 'update', T0, {kind: 'Cluster', name: 'shared'});
+    const lanes = [{id: 'unresolved', kind: 'Cluster', name: 'shared', namespace: 'default', events: [event], isWorkload: false, identityAmbiguous: true}];
+    const html = renderToString(<EventDetailPanel events={[event]} selectedId={event.id} onSelectId={() => {}} onClose={() => {}} onResourceClick={() => {}} resourceLanes={lanes} />);
+    expect(html).not.toMatch(/<button[^>]*class="badge[^>]*>/);
+    expect(html).toContain('shared');
+  })
+
+  it('keeps an unambiguous resolved historical event link', () => {
+    const event = mk('resolved', 'update', T0, {kind: 'Cluster', name: 'shared'});
+    const lanes = [{id: 'exact', kind: 'Cluster', name: 'shared', namespace: 'default', group: 'postgresql.cnpg.io', events: [event], isWorkload: false, identityResolved: true}];
+    const html = renderToString(<EventDetailPanel events={[event]} selectedId={event.id} onSelectId={() => {}} onClose={() => {}} onResourceClick={() => {}} resourceLanes={lanes} />);
+    expect(html).toMatch(/<button[^>]*class="badge[^>]*>/);
+  })
+
   it('renders a row for every clustered event plus the summary header', () => {
     const html = renderToString(
       <EventDetailPanel events={ordered} selectedId={ordered[0].id} onSelectId={() => {}} onClose={() => {}} />,