@skyhook-io/radar-app 1.9.1 → 1.9.2

package/src/components/ui/command-items.ts

@@ -1,130 +1,200 @@
-import { useMemo } from 'react'
-import { Home, Network, List, Clock, Package, Activity, Sun, Stethoscope, DollarSign, ShieldCheck, GitBranch, AlertTriangle, Boxes, Server } from 'lucide-react'
-import { useNamespaces, useContexts } from '../../api/client'
-import { CORE_RESOURCES, useAPIResources } from '../../api/apiResources'
-import { getResourceIcon } from '../../utils/resource-icons'
-import { parseContextName } from '../../utils/context-name'
+import { useMemo } from "react";
+import {
+  Home,
+  Network,
+  List,
+  Clock,
+  Package,
+  Activity,
+  Sun,
+  Stethoscope,
+  DollarSign,
+  Gauge,
+  ShieldCheck,
+  GitBranch,
+  AlertTriangle,
+  Boxes,
+  Server,
+} from "lucide-react";
+import { useNamespaces, useContexts } from "../../api/client";
+import { CORE_RESOURCES, useAPIResources } from "../../api/apiResources";
+import { getResourceIcon } from "../../utils/resource-icons";
+import { parseContextName } from "../../utils/context-name";
 
 // Drop the disambiguating " (source)" suffix the context list appends, so the
 // GKE/EKS/AKS parser sees the bare context name (mirrors the cluster picker).
 function stripSourceSuffix(name: string, source?: string): string {
-  if (!source) return name
-  const escaped = source.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return name.replace(new RegExp(`\\s+\\(${escaped}(?:\\s+#\\d+)?\\)$`), '')
+  if (!source) return name;
+  const escaped = source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return name.replace(new RegExp(`\\s+\\(${escaped}(?:\\s+#\\d+)?\\)$`), "");
 }
 
-export type MainView = 'home' | 'topology' | 'resources' | 'timeline' | 'issues' | 'helm' | 'traffic' | 'cost' | 'checks' | 'gitops' | 'applications'
+export type MainView =
+  | "home"
+  | "topology"
+  | "resources"
+  | "timeline"
+  | "issues"
+  | "helm"
+  | "traffic"
+  | "cost"
+  | "capacity"
+  | "checks"
+  | "gitops"
+  | "applications";
 
 export interface CommandItem {
-  id: string
-  label: string
-  sublabel?: string
-  category: string
-  icon?: React.ComponentType<{ className?: string }>
-  shortcut?: string
-  action: () => void
+  id: string;
+  label: string;
+  sublabel?: string;
+  category: string;
+  icon?: React.ComponentType<{ className?: string }>;
+  shortcut?: string;
+  action: () => void;
   /** Extra terms to match against during search (not displayed). */
-  searchTerms?: string[]
+  searchTerms?: string[];
   /** Small priority bonus added to the final score (only if the item matched). */
-  priorityBonus?: number
+  priorityBonus?: number;
 }
 
 // Built-in k8s API groups. Used to nudge these above CRDs on tied matches.
-const CORE_GROUP_BONUS = 10
-const WELL_KNOWN_GROUP_BONUS = 5
+const CORE_GROUP_BONUS = 10;
+const WELL_KNOWN_GROUP_BONUS = 5;
 const WELL_KNOWN_GROUPS = new Set([
-  'apps', 'batch', 'autoscaling', 'policy', 'networking.k8s.io', 'rbac.authorization.k8s.io',
-  'storage.k8s.io', 'scheduling.k8s.io', 'coordination.k8s.io', 'apiextensions.k8s.io',
-  'admissionregistration.k8s.io', 'apiregistration.k8s.io', 'certificates.k8s.io',
-  'events.k8s.io', 'discovery.k8s.io', 'flowcontrol.apiserver.k8s.io', 'node.k8s.io',
-  'authentication.k8s.io', 'authorization.k8s.io',
-])
+  "apps",
+  "batch",
+  "autoscaling",
+  "policy",
+  "networking.k8s.io",
+  "rbac.authorization.k8s.io",
+  "storage.k8s.io",
+  "scheduling.k8s.io",
+  "coordination.k8s.io",
+  "apiextensions.k8s.io",
+  "admissionregistration.k8s.io",
+  "apiregistration.k8s.io",
+  "certificates.k8s.io",
+  "events.k8s.io",
+  "discovery.k8s.io",
+  "flowcontrol.apiserver.k8s.io",
+  "node.k8s.io",
+  "authentication.k8s.io",
+  "authorization.k8s.io",
+]);
 
 function groupPriorityBonus(group: string): number {
-  if (!group) return CORE_GROUP_BONUS
-  if (WELL_KNOWN_GROUPS.has(group)) return WELL_KNOWN_GROUP_BONUS
-  return 0
+  if (!group) return CORE_GROUP_BONUS;
+  if (WELL_KNOWN_GROUPS.has(group)) return WELL_KNOWN_GROUP_BONUS;
+  return 0;
 }
 
 // Fuzzy match scoring: exact > prefix > word boundary > substring. Within a
 // tier, a coverage bonus (up to +20) breaks ties in favor of shorter labels.
 export function scoreMatch(text: string, query: string): number {
-  const lower = text.toLowerCase()
-  const q = query.toLowerCase()
-  if (!lower.includes(q)) return 0
-  let base: number
-  if (lower === q) base = 150
-  else if (lower.startsWith(q)) base = 100
+  const lower = text.toLowerCase();
+  const q = query.toLowerCase();
+  if (!lower.includes(q)) return 0;
+  let base: number;
+  if (lower === q) base = 150;
+  else if (lower.startsWith(q)) base = 100;
   else {
-    const wordStart = lower.indexOf(q)
-    const prev = lower[wordStart - 1]
-    base = wordStart > 0 && (prev === ' ' || prev === '/' || prev === '-' || prev === '.') ? 75 : 50
+    const wordStart = lower.indexOf(q);
+    const prev = lower[wordStart - 1];
+    base =
+      wordStart > 0 &&
+      (prev === " " || prev === "/" || prev === "-" || prev === ".")
+        ? 75
+        : 50;
   }
-  return base + (q.length / lower.length) * 20
+  return base + (q.length / lower.length) * 20;
 }
 
 export function bestScore(item: CommandItem, query: string): number {
-  let best = scoreMatch(item.label, query)
-  const secondary = Math.floor(Math.max(scoreMatch(item.sublabel || '', query), scoreMatch(item.category, query)) * 0.6)
-  best = Math.max(best, secondary)
+  let best = scoreMatch(item.label, query);
+  const secondary = Math.floor(
+    Math.max(
+      scoreMatch(item.sublabel || "", query),
+      scoreMatch(item.category, query),
+    ) * 0.6,
+  );
+  best = Math.max(best, secondary);
   if (item.searchTerms) {
-    for (const term of item.searchTerms) best = Math.max(best, scoreMatch(term, query))
+    for (const term of item.searchTerms)
+      best = Math.max(best, scoreMatch(term, query));
   }
-  return best > 0 ? best + (item.priorityBonus || 0) : 0
+  return best > 0 ? best + (item.priorityBonus || 0) : 0;
 }
 
 export interface CommandItemCallbacks {
-  onNavigateView: (view: MainView) => void
-  onNavigateKind: (kind: string, group: string) => void
-  onSwitchContext: (name: string) => void
-  onSetNamespaces: (ns: string[]) => void
-  onToggleTheme: () => void
-  onShowDiagnostics?: () => void
+  onNavigateView: (view: MainView) => void;
+  onNavigateKind: (kind: string, group: string) => void;
+  onSwitchContext: (name: string) => void;
+  onSetNamespaces: (ns: string[]) => void;
+  onToggleTheme: () => void;
+  onShowDiagnostics?: () => void;
 }
 
-const VIEW_ENTRIES: { view: MainView; label: string; icon: React.ComponentType<{ className?: string }>; shortcut: string }[] = [
-  { view: 'home', label: 'Home', icon: Home, shortcut: 'g h' },
-  { view: 'resources', label: 'Resources', icon: List, shortcut: 'g r' },
-  { view: 'issues', label: 'Issues', icon: AlertTriangle, shortcut: 'g i' },
-  { view: 'topology', label: 'Topology', icon: Network, shortcut: 'g t' },
-  { view: 'applications', label: 'Applications', icon: Boxes, shortcut: 'g a' },
-  { view: 'timeline', label: 'Timeline', icon: Clock, shortcut: 'g l' },
-  { view: 'helm', label: 'Helm', icon: Package, shortcut: 'g m' },
-  { view: 'gitops', label: 'GitOps', icon: GitBranch, shortcut: 'g o' },
-  { view: 'traffic', label: 'Live Traffic', icon: Activity, shortcut: 'g f' },
-  { view: 'checks', label: 'Checks', icon: ShieldCheck, shortcut: 'g u' },
-  { view: 'cost', label: 'Cost', icon: DollarSign, shortcut: 'g c' },
-]
+const VIEW_ENTRIES: {
+  view: MainView;
+  label: string;
+  icon: React.ComponentType<{ className?: string }>;
+  shortcut: string;
+}[] = [
+  { view: "home", label: "Home", icon: Home, shortcut: "g h" },
+  { view: "resources", label: "Resources", icon: List, shortcut: "g r" },
+  { view: "issues", label: "Issues", icon: AlertTriangle, shortcut: "g i" },
+  { view: "topology", label: "Topology", icon: Network, shortcut: "g t" },
+  { view: "applications", label: "Applications", icon: Boxes, shortcut: "g a" },
+  { view: "timeline", label: "Timeline", icon: Clock, shortcut: "g l" },
+  { view: "helm", label: "Helm", icon: Package, shortcut: "g m" },
+  { view: "gitops", label: "GitOps", icon: GitBranch, shortcut: "g o" },
+  { view: "traffic", label: "Live Traffic", icon: Activity, shortcut: "g f" },
+  { view: "checks", label: "Checks", icon: ShieldCheck, shortcut: "g u" },
+  { view: "capacity", label: "Capacity", icon: Gauge, shortcut: "g p" },
+  { view: "cost", label: "Cost", icon: DollarSign, shortcut: "g c" },
+];
 
 // The static command-palette items (Views, Resource Kinds, Contexts,
 // Namespaces, Actions) — shared by the centered modal (embedded) and the
 // standalone omnibar so the two never drift.
 export function useCommandItems(cb: CommandItemCallbacks): CommandItem[] {
-  const { data: namespacesData } = useNamespaces()
-  const { data: contexts } = useContexts()
-  const { data: apiResources } = useAPIResources()
+  const { data: namespacesData } = useNamespaces();
+  const { data: contexts } = useContexts();
+  const { data: apiResources } = useAPIResources();
 
   return useMemo<CommandItem[]>(() => {
-    const result: CommandItem[] = []
+    const result: CommandItem[] = [];
 
     for (const v of VIEW_ENTRIES) {
-      result.push({ id: `view-${v.view}`, label: `Go to ${v.label}`, category: 'Views', icon: v.icon, shortcut: v.shortcut, action: () => cb.onNavigateView(v.view) })
+      result.push({
+        id: `view-${v.view}`,
+        label: `Go to ${v.label}`,
+        category: "Views",
+        icon: v.icon,
+        shortcut: v.shortcut,
+        action: () => cb.onNavigateView(v.view),
+      });
     }
 
-    const resources = apiResources || CORE_RESOURCES
-    const seenKinds = new Set<string>()
+    const resources = apiResources || CORE_RESOURCES;
+    const seenKinds = new Set<string>();
     for (const r of resources) {
-      if (!r.verbs?.includes('list')) continue
-      const kindKey = `${r.name}/${r.group}`
-      if (seenKinds.has(kindKey)) continue
-      seenKinds.add(kindKey)
+      if (!r.verbs?.includes("list")) continue;
+      const kindKey = `${r.name}/${r.group}`;
+      if (seenKinds.has(kindKey)) continue;
+      seenKinds.add(kindKey);
       result.push({
         // Group shown only when it disambiguates (CRDs) — "core" is noise on
         // built-in kinds. priorityBonus still nudges core/well-known above CRDs.
-        id: `kind-${r.name}-${r.group}`, label: r.kind, sublabel: r.group || undefined, category: 'Resource Kinds',
-        icon: getResourceIcon(r.kind), action: () => cb.onNavigateKind(r.name, r.group),
-        searchTerms: [r.name, r.kind], priorityBonus: groupPriorityBonus(r.group),
-      })
+        id: `kind-${r.name}-${r.group}`,
+        label: r.kind,
+        sublabel: r.group || undefined,
+        category: "Resource Kinds",
+        icon: getResourceIcon(r.kind),
+        action: () => cb.onNavigateKind(r.name, r.group),
+        searchTerms: [r.name, r.kind],
+        priorityBonus: groupPriorityBonus(r.group),
+      });
     }
 
     if (contexts) {
@@ -134,45 +204,99 @@ export function useCommandItems(cb: CommandItemCallbacks): CommandItem[] {
       // it. Count display names so genuine duplicates (same cluster name from
       // different kubeconfig sources) stay distinguishable; unique ones stay clean.
       const parsedCtx = contexts.map((ctx) => {
-        const parsed = parseContextName(stripSourceSuffix(ctx.name, ctx.source))
-        const fromCluster = ctx.cluster ? parseContextName(ctx.cluster) : null
-        const meta = [parsed.provider ?? fromCluster?.provider, parsed.region ?? fromCluster?.region].filter(Boolean).join(' · ')
-        return { ctx, clusterName: parsed.clusterName, account: parsed.account, base: ctx.isCurrent ? 'current' : meta }
-      })
+        const parsed = parseContextName(
+          stripSourceSuffix(ctx.name, ctx.source),
+        );
+        const fromCluster = ctx.cluster ? parseContextName(ctx.cluster) : null;
+        const meta = [
+          parsed.provider ?? fromCluster?.provider,
+          parsed.region ?? fromCluster?.region,
+        ]
+          .filter(Boolean)
+          .join(" · ");
+        return {
+          ctx,
+          clusterName: parsed.clusterName,
+          account: parsed.account,
+          base: ctx.isCurrent ? "current" : meta,
+        };
+      });
       // Disambiguate on the FINAL visible (label, sublabel) pair, not just the
       // cluster name — same name + same provider/region from the same kubeconfig
       // file would otherwise render identically while switching different
       // contexts. Collisions fall back to the raw context name (unique by id).
-      const pairCount = new Map<string, number>()
-      for (const p of parsedCtx) pairCount.set(`${p.clusterName}\x00${p.base}`, (pairCount.get(`${p.clusterName}\x00${p.base}`) ?? 0) + 1)
+      const pairCount = new Map<string, number>();
+      for (const p of parsedCtx)
+        pairCount.set(
+          `${p.clusterName}\x00${p.base}`,
+          (pairCount.get(`${p.clusterName}\x00${p.base}`) ?? 0) + 1,
+        );
       for (const { ctx, clusterName, account, base } of parsedCtx) {
-        const collides = (pairCount.get(`${clusterName}\x00${base}`) ?? 0) > 1
-        const sub = [base, collides ? ctx.name : ''].filter(Boolean).join(' · ')
+        const collides = (pairCount.get(`${clusterName}\x00${base}`) ?? 0) > 1;
+        const sub = [base, collides ? ctx.name : ""]
+          .filter(Boolean)
+          .join(" · ");
         result.push({
           id: `context-${ctx.name}`,
           label: clusterName,
           sublabel: sub || undefined,
-          category: 'Clusters',
+          category: "Clusters",
           icon: Server,
-          action: () => { if (!ctx.isCurrent) cb.onSwitchContext(ctx.name) },
-          searchTerms: [ctx.name, account || ''].filter(Boolean),
-        })
+          action: () => {
+            if (!ctx.isCurrent) cb.onSwitchContext(ctx.name);
+          },
+          searchTerms: [ctx.name, account || ""].filter(Boolean),
+        });
       }
     }
 
     if (namespacesData) {
       for (const ns of namespacesData) {
-        result.push({ id: `ns-${ns.name}`, label: ns.name, category: 'Namespaces', action: () => cb.onSetNamespaces([ns.name]) })
+        result.push({
+          id: `ns-${ns.name}`,
+          label: ns.name,
+          category: "Namespaces",
+          action: () => cb.onSetNamespaces([ns.name]),
+        });
       }
-      result.push({ id: 'ns-all', label: 'All Namespaces', category: 'Namespaces', action: () => cb.onSetNamespaces([]) })
+      result.push({
+        id: "ns-all",
+        label: "All Namespaces",
+        category: "Namespaces",
+        action: () => cb.onSetNamespaces([]),
+      });
     }
 
-    result.push({ id: 'action-theme', label: 'Toggle Theme', category: 'Actions', icon: Sun, shortcut: 't', action: () => cb.onToggleTheme() })
+    result.push({
+      id: "action-theme",
+      label: "Toggle Theme",
+      category: "Actions",
+      icon: Sun,
+      shortcut: "t",
+      action: () => cb.onToggleTheme(),
+    });
     if (cb.onShowDiagnostics) {
-      result.push({ id: 'action-diagnostics', label: 'Diagnostics', category: 'Actions', icon: Stethoscope, action: () => cb.onShowDiagnostics?.(), searchTerms: ['debug', 'health', 'status', 'snapshot'] })
+      result.push({
+        id: "action-diagnostics",
+        label: "Diagnostics",
+        category: "Actions",
+        icon: Stethoscope,
+        action: () => cb.onShowDiagnostics?.(),
+        searchTerms: ["debug", "health", "status", "snapshot"],
+      });
     }
 
-    return result
+    return result;
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [apiResources, contexts, namespacesData, cb.onNavigateView, cb.onNavigateKind, cb.onSwitchContext, cb.onSetNamespaces, cb.onToggleTheme, cb.onShowDiagnostics])
+  }, [
+    apiResources,
+    contexts,
+    namespacesData,
+    cb.onNavigateView,
+    cb.onNavigateKind,
+    cb.onSwitchContext,
+    cb.onSetNamespaces,
+    cb.onToggleTheme,
+    cb.onShowDiagnostics,
+  ]);
 }

package/src/components/workload/WorkloadView.tsx

@@ -1,6 +1,7 @@
 import { useMemo, useEffect, useCallback, useState } from 'react'
 import { useQueries, useQueryClient } from '@tanstack/react-query'
 import { useNavigate, useLocation, useSearchParams } from 'react-router-dom'
+import { workloadPodAwaitsScheduling } from '../capacity/podDemandGate'
 import { clsx } from 'clsx'
 import { Terminal } from 'lucide-react'
 import {
@@ -19,10 +20,9 @@ import {
   gitOpsRouteForOwner,
   gitOpsOwnerFromRelationships,
   getGitOpsResourceStatus,
-  resolvedEnvFromKey,
 } from '@skyhook-io/k8s-ui'
 import type { ServicePortRenderProps } from '@skyhook-io/k8s-ui/components/resources/renderers/ServiceRenderer'
-import type { SelectedResource, ResourceRef, Relationships, ResolvedEnvFrom } from '../../types'
+import type { SelectedResource, ResourceRef, Relationships } from '../../types'
 import {
   kindToPlural,
   pluralToKind,
@@ -95,6 +95,7 @@ import {
 import { useToast } from '../ui/Toast'
 import { Tooltip } from '../ui/Tooltip'
 import { PodRenderer } from '../resources/renderers/PodRenderer'
+import { KarpenterNodePoolRenderer } from '../resources/renderers/KarpenterNodePoolRenderer'
 import { NodeRenderer } from '../resources/renderers/NodeRenderer'
 import { ServiceRenderer } from '../resources/renderers/ServiceRenderer'
 import { WorkloadRenderer } from '../resources/renderers/WorkloadRenderer'
@@ -126,6 +127,7 @@ const BATCH_EXECUTION_KINDS = new Set([
 // Stable reference — web renderer wrappers inject platform hooks internally
 const rendererOverrides: RendererOverrides = {
   PodRenderer,
+  KarpenterNodePoolRenderer,
   NodeRenderer,
   ServiceRenderer,
   WorkloadRenderer,
@@ -548,85 +550,6 @@ export function WorkloadView({
     [helmOwner, helmSourceResource],
   )
 
-  // For pods: extract envFrom ConfigMap/Secret names and resolve their keys
-  const isPod = apiKind === 'pods'
-  const { envFromConfigMapNames, envFromSecretNames } = useMemo(() => {
-    if (!isPod || !resource)
-      return {
-        envFromConfigMapNames: [] as string[],
-        envFromSecretNames: [] as string[],
-      }
-    const cmNames = new Set<string>()
-    const secretNames = new Set<string>()
-    const containers = [
-      ...(resource.spec?.containers || []),
-      ...(resource.spec?.initContainers || []),
-    ]
-    for (const c of containers) {
-      for (const ef of c.envFrom || []) {
-        if (ef.configMapRef?.name) cmNames.add(ef.configMapRef.name)
-        if (ef.secretRef?.name) secretNames.add(ef.secretRef.name)
-      }
-    }
-    return {
-      envFromConfigMapNames: Array.from(cmNames),
-      envFromSecretNames: Array.from(secretNames),
-    }
-  }, [isPod, resource])
-
-  const configMapQueries = useQueries({
-    queries: envFromConfigMapNames.map((cmName) => ({
-      queryKey: ['resources', 'configmaps', namespace, cmName],
-      queryFn: () => fetchJSON<any>(`/resources/configmaps/${namespace}/${cmName}`),
-      enabled: isPod,
-      staleTime: 30000,
-    })),
-  })
-
-  const secretQueries = useQueries({
-    queries: envFromSecretNames.map((secretName) => ({
-      queryKey: ['resources', 'secrets', namespace, secretName],
-      queryFn: () => fetchJSON<any>(`/resources/secrets/${namespace}/${secretName}`),
-      enabled: isPod,
-      staleTime: 30000,
-    })),
-  })
-
-  const resolvedEnvFrom = useMemo(() => {
-    if (!isPod || (envFromConfigMapNames.length === 0 && envFromSecretNames.length === 0))
-      return undefined
-    const result: ResolvedEnvFrom = {}
-    envFromConfigMapNames.forEach((n, i) => {
-      // Single-resource endpoint returns { resource, relationships } wrapper
-      const cm = configMapQueries[i]?.data?.resource ?? configMapQueries[i]?.data
-      if (cm)
-        result[resolvedEnvFromKey('configmap', n)] = {
-          keys: Object.keys(cm.data || {}),
-          values: cm.data || {},
-          isSecret: false,
-        }
-    })
-    envFromSecretNames.forEach((n, i) => {
-      const secret = secretQueries[i]?.data?.resource ?? secretQueries[i]?.data
-      if (secret) {
-        const decodedValues: Record<string, string> = {}
-        for (const [k, v] of Object.entries(secret.data || {})) {
-          try {
-            decodedValues[k] = atob(v as string)
-          } catch {
-            decodedValues[k] = v as string
-          }
-        }
-        result[resolvedEnvFromKey('secret', n)] = {
-          keys: Object.keys(decodedValues),
-          values: decodedValues,
-          isSecret: true,
-        }
-      }
-    })
-    return Object.keys(result).length > 0 ? result : undefined
-  }, [isPod, envFromConfigMapNames, envFromSecretNames, configMapQueries, secretQueries])
-
   // Fetch topology for hierarchy building (only when expanded)
   const { data: topology } = useTopology([namespace], 'resources', {
     enabled: expanded,
@@ -654,7 +577,7 @@ export function WorkloadView({
 
   // RBAC
   const canUpdateSecrets = useCanUpdateSecrets()
-  const { features } = useCapabilitiesContext()
+  const { features, karpenter } = useCapabilitiesContext()
   const { canPortForward } = useNamespacedCapabilities(namespace)
   const isLocalDeployment = useIsLocalDeployment()
   const showServingPortForward = canPortForward || !isLocalDeployment
@@ -837,6 +760,9 @@ export function WorkloadView({
 
   const supportsWorkloadPods = ['deployments', 'statefulsets', 'daemonsets'].includes(apiKind)
   const workloadPodsQuery = useWorkloadPods(supportsWorkloadPods ? apiKind : '', namespace, name)
+  const workloadAwaitsCapacity =
+    karpenter?.state === 'available' &&
+    (workloadPodsQuery.data?.pods ?? []).some(workloadPodAwaitsScheduling)
   const servingRefs = useMemo(() => collectServingRefs(relationships), [relationships])
   const servingQueries = useQueries({
     queries: servingRefs.map((ref) => {
@@ -887,6 +813,14 @@ export function WorkloadView({
         certificateInfo={certificateInfo}
         hpaDiagnosis={hpaDiagnosis}
         workloadPods={supportsWorkloadPods ? workloadPodsQuery.data?.pods : undefined}
+        onEvaluateCapacity={
+          workloadAwaitsCapacity
+            ? () =>
+                navigateRouter(
+                  `/capacity/demand?owner=${encodeURIComponent(`${namespace}/${pluralToKind(apiKind)}/${name}`)}`,
+                )
+            : undefined
+        }
         workloadPodsLoading={supportsWorkloadPods ? workloadPodsQuery.isLoading : false}
         workloadPodsError={supportsWorkloadPods ? (workloadPodsQuery.error as Error | null) : null}
         servingResources={servingResources}
@@ -969,7 +903,6 @@ export function WorkloadView({
         onDownload={desktopDownload}
         actionsBarProps={actionsBarProps}
         rendererOverrides={rendererOverrides}
-        resolvedEnvFrom={resolvedEnvFrom}
         renderOverviewExtra={({ kind: k, namespace: ns, name: n }) => (
           <>
             <FluxSourceConsumersSection kind={k} namespace={ns} name={n} />

package/src/context/ConnectionContext.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest'
+
+import { shouldApplyPolledConnection, shouldAutoRetryConnection } from './ConnectionContext'
+
+describe('shouldAutoRetryConnection', () => {
+  it('retries transient failures', () => {
+    expect(shouldAutoRetryConnection('network')).toBe(true)
+    expect(shouldAutoRetryConnection('timeout')).toBe(true)
+    expect(shouldAutoRetryConnection(undefined)).toBe(true)
+  })
+
+  it('leaves auth-shaped failures to the server-side recovery loop', () => {
+    expect(shouldAutoRetryConnection('auth')).toBe(false)
+    expect(shouldAutoRetryConnection('auth-rejected')).toBe(false)
+  })
+
+  it('leaves configuration and RBAC errors for the user to resolve', () => {
+    expect(shouldAutoRetryConnection('config')).toBe(false)
+    expect(shouldAutoRetryConnection('rbac')).toBe(false)
+  })
+})
+
+describe('shouldApplyPolledConnection', () => {
+  it('recovers a missed disconnected SSE frame', () => {
+    expect(shouldApplyPolledConnection('connected', 'disconnected', 2, 2)).toBe(true)
+  })
+
+  it('does not flash a connected UI back to startup progress', () => {
+    expect(shouldApplyPolledConnection('connected', 'connecting', 2, 2)).toBe(false)
+  })
+
+  it('does not let a poll started before an SSE update overwrite it', () => {
+    expect(shouldApplyPolledConnection('disconnected', 'connected', 1, 2)).toBe(false)
+  })
+
+  it('allows a fresh fallback poll to observe recovery after an SSE update', () => {
+    expect(shouldApplyPolledConnection('disconnected', 'connected', 2, 2)).toBe(true)
+  })
+})