@skyhook-io/radar-app 1.16.3 → 1.17.1

package/src/hooks/useResolvedGitOpsOwner.ts

@@ -0,0 +1,256 @@
+import { useMemo } from 'react'
+import {
+  getGitOpsResourceStatus,
+  gitOpsOwnerFromRelationships,
+  type GitOpsOwnerRef,
+  type GitOpsStatus,
+  type HelmOwnerRef,
+} from '@skyhook-io/k8s-ui'
+import type { Relationships, ResourceRef } from '../types'
+import { kindToPluralWithGroup } from '../utils/navigation'
+import { useResource, useResourceWithRelationships, useResources } from '../api/client'
+
+export interface ResolvedGitOpsOwner {
+  /** GitOps owner, with an Argo Application's namespace filled in when the
+   *  tracking label omitted it and exactly one Application matches. */
+  owner: GitOpsOwnerRef | null
+  /** Owner as reported by relationships, before namespace resolution. */
+  rawOwner: GitOpsOwnerRef | null
+  /** The owner CR (Application / Kustomization / HelmRelease). */
+  ownerObject: any
+  ownerPending: boolean
+  ownerVerified: boolean
+  /** The Argo CD tracking label named no namespace and Radar filled it in
+   *  from a single Application of that name. */
+  ownerMatchedByName: boolean
+  ownerStatus: GitOpsStatus | null
+  /** The label/annotation that ties the object to its owner. */
+  ownerSource: string | null
+  helmOwner: HelmOwnerRef | null
+  helmSource: string | null
+  /** A parent (e.g. the Deployment of a ReplicaSet) consulted when the
+   *  object carries no GitOps ownership itself. */
+  inheritedLookupRef: ResourceRef | null
+  lookupPending: boolean
+  lookupError: boolean
+  /** The parent was read but the server sent no relationships for it (its
+   *  topology isn't built yet), so an inherited owner is unknown, not absent. */
+  relationshipsUnavailable: boolean
+}
+
+// Resolves who manages a resource: its own GitOps/Helm tracking metadata or,
+// failing that, the metadata of the workload that owns it.
+export function useResolvedGitOpsOwner({
+  kind,
+  group,
+  namespace,
+  name,
+  relationships,
+  resource,
+  enabled = true,
+  cacheScope,
+}: {
+  kind: string
+  group?: string
+  namespace: string
+  name: string
+  relationships: Relationships | undefined
+  resource: any
+  enabled?: boolean
+  /** Keeps these reads apart from the shared resource cache (see useResource). */
+  cacheScope?: string
+}): ResolvedGitOpsOwner {
+  const active = enabled && Boolean(relationships)
+  const relationshipGitopsOwner = useMemo(
+    () => (active ? gitOpsOwnerFromRelationships(relationships) : null),
+    [active, relationships],
+  )
+  const inheritedLookupRef = useMemo(
+    () =>
+      active
+        ? findInheritedGitOpsLookupRef(relationships, relationshipGitopsOwner, { kind, namespace, name, group })
+        : null,
+    [active, relationships, relationshipGitopsOwner, kind, namespace, name, group],
+  )
+  const inherited = useResourceWithRelationships<any>(
+    inheritedLookupRef ? kindToPluralWithGroup(inheritedLookupRef.kind, inheritedLookupRef.group ?? '') : '',
+    inheritedLookupRef?.namespace ?? '',
+    inheritedLookupRef?.name ?? '',
+    inheritedLookupRef?.group,
+    { cacheScope },
+  )
+  const inheritedGitopsOwner = useMemo(
+    () => (inheritedLookupRef ? gitOpsOwnerFromRelationships(inherited.data?.relationships) : null),
+    [inheritedLookupRef, inherited.data?.relationships],
+  )
+  const relationshipHelmOwner = useMemo(
+    () => (active ? nativeHelmOwnerFromRelationships(relationships, resource?.metadata?.namespace ?? namespace) : null),
+    [active, relationships, resource?.metadata?.namespace, namespace],
+  )
+  const inheritedHelmOwner = useMemo(
+    () =>
+      inheritedLookupRef
+        ? nativeHelmOwnerFromRelationships(
+            inherited.data?.relationships,
+            inherited.data?.resource?.metadata?.namespace ?? namespace,
+          )
+        : null,
+    [inheritedLookupRef, inherited.data?.relationships, inherited.data?.resource?.metadata?.namespace, namespace],
+  )
+
+  const rawOwner = relationshipGitopsOwner ?? inheritedGitopsOwner
+  const gitOpsSourceResource = relationshipGitopsOwner ? resource : inherited.data?.resource
+  const helmOwner = relationshipHelmOwner ?? inheritedHelmOwner
+  const helmSourceResource = relationshipHelmOwner ? resource : inherited.data?.resource
+
+  const shouldResolveArgoNamespace = rawOwner?.tool === 'argocd' && !rawOwner.namespace
+  const argoQuery = useResources<any>('applications', undefined, 'argoproj.io', {
+    enabled: shouldResolveArgoNamespace,
+    cacheScope,
+  })
+  const argoApplications = argoQuery.data
+  const owner = useMemo(() => resolveGitOpsOwner(rawOwner, argoApplications), [rawOwner, argoApplications])
+
+  const ownerGroup = owner ? gitOpsOwnerGroup(owner) : ''
+  const shouldFetchOwner = Boolean(owner?.namespace)
+  const ownerQuery = useResource<any>(
+    shouldFetchOwner ? owner!.kind : '',
+    owner?.namespace ?? '',
+    owner?.name ?? '',
+    ownerGroup,
+    { enabled: shouldFetchOwner, cacheScope },
+  )
+  const ownerObject = shouldFetchOwner ? ownerQuery.data : undefined
+
+  const ownerStatus = useMemo(() => deriveGitOpsOwnerStatus(owner, ownerObject), [owner, ownerObject])
+  const ownerSource = useMemo(
+    () => describeGitOpsOwnerSource(rawOwner, gitOpsSourceResource),
+    [rawOwner, gitOpsSourceResource],
+  )
+  const helmSource = useMemo(() => describeHelmOwnerSource(helmOwner, helmSourceResource), [helmOwner, helmSourceResource])
+
+  return {
+    owner,
+    rawOwner,
+    ownerObject,
+    ownerPending: Boolean(shouldFetchOwner && ownerQuery.isLoading && !ownerQuery.data),
+    ownerVerified: Boolean(shouldFetchOwner && ownerQuery.data),
+    ownerMatchedByName: Boolean(shouldResolveArgoNamespace && owner?.namespace),
+    ownerStatus,
+    ownerSource,
+    helmOwner,
+    helmSource,
+    inheritedLookupRef,
+    lookupPending: Boolean((inheritedLookupRef && inherited.isPending) || (shouldResolveArgoNamespace && argoQuery.isPending)),
+    lookupError: Boolean(inheritedLookupRef && inherited.isError),
+    relationshipsUnavailable: Boolean(inheritedLookupRef && inherited.data && !inherited.data.relationships),
+  }
+}
+
+export function gitOpsOwnerGroup(owner: GitOpsOwnerRef): string {
+  if (owner.tool === 'argocd') return 'argoproj.io'
+  if (owner.kind === 'kustomizations') return 'kustomize.toolkit.fluxcd.io'
+  return 'helm.toolkit.fluxcd.io'
+}
+
+/** The owner as the singular Kind + group the server's APIs take. */
+export function gitOpsOwnerKindRef(owner: GitOpsOwnerRef): { kind: string; group: string } {
+  if (owner.tool === 'argocd') return { kind: 'Application', group: 'argoproj.io' }
+  if (owner.kind === 'kustomizations') return { kind: 'Kustomization', group: 'kustomize.toolkit.fluxcd.io' }
+  return { kind: 'HelmRelease', group: 'helm.toolkit.fluxcd.io' }
+}
+
+function resolveGitOpsOwner(owner: GitOpsOwnerRef | null, argoApplications: any[] | undefined): GitOpsOwnerRef | null {
+  if (!owner || owner.namespace || owner.tool !== 'argocd') return owner
+  const matches = (argoApplications ?? []).filter((app) => app?.metadata?.name === owner.name)
+  if (matches.length !== 1) return owner
+  const namespace = matches[0]?.metadata?.namespace
+  return namespace ? { ...owner, namespace } : owner
+}
+
+export function findInheritedGitOpsLookupRef(
+  relationships: Relationships | undefined,
+  directOwner: GitOpsOwnerRef | null,
+  current: ResourceRef,
+): ResourceRef | null {
+  if (directOwner) return null
+  const inheritedManagerRefs = (relationships?.managedBy ?? []).filter(
+    (ref) => !gitOpsOwnerFromRelationships({ managedBy: [ref] }) && !isNativeHelmManager(ref),
+  )
+  const candidates = [relationships?.deployment, ...inheritedManagerRefs, relationships?.owner].filter(
+    Boolean,
+  ) as ResourceRef[]
+
+  return candidates.find((ref) => !isCurrentResource(ref, current)) ?? null
+}
+
+export function nativeHelmOwnerFromRelationships(
+  relationships: Relationships | undefined,
+  fallbackNamespace: string,
+): HelmOwnerRef | null {
+  const ref = relationships?.managedBy?.[0]
+  if (!ref || !isNativeHelmManager(ref)) return null
+  return {
+    namespace: ref.namespace || fallbackNamespace,
+    name: ref.name,
+  }
+}
+
+function isCurrentResource(ref: ResourceRef, current: ResourceRef): boolean {
+  return (
+    kindToPluralWithGroup(ref.kind, ref.group ?? '') === kindToPluralWithGroup(current.kind, current.group ?? '') &&
+    ref.namespace === current.namespace &&
+    ref.name === current.name &&
+    (ref.group ?? '') === (current.group ?? '')
+  )
+}
+
+function isNativeHelmManager(ref: ResourceRef): boolean {
+  return ref.kind === 'HelmRelease' && ref.group !== 'helm.toolkit.fluxcd.io'
+}
+
+function describeGitOpsOwnerSource(owner: GitOpsOwnerRef | null, resource: any): string | null {
+  if (!owner || !resource) return null
+  const labels = resource.metadata?.labels ?? {}
+  const annotations = resource.metadata?.annotations ?? {}
+
+  if (owner.tool === 'fluxcd') {
+    const nameKey = owner.kind === 'helmreleases' ? 'helm.toolkit.fluxcd.io/name' : 'kustomize.toolkit.fluxcd.io/name'
+    const nsKey =
+      owner.kind === 'helmreleases' ? 'helm.toolkit.fluxcd.io/namespace' : 'kustomize.toolkit.fluxcd.io/namespace'
+    if (labels[nameKey] || labels[nsKey]) {
+      return `${nameKey}=${labels[nameKey] ?? ''}, ${nsKey}=${labels[nsKey] ?? ''}`
+    }
+  }
+
+  const trackingID = annotations['argocd.argoproj.io/tracking-id']
+  if (trackingID) return `argocd.argoproj.io/tracking-id=${trackingID}`
+  const argoInstance = labels['argocd.argoproj.io/instance']
+  if (argoInstance) return `argocd.argoproj.io/instance=${argoInstance}`
+  return null
+}
+
+function describeHelmOwnerSource(owner: HelmOwnerRef | null, resource: any): string | null {
+  if (!owner || !resource) return null
+  const annotations = resource.metadata?.annotations ?? {}
+  const releaseName = annotations['meta.helm.sh/release-name']
+  const releaseNamespace = annotations['meta.helm.sh/release-namespace']
+  if (releaseName || releaseNamespace) {
+    return `meta.helm.sh/release-name=${releaseName ?? ''}, meta.helm.sh/release-namespace=${releaseNamespace ?? ''}`
+  }
+  return null
+}
+
+function deriveGitOpsOwnerStatus(owner: GitOpsOwnerRef | null, resource: any): GitOpsStatus | null {
+  if (!owner || !resource || !hasGitOpsStatusPayload(owner, resource)) return null
+  return getGitOpsResourceStatus(owner.kind, resource)
+}
+
+function hasGitOpsStatusPayload(owner: GitOpsOwnerRef, resource: any): boolean {
+  if (owner.kind === 'applications') {
+    const status = resource.status ?? {}
+    return Boolean(status.sync?.status || status.health?.status || status.operationState?.phase)
+  }
+  if (resource.spec?.suspend === true) return true
+  return Array.isArray(resource.status?.conditions) && resource.status.conditions.length > 0
+}

package/src/integrations/resourceHost.test.tsx

@@ -0,0 +1,55 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import {
+  composeDetailSlots, composeResourceHosts, hostsForResource, resourceHostForSlot,
+  type ResourceHost,
+} from './resourceHost'
+
+const job = { kind: 'Job', group: 'batch', namespace: 'ml', name: 'run' }
+const jobs = [{ name: 'jobs', group: 'batch' }]
+const Admission = () => <span>admission</span>
+
+describe('resource host composition', () => {
+  it('allows batch and admission to extend the same Job without hiding the destination owner', () => {
+    const hosts: ResourceHost[] = [
+      { id: 'admission', resources: jobs, detailSlots: () => ({ renderHeaderActions: () => <Admission /> }) },
+      { id: 'execution', resources: jobs, detailOwnership: ['destination'], expandedPath: () => '/execution/run', detailSlots: () => ({ renderHeaderActions: () => <span>execution</span>, extraTabs: [{ id: 'runs', label: 'Runs', render: () => null }] }) },
+    ]
+    composeResourceHosts(hosts)
+    expect(hostsForResource(hosts, job).map(host => host.id)).toEqual(['admission', 'execution'])
+    expect(resourceHostForSlot(hosts, job, 'destination')?.expandedPath?.(job)).toBe('/execution/run')
+    const slots = composeDetailSlots(hosts.map(host => ({ id: host.id, slots: host.detailSlots?.(job) })), [{ id: 'history', label: 'History', render: () => null }])
+    const html = renderToStaticMarkup(<>{slots.renderHeaderActions?.({ resource: {}, context: 'drawer' })}</>)
+    expect(html).toBe('<span>admission</span><span>execution</span>')
+    expect(slots.extraTabs?.map(tab => tab.id)).toEqual(['history', 'runs'])
+  })
+
+  it('requires resolved group identity and normalizes Kind versus resource plural', () => {
+    const hosts: ResourceHost[] = [{ id: 'batch', resources: jobs }]
+    expect(hostsForResource(hosts, job)).toHaveLength(1)
+    expect(hostsForResource(hosts, { ...job, kind: 'jobs' })).toHaveLength(1)
+    expect(hostsForResource(hosts, { ...job, group: undefined })).toEqual([])
+    expect(hostsForResource(hosts, { ...job, group: '' })).toEqual([])
+    expect(hostsForResource(hosts, { ...job, group: 'batch.volcano.sh' })).toEqual([])
+    expect(hostsForResource([{ id: 'core', resources: [{ name: 'pods', group: '' }] }], { ...job, kind: 'Pod', group: '' })).toHaveLength(1)
+  })
+
+  it('rejects competing exclusive ownership instead of letting registration order win', () => {
+    const owner: ResourceHost = { id: 'execution', resources: jobs, detailOwnership: ['destination'], expandedPath: () => '/execution' }
+    const other: ResourceHost = { ...owner, id: 'other' }
+    expect(() => composeResourceHosts([owner, other])).toThrow('ownership conflict')
+    expect(() => composeResourceHosts([{ id: 'missing', resources: jobs, logs: () => null }])).toThrow('must declare logs ownership')
+    expect(() => composeResourceHosts([{ id: 'missing', resources: jobs, expandedPath: () => '/' }])).toThrow('must declare destination ownership')
+    expect(() => composeResourceHosts([
+      { id: 'one', renderers: { JobRenderer: Admission } },
+      { id: 'two', renderers: { JobRenderer: Admission } },
+    ])).toThrow('renderer:JobRenderer')
+  })
+
+  it('catches summary and tab conflicts even if a contribution omitted its declaration', () => {
+    expect(() => composeDetailSlots(['one', 'two'].map(id => ({ id, slots: { renderSummary: () => null } })))).toThrow('summary ownership conflict')
+    const tab = { id: 'runs', label: 'Runs', render: () => null }
+    expect(composeDetailSlots([], [tab, tab]).extraTabs).toEqual([tab, tab])
+    expect(() => composeDetailSlots([{ id: 'execution', slots: { extraTabs: [tab] } }], [tab])).toThrow('tab ownership conflict: runs')
+  })
+})

package/src/integrations/resourceHost.ts

@@ -0,0 +1,99 @@
+import { createElement, Fragment, type ComponentProps, type ComponentType, type ReactNode } from 'react'
+import type { RendererOverrides, WorkloadExtraTab, WorkloadView } from '@skyhook-io/k8s-ui'
+import type { RadarFeature, RadarFeatureSupport } from '../api/radarFeatures'
+import type { RenderDiagnoseAction } from '../context/DiagnoseCustomization'
+import type { SelectedResource } from '../types'
+import { kindToPluralWithGroup } from '../utils/navigation'
+
+export type HostResource = Pick<SelectedResource, 'kind' | 'group' | 'namespace' | 'name'>
+export type DetailSlots = Pick<ComponentProps<typeof WorkloadView>, 'renderSummary' | 'renderHeaderActions' | 'extraTabs'>
+export type HostFeatures = Partial<Record<RadarFeature, RadarFeatureSupport>>
+export type KindListMode = 'table' | 'wait' | 'view'
+export interface HostKind { name: string; kind: string; group: string }
+export interface KindListProps {
+  namespaces: string[]
+  inspected: SelectedResource | null
+  onInspect: (resource: SelectedResource) => void
+  onClearNamespaces: () => void
+  onCreate: (kind: HostKind) => void
+}
+type ExclusiveDetailSlot = 'summary' | 'destination' | 'logs'
+export interface ResourceHost {
+  id: string
+  feature?: RadarFeature
+  diagnoseAction?: (render: RenderDiagnoseAction | undefined) => RenderDiagnoseAction | undefined
+  kindLists?: readonly {
+    kind: HostKind
+    title: string
+    mode: (support: RadarFeatureSupport, pending: boolean) => KindListMode
+    Component: ComponentType<KindListProps>
+  }[]
+  renderers?: RendererOverrides
+  resources?: readonly { name: string; group: string }[]
+  expandedPath?: (resource: HostResource, context?: string, tab?: 'yaml') => string | null
+  detailRedirect?: (resource: HostResource, search: URLSearchParams) => string | null
+  detailSlots?: (resource: HostResource) => DetailSlots
+  detailOwnership?: readonly ExclusiveDetailSlot[]
+  logs?: (resource: HostResource, data: { apiVersion?: string } | null | undefined) => ReactNode
+  drawerNavigation?: {
+    ownsPath: (pathname: string) => boolean
+    Component: ComponentType<{ resource: SelectedResource }>
+  }
+}
+
+export function hostSupport(host: ResourceHost, features: HostFeatures): RadarFeatureSupport {
+  return host.feature ? features[host.feature] ?? 'unknown' : 'supported'
+}
+
+function resourceKey(name: string, group: string): string { return `${group}\u0000${name}` }
+
+export function hostsForResource(hosts: readonly ResourceHost[], resource: HostResource): ResourceHost[] {
+  // An unresolved group must not select a colliding CRD, or be treated as core.
+  if (resource.group === undefined) return []
+  const plural = kindToPluralWithGroup(resource.kind, resource.group)
+  return hosts.filter(host => host.resources?.some(kind => kind.name === plural && kind.group === resource.group))
+}
+
+export function resourceHostForSlot(hosts: readonly ResourceHost[], resource: HostResource, slot: ExclusiveDetailSlot): ResourceHost | undefined {
+  return hostsForResource(hosts, resource).find(host => host.detailOwnership?.includes(slot))
+}
+
+export function composeResourceHosts(hosts: readonly ResourceHost[]): RendererOverrides {
+  const renderers: RendererOverrides = {}
+  const owners = new Map<string, string>()
+  const claim = (key: string, id: string) => {
+    const previous = owners.get(key)
+    if (previous) throw new Error(`Resource host ownership conflict: ${previous} and ${id} own ${key}`)
+    owners.set(key, id)
+  }
+  for (const host of hosts) {
+    claim(`host:${host.id}`, host.id)
+    if ((host.expandedPath || host.detailRedirect) && !host.detailOwnership?.includes('destination')) throw new Error(`Resource host ${host.id} must declare destination ownership`)
+    if (host.logs && !host.detailOwnership?.includes('logs')) throw new Error(`Resource host ${host.id} must declare logs ownership`)
+    for (const name of Object.keys(host.renderers ?? {})) claim(`renderer:${name}`, host.id)
+    Object.assign(renderers, host.renderers)
+    for (const kind of host.resources ?? []) {
+      for (const slot of host.detailOwnership ?? []) claim(`${slot}:${resourceKey(kind.name, kind.group)}`, host.id)
+    }
+    for (const list of host.kindLists ?? []) claim(`kind-list:${resourceKey(list.kind.name, list.kind.group)}`, host.id)
+  }
+  return renderers
+}
+
+export function composeDetailSlots(contributions: readonly { id: string; slots: DetailSlots | undefined }[], inheritedTabs: WorkloadExtraTab[] = []): DetailSlots {
+  const summaries = contributions.filter(host => host.slots?.renderSummary)
+  if (summaries.length > 1) throw new Error(`Resource host summary ownership conflict: ${summaries.map(host => host.id).join(', ')}`)
+  const summary = summaries[0]?.slots?.renderSummary
+  const actions = contributions.filter(host => host.slots?.renderHeaderActions)
+  const tabs = [...inheritedTabs, ...contributions.flatMap(host => host.slots?.extraTabs ?? [])]
+  const tabIds = new Set(inheritedTabs.map(tab => tab.id))
+  for (const tab of contributions.flatMap(host => host.slots?.extraTabs ?? [])) {
+    if (tabIds.has(tab.id)) throw new Error(`Resource host tab ownership conflict: ${tab.id}`)
+    tabIds.add(tab.id)
+  }
+  return {
+    ...(summary ? { renderSummary: summary } : {}),
+    ...(actions.length ? { renderHeaderActions: (props: Parameters<NonNullable<DetailSlots['renderHeaderActions']>>[0]) => actions.map(host => createElement(Fragment, { key: host.id }, host.slots!.renderHeaderActions!(props))) } : {}),
+    ...(tabs.length ? { extraTabs: tabs } : {}),
+  }
+}

package/src/integrations/resourceHosts.test.tsx

@@ -0,0 +1,141 @@
+import { isValidElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { describe, expect, it, vi } from 'vitest'
+import { ResourceRendererDispatch } from '@skyhook-io/k8s-ui'
+import { encodeDrawerTrail } from '../utils/drawer-trail'
+import { kindToPluralWithGroup } from '../utils/navigation'
+import {
+  decorateResourceDiagnose, renderResourceKindList, resourceKindListMode, resourceKindListTitle, ResourceDrawerNavigation,
+  resourceDetailRedirect, resourceDetailSlots, resourceExpandedPath,
+  resourceLogs, resourceRendererOverrides,
+} from './resourceHosts'
+
+vi.mock('../api/client', () => ({
+  ApiError: class extends Error { status = 500 },
+  useKueueAdmission: () => ({ data: { uid: 'job-id', installed: true, workloads: [], total: 0 }, isLoading: false, refetch: () => {} }),
+}))
+
+import type { HostFeatures } from './resourceHost'
+
+const cluster = { kind: 'Cluster', group: 'postgresql.cnpg.io', namespace: 'db', name: 'pg' }
+
+const cnpgKind = { name: 'clusters', group: cluster.group }
+const supported: HostFeatures = { cnpgWorkspace: 'supported' }
+const unsupported: HostFeatures = { cnpgWorkspace: 'unsupported' }
+const unknown: HostFeatures = { cnpgWorkspace: 'unknown' }
+const listProps = { namespaces: ['db'], inspected: null, onInspect: () => {}, onClearNamespaces: () => {}, onCreate: () => {} }
+
+function renderResource(data: any) {
+  const group = data.apiVersion.split('/')[0]
+  return renderToStaticMarkup(<MemoryRouter><ResourceRendererDispatch
+    resource={{ kind: kindToPluralWithGroup(data.kind, group), namespace: 'ml', name: 'run', group }}
+    data={data} onCopy={() => {}} copied={null} showCommonSections={false}
+    rendererOverrides={resourceRendererOverrides}
+  /></MemoryRouter>)
+}
+
+describe('application resource hosts', () => {
+  it('preserves existing CNPG access and exact group collisions without a new feature flag', () => {
+    expect(resourceExpandedPath(cluster, 'kind-demo', 'yaml')).toBe('/cnpg/clusters/db/pg?ctx=kind-demo&tab=yaml')
+    expect(resourceDetailSlots(cluster).renderSummary).toBeDefined()
+    for (const group of [undefined, '', 'cluster.x-k8s.io']) {
+      expect(resourceExpandedPath({ ...cluster, group })).toBeNull()
+      expect(resourceDetailSlots({ ...cluster, group })).toEqual({})
+    }
+    expect(resourceExpandedPath({ kind: 'NodePool', group: 'karpenter.sh', namespace: '', name: 'pool' })).toBeNull()
+  })
+
+  it('retains every existing renderer override at a stable module reference', () => {
+    expect(Object.keys(resourceRendererOverrides).sort()).toEqual([
+      'RayJobRenderer', 'JobRenderer', 'JobSetRenderer', 'RayServiceRenderer', 'RayClusterRenderer',
+      'KueueWorkloadRenderer', 'CAPIClusterRenderer', 'PodRenderer', 'KarpenterNodePoolRenderer',
+      'NodeRenderer', 'ServiceRenderer', 'WorkloadRenderer', 'CompositeRenderer', 'ServiceAccountRenderer',
+      'RoleRenderer', 'RoleBindingRenderer', 'NamespaceRenderer', 'HPARenderer', 'PVCRenderer',
+      'RolloutRenderer', 'KyvernoPolicyCoverage', 'KyvernoPolicyQueued', 'CNPGObjectStoreRenderer',
+      'VeleroBSLRenderer', 'VeleroBackupRenderer', 'VeleroRestoreRenderer', 'CNPGClusterRenderer',
+      'CNPGDatabaseRenderer', 'CNPGPublicationRenderer', 'CNPGSubscriptionRenderer', 'CNPGImageCatalogRenderer',
+    ].sort())
+    const inherited = [{ id: 'local', label: 'Local', render: () => null }]
+    expect(resourceDetailSlots({ kind: 'Pod', group: '', namespace: 'db', name: 'pg-1' }, inherited).extraTabs).toEqual(inherited)
+    expect(resourceExpandedPath({ ...cluster, group: undefined })).toBeNull()
+    expect(resourceDetailRedirect({ ...cluster, group: '' }, new URLSearchParams('tab=events'))).toBeNull()
+  })
+
+  it('keeps query, tab, context and drawer state when redirecting a generic detail link', () => {
+    const search = new URLSearchParams('apiGroup=postgresql.cnpg.io&ctx=kind-demo&tab=events&drawer=pods%3Apg-1&ai-run=run')
+    const path = resourceDetailRedirect({ ...cluster, kind: 'clusters' }, search)!
+    const url = new URL(path, 'http://radar.test')
+    expect(url.pathname).toBe('/cnpg/clusters/db/pg')
+    expect(Object.fromEntries(url.searchParams)).toEqual({ ctx: 'kind-demo', tab: 'activity', drawer: 'pods:pg-1', 'ai-run': 'run' })
+    expect(search.get('tab')).toBe('events')
+    expect(search.get('apiGroup')).toBe('postgresql.cnpg.io')
+  })
+
+  it('keeps integration log selection confined to observed CNPG Clusters and falls back for other resources', () => {
+    expect(isValidElement(resourceLogs(cluster, { apiVersion: 'postgresql.cnpg.io/v1' }))).toBe(true)
+    expect(isValidElement(resourceLogs({ ...cluster, group: undefined }, { apiVersion: 'postgresql.cnpg.io/v1' }))).toBe(true)
+    expect(resourceLogs(cluster, { apiVersion: 'cluster.x-k8s.io/v1beta1' })).toBeNull()
+    expect(resourceLogs({ ...cluster, kind: 'Pooler' }, { apiVersion: 'postgresql.cnpg.io/v1' })).toBeNull()
+    expect(resourceLogs({ kind: 'Pod', group: '', namespace: 'db', name: 'pg-1' }, { apiVersion: 'v1' })).toBeNull()
+  })
+
+  it('mounts drawer trail navigation for any inspected resource in its owning workspace, including embeds', () => {
+    const previous = { kind: 'backups', group: 'postgresql.cnpg.io', namespace: 'db', name: 'base' }
+    const pod = { kind: 'pods', group: '', namespace: 'db', name: 'pg-1' }
+    const search = `?drawer=${encodeURIComponent(encodeDrawerTrail([previous, pod]))}`
+    const html = renderToStaticMarkup(<MemoryRouter basename="/c/demo" initialEntries={[`/c/demo/cnpg/protection${search}`]}><ResourceDrawerNavigation resource={pod} /></MemoryRouter>)
+    expect(html).toContain('Backup base')
+    const ordinary = renderToStaticMarkup(<MemoryRouter initialEntries={[`/resources/pods${search}`]}><ResourceDrawerNavigation resource={pod} /></MemoryRouter>)
+    expect(ordinary).toBe('')
+  })
+
+  it('preserves shared version dispatch and simultaneous batch/Kueue detail in the stable override map', () => {
+    const data = { kind: 'Job', apiVersion: 'batch/v1', metadata: { name: 'run', namespace: 'ml', uid: 'job-id', labels: { 'kueue.x-k8s.io/queue-name': 'queue' } }, spec: { completions: 1 }, status: { active: 1 } }
+    const job = renderResource(data)
+    expect(job).toContain('Completions')
+    expect(job).toContain('No controller-owned Kueue Workload observed')
+    const jobSet = { ...data, kind: 'JobSet', apiVersion: 'jobset.x-k8s.io/v1alpha2', spec: { replicatedJobs: [] } }
+    const current = renderResource(jobSet)
+    expect(current).toContain('JobSet status')
+    expect(current).toContain('No controller-owned Kueue Workload observed')
+    for (const apiVersion of ['jobset.x-k8s.io/v1beta1', 'example.io/v1alpha2']) {
+      const generic = renderResource({ ...jobSet, apiVersion })
+      expect(generic).not.toContain('JobSet status')
+      expect(generic).not.toContain('No controller-owned Kueue Workload observed')
+    }
+    const foreignJob = renderResource({ ...data, apiVersion: 'batch.volcano.sh/v1alpha1' })
+    expect(foreignJob).toContain('Specification')
+    expect(foreignJob).not.toContain('No controller-owned Kueue Workload observed')
+  })
+
+  it('makes the same kind-list decision for fetching and rendering across feature states', () => {
+    for (const [features, pending, mode] of [
+      [supported, true, 'view'], [supported, false, 'view'],
+      [unknown, true, 'wait'], [unknown, false, 'table'],
+      [unsupported, true, 'table'], [unsupported, false, 'table'],
+    ] as const) {
+      expect(resourceKindListMode(cnpgKind, features, pending)).toBe(mode)
+      const view = renderResourceKindList(cnpgKind, features, pending, listProps)
+      expect(view !== null).toBe(mode !== 'table')
+      if (mode === 'wait') expect(renderToStaticMarkup(view)).toContain('Loading…')
+    }
+    for (const group of ['', 'cluster.x-k8s.io']) {
+      expect(resourceKindListMode({ ...cnpgKind, group }, supported, true)).toBe('table')
+      expect(renderResourceKindList({ ...cnpgKind, group }, supported, true, listProps)).toBeNull()
+      expect(resourceKindListTitle({ ...cnpgKind, group })).toBeNull()
+    }
+    expect(resourceKindListTitle(cnpgKind)).toBe('CloudNativePG Clusters')
+  })
+
+  it('decorates Diagnose only for the integration-owned resource context', () => {
+    const render = vi.fn(() => <span>diagnose</span>)
+    const decorated = decorateResourceDiagnose(render)!
+    const context = { ...cluster, compact: false }
+    expect(isValidElement(decorated(context))).toBe(true)
+    expect(render).not.toHaveBeenCalled()
+    decorated({ ...context, group: 'cluster.x-k8s.io' })
+    expect(render).toHaveBeenCalledOnce()
+    expect(decorateResourceDiagnose(undefined)).toBeUndefined()
+  })
+})