diff --git a/src/components/ClusterStatGrids.jsx b/src/components/ClusterStatGrids.jsx
index 486b907b..ae3c66a6 100644
--- a/src/components/ClusterStatGrids.jsx
+++ b/src/components/ClusterStatGrids.jsx
@@ -11,7 +11,6 @@ const ClickLoader = memo(({isLoading}) => (
 
 export const GridNodes = memo(({nodeCount, frozenCount, onClick}) => {
     const [isLoading, setIsLoading] = useState(false);
-
     const handleClick = useCallback(() => {
         setIsLoading(true);
         prepareForNavigation();
@@ -22,13 +21,7 @@ export const GridNodes = memo(({nodeCount, frozenCount, onClick}) => {
     }, [onClick]);
 
     const subtitle = useMemo(() => (
-        <Box sx={{
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            gap: 1,
-            width: '100%'
-        }}>
+        <Box sx={{display: 'flex', alignItems: 'center', justifyContent: 'center', gap: 1, width: '100%'}}>
             <Chip
                 label={`Frozen ${frozenCount}`}
                 size="small"
@@ -45,14 +38,7 @@ export const GridNodes = memo(({nodeCount, frozenCount, onClick}) => {
         </Box>
     ), [frozenCount, isLoading, handleClick]);
 
-    return (
-        <StatCard
-            title="Nodes"
-            value={nodeCount}
-            subtitle={subtitle}
-            onClick={handleClick}
-        />
-    );
+    return <StatCard title="Nodes" value={nodeCount} subtitle={subtitle} onClick={handleClick}/>;
 });
 
 export const GridObjects = memo(({objectCount, statusCount, onClick}) => {
@@ -79,7 +65,6 @@ export const GridObjects = memo(({objectCount, statusCount, onClick}) => {
     const subtitle = useMemo(() => {
         const chips = [];
         const statuses = ['up', 'warn', 'down', 'unprovisioned'];
-
         for (const status of statuses) {
             const count = statusCount[status] || 0;
             if (count > 0) {
@@ -94,7 +79,6 @@ export const GridObjects = memo(({objectCount, statusCount, onClick}) => {
                 );
             }
         }
-
         return (
             <Box sx={{display: "flex", justifyContent: "center", gap: 1, flexWrap: "wrap"}}>
                 {chips}
@@ -103,31 +87,15 @@ export const GridObjects = memo(({objectCount, statusCount, onClick}) => {
         );
     }, [statusCount, loadingStatus, handleChipClick]);
 
-    return (
-        <StatCard
-            title="Objects"
-            value={objectCount}
-            subtitle={subtitle}
-            onClick={handleCardClick}
-        />
-    );
+    return <StatCard title="Objects" value={objectCount} subtitle={subtitle} onClick={handleCardClick}/>;
 });
 
 const StatusChip = memo(({status, count, isLoading, onClick}) => {
-    const colors = {
-        up: 'green',
-        warn: 'orange',
-        down: 'red',
-        unprovisioned: 'red'
-    };
-
+    const colors = {up: 'green', warn: 'orange', down: 'red', unprovisioned: 'red'};
     const handleClick = useCallback((e) => {
         e.stopPropagation();
-        if (!isLoading) {
-            onClick();
-        }
+        if (!isLoading) onClick();
     }, [onClick, isLoading]);
-
     return (
         <Box sx={{display: 'inline-flex', alignItems: 'center', gap: 0.5}}>
             <Chip
@@ -147,6 +115,7 @@ const StatusChip = memo(({status, count, isLoading, onClick}) => {
     );
 });
 
+// ==================== NAMESPACES ====================
 export const GridNamespaces = memo(({namespaceCount, namespaceSubtitle, onClick}) => {
     const [loadingNamespace, setLoadingNamespace] = useState('');
     const [isCardLoading, setIsCardLoading] = useState(false);
@@ -160,30 +129,26 @@ export const GridNamespaces = memo(({namespaceCount, namespaceSubtitle, onClick}
         }, 50);
     }, [onClick]);
 
-    const subtitle = useMemo(() => {
-        return (
-            <Box sx={{
-                display: "flex",
-                flexWrap: "wrap",
-                gap: 1,
-                pt: 1,
-                maxHeight: '400px',
-                overflowY: 'auto',
-                justifyContent: 'flex-start'
-            }}>
-                {namespaceSubtitle.map(({namespace, status}) => (
-                    <NamespaceChip
-                        key={namespace}
-                        namespace={namespace}
-                        status={status}
-                        isLoading={loadingNamespace === namespace}
-                        onClick={onClick}
-                        onLoadingChange={setLoadingNamespace}
-                    />
-                ))}
-            </Box>
-        );
-    }, [namespaceSubtitle, loadingNamespace, onClick]);
+    const subtitle = useMemo(() => (
+        <Box sx={{
+            display: "flex",
+            flexWrap: "wrap",
+            gap: 1,
+            pt: 1,
+            justifyContent: 'flex-start'
+        }}>
+            {namespaceSubtitle.map(({namespace, status}) => (
+                <NamespaceChip
+                    key={namespace}
+                    namespace={namespace}
+                    status={status}
+                    isLoading={loadingNamespace === namespace}
+                    onClick={onClick}
+                    onLoadingChange={setLoadingNamespace}
+                />
+            ))}
+        </Box>
+    ), [namespaceSubtitle, loadingNamespace, onClick]);
 
     return (
         <StatCard
@@ -221,7 +186,6 @@ const NamespaceChip = memo(({namespace, status, isLoading, onClick, onLoadingCha
     const statusElements = useMemo(() => {
         const elements = [];
         const statusTypes = ['up', 'warn', 'down', 'unprovisioned'];
-
         for (const stat of statusTypes) {
             const count = status[stat] || 0;
             if (count > 0) {
@@ -313,11 +277,8 @@ const NamespaceChip = memo(({namespace, status, isLoading, onClick, onLoadingCha
     );
 });
 
-export const GridHeartbeats = memo(({
-                                        heartbeatCount,
-                                        perHeartbeatStats = {},
-                                        onClick
-                                    }) => {
+// ==================== HEARTBEATS ====================
+export const GridHeartbeats = memo(({heartbeatCount, perHeartbeatStats = {}, onClick}) => {
     const [loadingId, setLoadingId] = useState('');
 
     const handleCardClick = useCallback(() => {
@@ -342,34 +303,20 @@ export const GridHeartbeats = memo(({
 
     const subtitle = useMemo(() => {
         const groups = new Map();
-
         for (const [fullId, {running, beating}] of Object.entries(perHeartbeatStats)) {
             if (running === 0 && beating === 0) continue;
-
             let baseId = fullId;
-            if (fullId.endsWith('.rx')) {
-                baseId = fullId.slice(0, -3);
-            } else if (fullId.endsWith('.tx')) {
-                baseId = fullId.slice(0, -3);
-            }
-
-            if (!groups.has(baseId)) {
-                groups.set(baseId, {total: 0, healthy: 0});
-            }
+            if (fullId.endsWith('.rx')) baseId = fullId.slice(0, -3);
+            else if (fullId.endsWith('.tx')) baseId = fullId.slice(0, -3);
+            if (!groups.has(baseId)) groups.set(baseId, {total: 0, healthy: 0});
             const group = groups.get(baseId);
             group.total += 1;
-
-            const isHealthy = running > 0 && beating === running;
-            if (isHealthy) {
-                group.healthy += 1;
-            }
+            if (running > 0 && beating === running) group.healthy += 1;
         }
-
         const chips = [];
         for (const [baseId, {total, healthy}] of groups.entries()) {
             const isHealthy = (total === healthy);
             const isLoading = loadingId === baseId;
-
             chips.push(
                 <Box key={baseId} sx={{display: 'inline-flex', alignItems: 'center', gap: 0.5}}>
                     <Chip
@@ -388,34 +335,20 @@ export const GridHeartbeats = memo(({
                 </Box>
             );
         }
-
         return (
-            <Box sx={{
-                display: "flex",
-                flexWrap: "wrap",
-                justifyContent: "center",
-                gap: 1,
-                minHeight: "40px"
-            }}>
+            <Box sx={{display: "flex", flexWrap: "wrap", justifyContent: "center", gap: 1, minHeight: "40px"}}>
                 {chips}
             </Box>
         );
     }, [perHeartbeatStats, loadingId, handleChipClick]);
 
-    return (
-        <StatCard
-            title="Heartbeats"
-            value={heartbeatCount}
-            subtitle={subtitle}
-            onClick={handleCardClick}
-            isLoading={loadingId === 'card'}
-        />
-    );
+    return <StatCard title="Heartbeats" value={heartbeatCount} subtitle={subtitle} onClick={handleCardClick}
+                     isLoading={loadingId === 'card'}/>;
 });
 
+// ==================== POOLS ====================
 export const GridPools = memo(({poolCount, pools, onClick}) => {
     const [isLoading, setIsLoading] = useState(false);
-
     const handleClick = useCallback(() => {
         setIsLoading(true);
         prepareForNavigation();
@@ -426,67 +359,36 @@ export const GridPools = memo(({poolCount, pools, onClick}) => {
     }, [onClick]);
 
     const subtitle = useMemo(() => {
-        if (!pools || pools.length === 0) {
-            return null;
-        }
-
+        if (!pools || pools.length === 0) return null;
         return (
-            <Box sx={{
-                display: "flex",
-                flexWrap: "wrap",
-                gap: 1,
-                pt: 1,
-                maxHeight: '400px',
-                overflowY: 'auto',
-                justifyContent: 'flex-start'
-            }}>
+            <Box sx={{display: "flex", flexWrap: "wrap", gap: 1, justifyContent: 'flex-start'}}>
                 {pools.map((pool) => {
-                    const usagePercentage = pool.size && pool.used >= 0
-                        ? ((pool.used / pool.size) * 100).toFixed(1)
-                        : "N/A";
+                    const usagePercentage = pool.size && pool.used >= 0 ? ((pool.used / pool.size) * 100).toFixed(1) : "N/A";
                     const free = pool.size - pool.used;
                     const freePercent = pool.size ? (free / pool.size) * 100 : 100;
                     const isLowStorage = freePercent < 10;
-
                     return (
-                        <Box key={pool.name || Math.random()} sx={{
-                            position: 'relative',
-                            display: 'inline-flex',
-                            flexShrink: 0,
-                            margin: "4px"
-                        }}>
-                            <Chip
-                                label={`${pool.name || "Unnamed"} (${usagePercentage}% used)`}
-                                size="small"
-                                sx={{
-                                    backgroundColor: isLowStorage ? 'red' : 'default',
-                                    color: isLowStorage ? 'white' : 'inherit',
-                                    cursor: 'pointer',
-                                    minWidth: "fit-content",
-                                    px: 1.5
-                                }}
-                            />
-                        </Box>
+                        <Chip
+                            key={pool.name || Math.random()}
+                            label={`${pool.name || "Unnamed"} (${usagePercentage}% used)`}
+                            size="small"
+                            sx={{
+                                backgroundColor: isLowStorage ? 'red' : 'default',
+                                color: isLowStorage ? 'white' : 'inherit'
+                            }}
+                        />
                     );
                 })}
             </Box>
         );
     }, [pools]);
 
-    return (
-        <StatCard
-            title="Pools"
-            value={poolCount}
-            subtitle={subtitle}
-            onClick={handleClick}
-            isLoading={isLoading}
-        />
-    );
+    return <StatCard title="Pools" value={poolCount} subtitle={subtitle} onClick={handleClick} isLoading={isLoading}/>;
 });
 
+// ==================== NETWORKS ====================
 export const GridNetworks = memo(({networks, onClick}) => {
     const [isLoading, setIsLoading] = useState(false);
-
     const handleCardClick = useCallback(() => {
         setIsLoading(true);
         prepareForNavigation();
@@ -496,61 +398,33 @@ export const GridNetworks = memo(({networks, onClick}) => {
         }, 50);
     }, [onClick]);
 
-    const subtitle = useMemo(() => {
-        return (
-            <Box sx={{
-                display: "flex",
-                flexWrap: "wrap",
-                gap: 1,
-                pt: 1,
-                maxHeight: '400px',
-                overflowY: 'auto',
-                justifyContent: 'flex-start'
-            }}>
-                {networks.map((network) => {
-                    const usagePercentage = network.size
-                        ? ((network.used / network.size) * 100).toFixed(1)
-                        : 0;
-                    const free = network.size - network.used;
-                    const freePercent = network.size ? (free / network.size) * 100 : 100;
-                    const isLowStorage = freePercent < 10;
-
-                    return (
-                        <Box key={network.name} sx={{
-                            position: 'relative',
-                            display: 'inline-flex',
-                            flexShrink: 0,
-                            margin: "4px"
-                        }}>
-                            <Chip
-                                label={`${network.name} (${usagePercentage}% used)`}
-                                size="small"
-                                sx={{
-                                    backgroundColor: isLowStorage ? 'red' : 'default',
-                                    color: isLowStorage ? 'white' : 'inherit',
-                                    cursor: 'pointer',
-                                    minWidth: "fit-content",
-                                    px: 1.5
-                                }}
-                            />
-                        </Box>
-                    );
-                })}
-            </Box>
-        );
-    }, [networks]);
+    const subtitle = useMemo(() => (
+        <Box sx={{display: "flex", flexWrap: "wrap", gap: 1, justifyContent: 'flex-start'}}>
+            {networks.map((network) => {
+                const usagePercentage = network.size ? ((network.used / network.size) * 100).toFixed(1) : 0;
+                const free = network.size - network.used;
+                const freePercent = network.size ? (free / network.size) * 100 : 100;
+                const isLowStorage = freePercent < 10;
+                return (
+                    <Chip
+                        key={network.name}
+                        label={`${network.name} (${usagePercentage}% used)`}
+                        size="small"
+                        sx={{
+                            backgroundColor: isLowStorage ? 'red' : 'default',
+                            color: isLowStorage ? 'white' : 'inherit'
+                        }}
+                    />
+                );
+            })}
+        </Box>
+    ), [networks]);
 
-    return (
-        <StatCard
-            title="Networks"
-            value={networks.length}
-            subtitle={subtitle}
-            onClick={handleCardClick}
-            isLoading={isLoading}
-        />
-    );
+    return <StatCard title="Networks" value={networks.length} subtitle={subtitle} onClick={handleCardClick}
+                     isLoading={isLoading}/>;
 });
 
+// ==================== KINDS ====================
 export const GridKinds = memo(({kindCount, kindSubtitle, onClick}) => {
     const [loadingKind, setLoadingKind] = useState('');
     const [isCardLoading, setIsCardLoading] = useState(false);
@@ -564,30 +438,26 @@ export const GridKinds = memo(({kindCount, kindSubtitle, onClick}) => {
         }, 50);
     }, [onClick]);
 
-    const subtitle = useMemo(() => {
-        return (
-            <Box sx={{
-                display: "flex",
-                flexWrap: "wrap",
-                gap: 1,
-                pt: 1,
-                maxHeight: '400px',
-                overflowY: 'auto',
-                justifyContent: 'flex-start'
-            }}>
-                {kindSubtitle.map(({kind, status}) => (
-                    <KindChip
-                        key={kind}
-                        kind={kind}
-                        status={status}
-                        isLoading={loadingKind === kind}
-                        onClick={onClick}
-                        onLoadingChange={setLoadingKind}
-                    />
-                ))}
-            </Box>
-        );
-    }, [kindSubtitle, loadingKind, onClick]);
+    const subtitle = useMemo(() => (
+        <Box sx={{
+            display: "flex",
+            flexWrap: "wrap",
+            gap: 1,
+            pt: 1,
+            justifyContent: 'flex-start'
+        }}>
+            {kindSubtitle.map(({kind, status}) => (
+                <KindChip
+                    key={kind}
+                    kind={kind}
+                    status={status}
+                    isLoading={loadingKind === kind}
+                    onClick={onClick}
+                    onLoadingChange={setLoadingKind}
+                />
+            ))}
+        </Box>
+    ), [kindSubtitle, loadingKind, onClick]);
 
     return (
         <StatCard
@@ -625,7 +495,6 @@ const KindChip = memo(({kind, status, isLoading, onClick, onLoadingChange}) => {
     const statusElements = useMemo(() => {
         const elements = [];
         const statusTypes = ['up', 'warn', 'down', 'unprovisioned'];
-
         for (const stat of statusTypes) {
             const count = status[stat] || 0;
             if (count > 0) {
diff --git a/src/components/ConfigSection.jsx b/src/components/ConfigSection.jsx
index 3d021955..05b90ec4 100644
--- a/src/components/ConfigSection.jsx
+++ b/src/components/ConfigSection.jsx
@@ -29,7 +29,7 @@ import DeleteIcon from "@mui/icons-material/Delete";
 import {URL_OBJECT, URL_NODE} from "../config/apiPath.js";
 import {parseObjectPath} from "../utils/objectUtils";
 
-const useConfig = (decodedObjectName, configNode, setConfigNode) => {
+const useConfig = (decodedObjectName, configNode, setConfigNode, refreshTrigger) => {
     const initialState = {
         data: null,
         loading: false,
@@ -43,20 +43,23 @@ const useConfig = (decodedObjectName, configNode, setConfigNode) => {
                 return {...state, loading: false, data: action.payload};
             case "FETCH_ERROR":
                 return {...state, loading: false, error: action.payload};
+            case "RESET":
+                return initialState;
             default:
                 return state;
         }
     };
     const [state, dispatch] = useReducer(reducer, initialState);
     const lastFetch = useRef({});
-    const fetchConfig = useCallback(async (node) => {
+
+    const fetchConfig = useCallback(async (node, forceBypassThrottle = false) => {
         if (!node) {
-            dispatch({type: "FETCH_ERROR", payload: "No node available to fetch configuration."});
+            dispatch({type: "RESET"});
             return;
         }
         const key = `${decodedObjectName}:${node}`;
         const now = Date.now();
-        if (lastFetch.current[key] && now - lastFetch.current[key] < 1000) return;
+        if (!forceBypassThrottle && lastFetch.current[key] && now - lastFetch.current[key] < 1000) return;
         lastFetch.current[key] = now;
         const {namespace, kind, name} = parseObjectPath(decodedObjectName);
         const token = localStorage.getItem("authToken") || "";
@@ -78,13 +81,26 @@ const useConfig = (decodedObjectName, configNode, setConfigNode) => {
             dispatch({type: "FETCH_ERROR", payload: `Failed to fetch config: ${err.message}`});
         }
     }, [decodedObjectName, setConfigNode]);
+
     useEffect(() => {
         if (configNode) {
             fetchConfig(configNode);
         } else {
-            dispatch({type: "FETCH_ERROR", payload: "No node available to fetch configuration."});
+            dispatch({type: "RESET"});
         }
     }, [configNode, decodedObjectName, fetchConfig]);
+
+    // Force re-fetch when refreshTrigger bumps (external config change via SSE)
+    const prevRefreshTrigger = useRef(refreshTrigger);
+    useEffect(() => {
+        if (refreshTrigger === prevRefreshTrigger.current) return;
+        prevRefreshTrigger.current = refreshTrigger;
+        if (configNode) {
+            // Bypass throttle so the fresh content is fetched immediately
+            fetchConfig(configNode, true);
+        }
+    }, [refreshTrigger, configNode, fetchConfig]);
+
     return {...state, fetchConfig};
 };
 
@@ -589,7 +605,8 @@ const ConfigSection = ({
                            setConfigNode,
                            openSnackbar,
                            configDialogOpen,
-                           setConfigDialogOpen
+                           setConfigDialogOpen,
+                           configRefreshTrigger = 0,
                        }) => {
     const theme = useTheme();
     const isDark = theme.palette.mode === 'dark';
@@ -597,7 +614,8 @@ const ConfigSection = ({
     const {data: configData, loading: configLoading, error: configError, fetchConfig} = useConfig(
         decodedObjectName,
         configNode,
-        setConfigNode
+        setConfigNode,
+        configRefreshTrigger,
     );
     const {
         data: keywordsData,
@@ -661,7 +679,7 @@ const ConfigSection = ({
             }
             openSnackbar("Configuration updated successfully");
             if (configNode) {
-                await fetchConfig(configNode);
+                await fetchConfig(configNode, true);
                 setConfigDialogOpen(true);
             }
         } catch (err) {
@@ -728,7 +746,7 @@ const ConfigSection = ({
         if (successCount > 0) {
             openSnackbar(`Successfully added ${successCount} parameter(s)`, "success");
             if (configNode) {
-                await fetchConfig(configNode);
+                await fetchConfig(configNode, true);
                 await fetchExistingParams();
                 setConfigDialogOpen(true);
             }
@@ -773,7 +791,7 @@ const ConfigSection = ({
         if (successCount > 0) {
             openSnackbar(`Successfully unset ${successCount} parameter(s)`, "success");
             if (configNode) {
-                await fetchConfig(configNode);
+                await fetchConfig(configNode, true);
                 await fetchExistingParams();
                 setConfigDialogOpen(true);
             }
@@ -812,7 +830,7 @@ const ConfigSection = ({
         if (successCount > 0) {
             openSnackbar(`Successfully deleted ${successCount} section(s)`, "success");
             if (configNode) {
-                await fetchConfig(configNode);
+                await fetchConfig(configNode, true);
                 await fetchExistingParams();
                 setConfigDialogOpen(true);
             }
@@ -840,7 +858,7 @@ const ConfigSection = ({
 
     return (
         <Box sx={{mb: 2, width: "100%", display: 'flex', justifyContent: 'flex-end'}}>
-            <Box sx={{ width: '100%', overflow: 'hidden' }}>
+            <Box sx={{width: '100%', overflow: 'hidden'}}>
                 <Button
                     variant="contained"
                     size="small"
@@ -897,9 +915,14 @@ const ConfigSection = ({
                                 </IconButton>
                             </Tooltip>
                         </Box>
+                        {!configNode && !configLoading && !configError && (
+                            <Typography color="textSecondary" variant="body2">
+                                No instance selected to view configuration.
+                            </Typography>
+                        )}
                         {configLoading && <CircularProgress size={24}/>}
                         {configError && <Alert severity="error" sx={{mb: 2}}>{configError}</Alert>}
-                        {!configLoading && !configError && configData === null && (
+                        {!configLoading && !configError && configData === null && configNode && (
                             <Typography color="textSecondary" variant="body2">No configuration available.</Typography>
                         )}
                         {!configLoading && !configError && configData !== null && (
diff --git a/src/components/HeaderSection.jsx b/src/components/HeaderSection.jsx
index abc97589..33d74826 100644
--- a/src/components/HeaderSection.jsx
+++ b/src/components/HeaderSection.jsx
@@ -48,7 +48,7 @@ const HeaderSection = ({
             {name: "flip", options: {enabled: true}},
         ],
         sx: {
-            zIndex: 1300,
+            zIndex: 10000,
             "& .MuiPaper-root": {minWidth: 200, boxShadow: "0px 5px 15px rgba(0,0,0,0.2)"},
         },
     });
@@ -129,7 +129,7 @@ const HeaderSection = ({
                     <Popper open={Boolean(objectMenuAnchor)} anchorEl={objectMenuAnchor} {...popperProps()}>
                         <ClickAwayListener onClickAway={() => setObjectMenuAnchor(null)}>
                             <Paper elevation={3} role="menu">
-                                {OBJECT_ACTIONS.map(({name, icon}) => {
+                                {OBJECT_ACTIONS.map(({name, icon, color}) => {
                                     const isAllowed = isActionAllowedForSelection(name, [decodedObjectName]);
                                     return (
                                         <MenuItem
@@ -140,13 +140,20 @@ const HeaderSection = ({
                                             }}
                                             disabled={!isAllowed || actionInProgress}
                                             sx={{
-                                                color: isAllowed ? 'inherit' : 'text.disabled',
+                                                color: isAllowed
+                                                    ? (color === "red" ? "error.main" : "inherit")
+                                                    : "text.disabled",
                                                 '&.Mui-disabled': {opacity: 0.5},
                                             }}
                                             aria-label={`Object ${name} action`}
                                         >
                                             <ListItemIcon
-                                                sx={{minWidth: 40, color: isAllowed ? 'inherit' : 'text.disabled'}}>
+                                                sx={{
+                                                    minWidth: 40,
+                                                    color: isAllowed
+                                                        ? (color === "red" ? "error.main" : "inherit")
+                                                        : "text.disabled"
+                                                }}>
                                                 {icon}
                                             </ListItemIcon>
                                             <ListItemText>
diff --git a/src/components/InstanceCard.jsx b/src/components/InstanceCard.jsx
index f90e3eaf..5c75bf20 100644
--- a/src/components/InstanceCard.jsx
+++ b/src/components/InstanceCard.jsx
@@ -15,19 +15,19 @@ import {grey, blue, red} from "@mui/material/colors";
 import logger from '../utils/logger.js';
 
 const InstanceCard = ({
-                      node,
-                      nodeData = {},
-                      selectedNodes = [],
-                      toggleNode = () => logger.warn("toggleNode not provided"),
-                      actionInProgress = false,
-                      setIndividualNodeMenuAnchor = () => logger.warn("setIndividualNodeMenuAnchor not provided"),
-                      setCurrentNode = () => logger.warn("setCurrentNode not provided"),
-                      getColor = () => grey[500],
-                      getNodeState = () => ({avail: "unknown", frozen: "unfrozen", state: null}),
-                      instanceName,
-                      onOpenLogs = () => logger.warn("onOpenLogs not provided"),
-                      onViewInstance,
-                  }) => {
+                          node,
+                          nodeData = {},
+                          selectedNodes = [],
+                          toggleNode = () => logger.warn("toggleNode not provided"),
+                          actionInProgress = false,
+                          setIndividualNodeMenuAnchor = () => logger.warn("setIndividualNodeMenuAnchor not provided"),
+                          setCurrentNode = () => logger.warn("setCurrentNode not provided"),
+                          getColor = () => grey[500],
+                          getNodeState = () => ({avail: "unknown", frozen: "unfrozen", state: null}),
+                          instanceName,
+                          onOpenLogs = () => logger.warn("onOpenLogs not provided"),
+                          onViewInstance,
+                      }) => {
     const resolvedInstanceName = instanceName || nodeData?.instanceName || nodeData?.name || node;
     const [isHovered, setIsHovered] = useState(false);
 
diff --git a/src/components/NodeRow.jsx b/src/components/NodeRow.jsx
index ad93d481..12a86156 100644
--- a/src/components/NodeRow.jsx
+++ b/src/components/NodeRow.jsx
@@ -264,8 +264,12 @@ const NodeRow = ({
                     open={Boolean(anchorEl)}
                     onClose={() => onMenuClose(nodename)}
                     {...menuProps}
+                    sx={{
+                        ...(menuProps.sx || {}),
+                        zIndex: 10000,
+                    }}
                 >
-                    {filteredMenuItems.map(({name, icon}) => (
+                    {filteredMenuItems.map(({name, icon, color}) => (
                         <MenuItem
                             key={name}
                             onClick={(e) => {
@@ -273,10 +277,17 @@ const NodeRow = ({
                                 onAction(nodename, name);
                                 onMenuClose(nodename);
                             }}
-                            sx={{display: "flex", alignItems: "center", gap: 1}}
+                            sx={{
+                                display: "flex",
+                                alignItems: "center",
+                                gap: 1,
+                                color: color === "red" ? "error.main" : "inherit",
+                            }}
                             aria-label={`${name} action`}
                         >
-                            <ListItemIcon>{icon}</ListItemIcon>
+                            <ListItemIcon sx={{color: color === "red" ? "error.main" : "inherit"}}>
+                                {icon}
+                            </ListItemIcon>
                             <ListItemText>
                                 {name
                                     .split(" ")
diff --git a/src/components/NodesTable.jsx b/src/components/NodesTable.jsx
index dade189f..35143dbf 100644
--- a/src/components/NodesTable.jsx
+++ b/src/components/NodesTable.jsx
@@ -425,9 +425,12 @@ const NodesTable = () => {
                             vertical: "top",
                             horizontal: "right",
                         }}
-                        sx={menuSx}
+                        sx={{
+                            ...menuSx,
+                            zIndex: 10000,
+                        }}
                     >
-                        {filteredMenuItems.map(({name, icon}) => (
+                        {filteredMenuItems.map(({name, icon, color}) => (
                             <MenuItem
                                 key={name}
                                 onClick={() => handleAction(name)}
@@ -435,9 +438,12 @@ const NodesTable = () => {
                                     display: "flex",
                                     alignItems: "center",
                                     gap: 1,
+                                    color: color === "red" ? "error.main" : "inherit",
                                 }}
                             >
-                                <ListItemIcon>{icon}</ListItemIcon>
+                                <ListItemIcon sx={{color: color === "red" ? "error.main" : "inherit"}}>
+                                    {icon}
+                                </ListItemIcon>
                                 <ListItemText>
                                     {name
                                         .split(" ")
diff --git a/src/components/ObjectDetails.jsx b/src/components/ObjectDetails.jsx
index 31db47ef..cb037e2e 100644
--- a/src/components/ObjectDetails.jsx
+++ b/src/components/ObjectDetails.jsx
@@ -73,10 +73,9 @@ const ObjectDetail = () => {
     const instanceConfig = useEventStore((s) => s.instanceConfig[decodedObjectName]);
     const clearConfigUpdate = useEventStore((s) => s.clearConfigUpdate);
 
-    const [configLoading, setConfigLoading] = useState(false);
-    const [configError, setConfigError] = useState(null);
     const [configNode, setConfigNode] = useState(null);
     const [configDialogOpen, setConfigDialogOpen] = useState(false);
+    const [configRefreshTrigger, setConfigRefreshTrigger] = useState(0);
 
     const [selectedNodes, setSelectedNodes] = useState([]);
     const [actionsMenuAnchor, setActionsMenuAnchor] = useState(null);
@@ -120,6 +119,7 @@ const ObjectDetail = () => {
         "ObjectDeleted",
         "InstanceMonitorUpdated",
         "InstanceConfigUpdated",
+        "InstanceConfigDeleted",
         "CONNECTION_OPENED",
         "CONNECTION_ERROR",
         "RECONNECTION_ATTEMPT",
@@ -127,9 +127,10 @@ const ObjectDetail = () => {
         "CONNECTION_CLOSED"
     ], []);
 
-    const lastFetch = useRef({});
-    const isProcessingConfigUpdate = useRef(false);
     const isMounted = useRef(true);
+    const fallbackTimer = useRef(null);
+    const hasFallbackFired = useRef(false);
+    const [fallbackCompleted, setFallbackCompleted] = useState(false);
 
     const objectData = useMemo(() => {
         const avail = objectStatus?.avail || "n/a";
@@ -148,6 +149,11 @@ const ObjectDetail = () => {
         return {avail, frozen, globalExpect};
     }, [objectStatus, objectInstanceStatus, instanceMonitor, decodedObjectName]);
 
+    const nodesList = useMemo(() => {
+        if (!objectInstanceStatus) return [];
+        return Object.keys(objectInstanceStatus).sort();
+    }, [objectInstanceStatus]);
+
     const memoizedObjectData = useMemo(() => {
         if (!objectInstanceStatus) return {};
         const enhanced = {};
@@ -161,63 +167,126 @@ const ObjectDetail = () => {
         return enhanced;
     }, [objectInstanceStatus, instanceConfig, instanceMonitor, decodedObjectName]);
 
-    const nodesList = useMemo(() => Object.keys(memoizedObjectData), [memoizedObjectData]);
+    const fetchFallbackData = useCallback(async () => {
+        if (hasFallbackFired.current) return;
+        hasFallbackFired.current = true;
 
-    const fetchInitialObjectData = useCallback(async () => {
-        setInitialDataError(null);
         const token = localStorage.getItem("authToken");
         if (!token) {
             setInitialDataError("Auth token not found");
+            setInitialLoading(false);
+            setFallbackCompleted(true);
             return;
         }
+
+        const {namespace, kind, name: objName} = parseObjectPath(decodedObjectName);
+        const encodedNamespace = encodeURIComponent(namespace);
+        const encodedKind = encodeURIComponent(kind);
+        const encodedName = encodeURIComponent(objName);
+
         try {
-            const {namespace, kind, name: objName} = parseObjectPath(decodedObjectName);
-            const objRes = await fetch(`${URL_OBJECT}/${namespace}/${kind}/${objName}`, {
-                headers: {Authorization: `Bearer ${token}`},
-                cache: "no-cache",
-            });
+            const objRes = await fetch(
+                `${URL_OBJECT}/${encodedNamespace}/${encodedKind}/${encodedName}`,
+                {headers: {Authorization: `Bearer ${token}`}, cache: "no-cache"}
+            );
             let objectData = null;
             if (objRes.ok) objectData = await objRes.json();
 
-            const instRes = await fetch(`${URL_NODE}/all/instance/path/${namespace}/${kind}/${objName}`, {
-                headers: {Authorization: `Bearer ${token}`},
-                cache: "no-cache",
-            });
+            const instRes = await fetch(
+                `${URL_NODE}/all/instance/path/${encodedNamespace}/${encodedKind}/${encodedName}`,
+                {headers: {Authorization: `Bearer ${token}`}, cache: "no-cache"}
+            );
             let instancesData = {};
             if (instRes.ok) instancesData = await instRes.json();
 
-            const store = useEventStore.getState();
-            if (objectData) store.setObjectStatuses({[decodedObjectName]: objectData});
-            if (Object.keys(instancesData).length > 0) store.setInstanceStatuses({[decodedObjectName]: instancesData});
+            const currentState = useEventStore.getState();
+            const hasInstances = currentState.objectInstanceStatus[decodedObjectName] &&
+                Object.keys(currentState.objectInstanceStatus[decodedObjectName]).length > 0;
+
+            if (!hasInstances) {
+                if (objectData) currentState.setObjectStatuses({[decodedObjectName]: objectData});
+                if (instancesData) {
+                    currentState.setInstanceStatuses({[decodedObjectName]: instancesData}, true);
+                } else {
+                    currentState.setInstanceStatuses({[decodedObjectName]: {}}, true);
+                }
+            }
         } catch (err) {
-            logger.error("Failed to fetch initial object data:", err);
+            logger.error("Fallback fetch failed:", err);
             setInitialDataError(err.message);
+        } finally {
+            setInitialLoading(false);
+            setFallbackCompleted(true);
         }
     }, [decodedObjectName]);
 
     useEffect(() => {
+        useEventStore.getState().removeObject(decodedObjectName);
+        setInitialLoading(true);
+        setInitialDataError(null);
+        setFallbackCompleted(false);
+        hasFallbackFired.current = false;
+        setConfigNode(null);
+
         const token = localStorage.getItem("authToken");
         if (token) {
-            const filters = objectEventTypes.map(type => {
-                if (["CONNECTION_OPENED", "CONNECTION_ERROR", "RECONNECTION_ATTEMPT", "MAX_RECONNECTIONS_REACHED", "CONNECTION_CLOSED"].includes(type)) {
-                    return type;
-                } else {
-                    return `${type},path=${decodedObjectName}`;
-                }
-            });
-            startEventReception(token, filters);
+            startEventReception(token, objectEventTypes, decodedObjectName);
         }
-        return () => closeEventSource();
-    }, [decodedObjectName, objectEventTypes]);
+
+        fallbackTimer.current = setTimeout(() => {
+            fetchFallbackData();
+        }, 5000);
+
+        return () => {
+            clearTimeout(fallbackTimer.current);
+            closeEventSource();
+        };
+    }, [decodedObjectName, objectEventTypes, fetchFallbackData]);
 
     useEffect(() => {
-        const hasData = objectInstanceStatus && Object.keys(objectInstanceStatus).length > 0;
-        if (!hasData) {
-            fetchInitialObjectData().finally(() => setInitialLoading(false));
-        } else {
+        if (initialLoading && (objectInstanceStatus !== undefined || fallbackCompleted)) {
             setInitialLoading(false);
+            if (fallbackTimer.current) {
+                clearTimeout(fallbackTimer.current);
+                fallbackTimer.current = null;
+            }
+            hasFallbackFired.current = true;
         }
-    }, [objectInstanceStatus, fetchInitialObjectData]);
+    }, [initialLoading, objectInstanceStatus, fallbackCompleted]);
+
+    useEffect(() => {
+        if (configNode || !objectInstanceStatus) return;
+        const nodes = Object.keys(objectInstanceStatus);
+        if (nodes.length === 0) return;
+        const best = nodes.find((node) => {
+            const nodeData = objectInstanceStatus[node];
+            return nodeData?.encap && Object.values(nodeData.encap).some(
+                (container) => container.resources && Object.keys(container.resources).length > 0
+            );
+        }) || nodes[0];
+        setConfigNode(best);
+    }, [objectInstanceStatus, configNode]);
+
+    useEffect(() => {
+        if (!configNode || !objectInstanceStatus) return;
+        const currentNodes = Object.keys(objectInstanceStatus);
+        if (currentNodes.length === 0) {
+            setConfigNode(null);
+            setConfigDialogOpen(false);
+            return;
+        }
+        if (!currentNodes.includes(configNode)) {
+            logger.debug(`[ObjectDetail] configNode "${configNode}" removed, switching to "${currentNodes[0]}"`);
+            setConfigNode(currentNodes[0]);
+        }
+    }, [objectInstanceStatus, configNode]);
+
+    const prevInstanceConfigRef = useRef(instanceConfig);
+    useEffect(() => {
+        if (instanceConfig === prevInstanceConfigRef.current) return;
+        prevInstanceConfigRef.current = instanceConfig;
+        setConfigRefreshTrigger((n) => n + 1);
+    }, [instanceConfig]);
 
     const openSnackbar = useCallback((msg, sev = "success") => {
         setSnackbar({open: true, message: msg, severity: sev});
@@ -226,7 +295,7 @@ const ObjectDetail = () => {
 
     const postActionUrl = useCallback(({node, objectName, action}) => {
         const {namespace, kind, name} = parseObjectPath(objectName);
-        return `${URL_NODE}/${node}/instance/path/${namespace}/${kind}/${name}/action/${action}`;
+        return `${URL_NODE}/${encodeURIComponent(node)}/instance/path/${encodeURIComponent(namespace)}/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/action/${encodeURIComponent(action)}`;
     }, []);
 
     const postConsoleAction = useCallback(async ({node, rid, seats = 1, greet_timeout = "5s"}) => {
@@ -238,7 +307,7 @@ const ObjectDetail = () => {
         setActionInProgress(true);
         openSnackbar(`Opening console for resource ${rid}...`, "info");
         const {namespace, kind, name} = parseObjectPath(decodedObjectName);
-        const url = `${URL_NODE}/${node}/instance/path/${namespace}/${kind}/${name}/console?rid=${encodeURIComponent(rid)}&seats=${seats}&greet_timeout=${encodeURIComponent(greet_timeout)}`;
+        const url = `${URL_NODE}/${encodeURIComponent(node)}/instance/path/${encodeURIComponent(namespace)}/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/console?rid=${encodeURIComponent(rid)}&seats=${seats}&greet_timeout=${encodeURIComponent(greet_timeout)}`;
         try {
             const response = await fetch(url, {
                 method: "POST",
@@ -269,7 +338,7 @@ const ObjectDetail = () => {
         if (!token) return openSnackbar("Auth token not found.", "error");
         setActionInProgress(true);
         openSnackbar(`Executing ${action} on object…`, "info");
-        const url = `${URL_OBJECT}/${namespace}/${kind}/${name}/action/${action}`;
+        const url = `${URL_OBJECT}/${encodeURIComponent(namespace)}/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/action/${encodeURIComponent(action)}`;
         try {
             const res = await fetch(url, {method: "POST", headers: {Authorization: `Bearer ${token}`}});
             if (!res.ok) {
@@ -306,45 +375,6 @@ const ObjectDetail = () => {
         }
     }, [decodedObjectName, openSnackbar, postActionUrl]);
 
-    const fetchConfig = useCallback(async (node) => {
-        if (!node || !decodedObjectName) {
-            setConfigError("No node or object available to fetch configuration.");
-            return;
-        }
-        const key = `${decodedObjectName}:${node}`;
-        const now = Date.now();
-        if (lastFetch.current[key] && now - lastFetch.current[key] < 1000) return;
-        lastFetch.current[key] = now;
-        if (configLoading) return;
-
-        const {namespace, kind, name} = parseObjectPath(decodedObjectName);
-        const token = localStorage.getItem("authToken");
-        if (!token) {
-            setConfigError("Auth token not found.");
-            return;
-        }
-        setConfigLoading(true);
-        setConfigError(null);
-        setConfigNode(node);
-        const url = `${URL_NODE}/${node}/instance/path/${namespace}/${kind}/${name}/config/file`;
-        try {
-            const fetchResponse = await Promise.race([
-                fetch(url, {headers: {Authorization: `Bearer ${token}`}, cache: "no-cache"}),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("Fetch config timeout")), 10000)),
-            ]);
-            if (!fetchResponse.ok) {
-                setConfigError(`Failed to fetch config: HTTP error! status: ${fetchResponse.status}`);
-                return;
-            }
-            const text = await fetchResponse.text();
-            if (isMounted.current) return text;
-        } catch (err) {
-            if (isMounted.current) setConfigError(err.message);
-        } finally {
-            if (isMounted.current) setConfigLoading(false);
-        }
-    }, [decodedObjectName, configLoading]);
-
     const openActionDialog = useCallback((action, context = null) => {
         setPendingAction({action, ...(context ? context : {})});
         setSeats(1);
@@ -493,64 +523,6 @@ const ObjectDetail = () => {
         document.body.style.cursor = "ew-resize";
     }, [drawerWidth, minDrawerWidth, maxDrawerWidth]);
 
-    useEffect(() => {
-        const loadInitialConfig = async () => {
-            if (objectInstanceStatus && Object.keys(objectInstanceStatus).length > 0) {
-                const nodes = Object.keys(objectInstanceStatus);
-                const initialNode = nodes.find((node) => {
-                    const nodeData = objectInstanceStatus[node];
-                    return nodeData?.encap && Object.values(nodeData.encap).some(
-                        (container) => container.resources && Object.keys(container.resources).length > 0
-                    );
-                }) || nodes[0];
-                if (initialNode) {
-                    await fetchConfig(initialNode);
-                }
-            }
-        };
-        loadInitialConfig();
-    }, [objectInstanceStatus, fetchConfig]);
-
-    useEffect(() => {
-        let unsubscribe = null;
-        try {
-            const maybeUnsubscribe = useEventStore.subscribe(
-                (state) => state.configUpdates,
-                async (updates) => {
-                    if (!isMounted.current || isProcessingConfigUpdate.current) return;
-                    isProcessingConfigUpdate.current = true;
-                    try {
-                        const {name} = parseObjectPath(decodedObjectName);
-                        const matchingUpdate = updates.find(
-                            (u) => (u.name === name || u.fullName === decodedObjectName) && u.node
-                        );
-                        if (matchingUpdate && matchingUpdate.node) {
-                            await fetchConfig(matchingUpdate.node);
-                            setConfigDialogOpen(true);
-                            openSnackbar("Configuration updated", "info");
-                            clearConfigUpdate(decodedObjectName);
-                        }
-                    } catch (err) {
-                        openSnackbar("Failed to load updated configuration", "error");
-                    } finally {
-                        isProcessingConfigUpdate.current = false;
-                    }
-                },
-                {fireImmediately: false}
-            );
-            if (typeof maybeUnsubscribe === 'function') {
-                unsubscribe = maybeUnsubscribe;
-            } else {
-                logger.warn("[ObjectDetail] Subscription is not a function:", maybeUnsubscribe);
-            }
-        } catch (err) {
-            logger.warn("[ObjectDetail] Failed to subscribe to configUpdates:", err);
-        }
-        return () => {
-            if (typeof unsubscribe === 'function') unsubscribe();
-        };
-    }, [decodedObjectName, clearConfigUpdate, fetchConfig, openSnackbar]);
-
     useEffect(() => {
         let unsubscribe = null;
         try {
@@ -559,7 +531,6 @@ const ObjectDetail = () => {
                 (newConfig) => {
                     const config = newConfig[decodedObjectName];
                     if (config && configNode) {
-                        setConfigDialogOpen(true);
                         openSnackbar("Instance configuration updated", "info");
                     }
                 }
@@ -603,8 +574,8 @@ const ObjectDetail = () => {
                     openSnackbar={openSnackbar}
                     configDialogOpen={configDialogOpen}
                     setConfigDialogOpen={setConfigDialogOpen}
+                    configRefreshTrigger={configRefreshTrigger}
                 />
-                {configError && <Alert severity="error" sx={{mt: 2}}>{configError}</Alert>}
             </Box>
         );
     }
@@ -664,6 +635,7 @@ const ObjectDetail = () => {
                                 openSnackbar={openSnackbar}
                                 configDialogOpen={configDialogOpen}
                                 setConfigDialogOpen={setConfigDialogOpen}
+                                configRefreshTrigger={configRefreshTrigger}
                             />
                         </Grid>
                     </Grid>
@@ -732,17 +704,11 @@ const ObjectDetail = () => {
                         <DialogTitle>Console URL</DialogTitle>
                         <DialogContent>
                             <Box sx={{
-                                border: '1px solid #ccc',
-                                borderRadius: '4px',
-                                padding: {xs: '8px 10px', sm: '12px 14px'},
-                                backgroundColor: '#f5f5f5',
-                                marginBottom: 2,
-                                overflow: 'auto',
-                                maxHeight: '100px',
-                                fontFamily: 'monospace',
-                                fontSize: {xs: '0.75rem', sm: '0.875rem'},
-                                wordBreak: 'break-all',
-                                whiteSpace: 'pre-wrap'
+                                border: '1px solid #ccc', borderRadius: '4px',
+                                padding: {xs: '8px 10px', sm: '12px 14px'}, backgroundColor: '#f5f5f5',
+                                marginBottom: 2, overflow: 'auto', maxHeight: '100px',
+                                fontFamily: 'monospace', fontSize: {xs: '0.75rem', sm: '0.875rem'},
+                                wordBreak: 'break-all', whiteSpace: 'pre-wrap'
                             }}>
                                 {currentConsoleUrl ? String(currentConsoleUrl) : 'No URL available'}
                             </Box>
@@ -755,11 +721,13 @@ const ObjectDetail = () => {
                                 <Button variant="outlined" size={window.innerWidth < 600 ? "small" : "medium"}
                                         onClick={() => {
                                             if (currentConsoleUrl) navigator.clipboard.writeText(String(currentConsoleUrl));
-                                        }} disabled={!currentConsoleUrl}>Copy URL</Button>
+                                        }}
+                                        disabled={!currentConsoleUrl}>Copy URL</Button>
                                 <Button variant="contained" size={window.innerWidth < 600 ? "small" : "medium"}
                                         onClick={() => {
                                             if (currentConsoleUrl) window.open(String(currentConsoleUrl), '_blank', 'noopener,noreferrer');
-                                        }} disabled={!currentConsoleUrl}>Open in New Tab</Button>
+                                        }}
+                                        disabled={!currentConsoleUrl}>Open in New Tab</Button>
                             </Box>
                         </DialogContent>
                         <DialogActions>
@@ -772,22 +740,15 @@ const ObjectDetail = () => {
                     {!["sec", "cfg", "usr"].includes(kind) && (
                         <>
                             <Box sx={{display: "flex", alignItems: "center", gap: 1, mb: 2}}>
-                                <Button
-                                    variant="outlined"
-                                    onClick={(e) => setActionsMenuAnchor(e.currentTarget)}
-                                    disabled={selectedNodes.length === 0}
-                                >
+                                <Button variant="outlined" onClick={(e) => setActionsMenuAnchor(e.currentTarget)}
+                                        disabled={selectedNodes.length === 0}>
                                     Actions on Selected Nodes ({selectedNodes.length})
                                 </Button>
                             </Box>
-
-                            <Menu
-                                anchorEl={actionsMenuAnchor}
-                                open={Boolean(actionsMenuAnchor)}
-                                onClose={() => setActionsMenuAnchor(null)}
-                                anchorOrigin={{vertical: 'bottom', horizontal: 'right'}}
-                                transformOrigin={{vertical: 'top', horizontal: 'right'}}
-                            >
+                            <Menu anchorEl={actionsMenuAnchor} open={Boolean(actionsMenuAnchor)}
+                                  onClose={() => setActionsMenuAnchor(null)}
+                                  anchorOrigin={{vertical: 'bottom', horizontal: 'right'}}
+                                  transformOrigin={{vertical: 'top', horizontal: 'right'}} sx={{zIndex: 10000}}>
                                 {INSTANCE_ACTIONS.map(({name, icon}) => (
                                     <MenuItem key={name} onClick={() => handleBatchNodeActionClick(name)}>
                                         <ListItemIcon>{icon}</ListItemIcon>
@@ -795,7 +756,6 @@ const ObjectDetail = () => {
                                     </MenuItem>
                                 ))}
                             </Menu>
-
                             {nodesList.map(node => (
                                 <InstanceCard
                                     key={node}
@@ -819,14 +779,10 @@ const ObjectDetail = () => {
                                     onViewInstance={handleViewInstance}
                                 />
                             ))}
-
-                            <Menu
-                                anchorEl={individualNodeMenuAnchor}
-                                open={Boolean(individualNodeMenuAnchor)}
-                                onClose={() => setIndividualNodeMenuAnchor(null)}
-                                anchorOrigin={{vertical: 'bottom', horizontal: 'right'}}
-                                transformOrigin={{vertical: 'top', horizontal: 'right'}}
-                            >
+                            <Menu anchorEl={individualNodeMenuAnchor} open={Boolean(individualNodeMenuAnchor)}
+                                  onClose={() => setIndividualNodeMenuAnchor(null)}
+                                  anchorOrigin={{vertical: 'bottom', horizontal: 'right'}}
+                                  transformOrigin={{vertical: 'top', horizontal: 'right'}} sx={{zIndex: 10000}}>
                                 {INSTANCE_ACTIONS.map(({name, icon}) => (
                                     <MenuItem key={name} onClick={() => handleIndividualNodeActionClick(name)}>
                                         <ListItemIcon>{icon}</ListItemIcon>
@@ -837,8 +793,6 @@ const ObjectDetail = () => {
                         </>
                     )}
 
-                    {configError && <Alert severity="error" sx={{mt: 2}}>{configError}</Alert>}
-
                     <Snackbar open={snackbar.open} autoHideDuration={5000} onClose={closeSnackbar}
                               anchorOrigin={{vertical: "bottom", horizontal: "center"}}>
                         <Alert onClose={closeSnackbar} severity={snackbar.severity}
@@ -850,15 +804,9 @@ const ObjectDetail = () => {
             {logsDrawerOpen && selectedNodeForLogs && (
                 <Drawer anchor="right" open={logsDrawerOpen} variant="persistent" sx={{
                     "& .MuiDrawer-paper": {
-                        width: `${drawerWidth}px`,
-                        maxWidth: "80vw",
-                        p: 2,
-                        boxSizing: "border-box",
-                        backgroundColor: theme.palette.background.paper,
-                        top: 0,
-                        height: "100vh",
-                        overflow: "auto",
-                        borderLeft: `1px solid ${theme.palette.divider}`,
+                        width: `${drawerWidth}px`, maxWidth: "80vw", p: 2, boxSizing: "border-box",
+                        backgroundColor: theme.palette.background.paper, top: 0, height: "100vh",
+                        overflow: "auto", borderLeft: `1px solid ${theme.palette.divider}`,
                         transition: theme.transitions.create("width", {
                             easing: theme.transitions.easing.sharp,
                             duration: theme.transitions.duration.enteringScreen
@@ -866,19 +814,14 @@ const ObjectDetail = () => {
                     }
                 }}>
                     <Box sx={{
-                        position: "absolute",
-                        top: 0,
-                        left: 0,
-                        width: "6px",
-                        height: "100%",
-                        cursor: "ew-resize",
-                        bgcolor: theme.palette.grey[300],
-                        "&:hover": {bgcolor: theme.palette.primary.light},
-                        transition: "background-color 0.2s"
+                        position: "absolute", top: 0, left: 0, width: "6px", height: "100%",
+                        cursor: "ew-resize", bgcolor: theme.palette.grey[300],
+                        "&:hover": {bgcolor: theme.palette.primary.light}, transition: "background-color 0.2s"
                     }} onMouseDown={startResizing} onTouchStart={startResizing} aria-label="Resize drawer"/>
                     <Box sx={{display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2}}>
-                        <Typography
-                            variant="h6">{selectedInstanceForLogs ? `Instance Logs - ${selectedInstanceForLogs}` : `Node Logs - ${selectedNodeForLogs}`}</Typography>
+                        <Typography variant="h6">
+                            {selectedInstanceForLogs ? `Instance Logs - ${selectedInstanceForLogs}` : `Node Logs - ${selectedNodeForLogs}`}
+                        </Typography>
                         <IconButton onClick={handleCloseLogsDrawer}><CloseIcon/></IconButton>
                     </Box>
                     <LogsViewer nodename={selectedNodeForLogs} type={selectedInstanceForLogs ? "instance" : "node"}
diff --git a/src/components/ObjectInstanceView.jsx b/src/components/ObjectInstanceView.jsx
index ecd6a90b..63dd3f46 100644
--- a/src/components/ObjectInstanceView.jsx
+++ b/src/components/ObjectInstanceView.jsx
@@ -927,7 +927,7 @@ const ObjectInstanceView = () => {
                 open={Boolean(instanceMenuAnchor)}
                 anchorEl={instanceMenuAnchor}
                 placement="bottom-end"
-                sx={{zIndex: 1400}}
+                sx={{zIndex: 10000}}
             >
                 <ClickAwayListener onClickAway={() => setInstanceMenuAnchor(null)}>
                     <Paper sx={{minWidth: 200, boxShadow: 3}}>
@@ -951,7 +951,7 @@ const ObjectInstanceView = () => {
                 open={Boolean(resourceMenuAnchor)}
                 anchorEl={resourceMenuAnchor}
                 placement="bottom-end"
-                sx={{zIndex: 1300}}
+                sx={{zIndex: 10000}}
             >
                 <ClickAwayListener onClickAway={() => setResourceMenuAnchor(null)}>
                     <Paper sx={{minWidth: 200, boxShadow: 3}}>
diff --git a/src/components/Objects.jsx b/src/components/Objects.jsx
index fcf73b7e..d0501c20 100644
--- a/src/components/Objects.jsx
+++ b/src/components/Objects.jsx
@@ -935,10 +935,10 @@ const Objects = () => {
         if (!currentObject) return [];
         const objectData = objectStatus[currentObject];
         return OBJECT_ACTIONS.filter(
-            ({name}) =>
-                isActionAllowedForSelection(name, [currentObject]) &&
-                (name !== "freeze" || !objectData?.frozen || objectData.frozen !== "frozen") &&
-                (name !== "unfreeze" || objectData?.frozen === "frozen")
+            (action) =>
+                isActionAllowedForSelection(action.name, [currentObject]) &&
+                (action.name !== "freeze" || !objectData?.frozen || objectData.frozen !== "frozen") &&
+                (action.name !== "unfreeze" || objectData?.frozen === "frozen")
         );
     }, [currentObject, objectStatus]);
 
@@ -1185,6 +1185,7 @@ const Objects = () => {
                         </Box>
                     </Box>
 
+                    {/* Menu for row actions (per object) */}
                     <Menu
                         open={Boolean(rowMenuAnchor)}
                         anchorEl={rowMenuAnchor}
@@ -1199,26 +1200,37 @@ const Objects = () => {
                             horizontal: 'right',
                         }}
                         sx={{
+                            zIndex: 10000,
                             "& .MuiPaper-root": {
                                 minWidth: 200,
                                 boxShadow: "0px 5px 15px rgba(0,0,0,0.2)",
                             }
                         }}
                     >
-                        {filteredRowActions.map(({name, icon}) => (
-                            <MenuItem
-                                key={name}
-                                onClick={(e) => {
-                                    e.stopPropagation();
-                                    handleActionClick(name, true, currentObject);
-                                }}
-                                sx={{display: "flex", alignItems: "center", gap: 1}}
-                                aria-label={`${name} action for object ${currentObject}`}
-                            >
-                                <ListItemIcon>{icon}</ListItemIcon>
-                                {name.charAt(0).toUpperCase() + name.slice(1)}
-                            </MenuItem>
-                        ))}
+                        {filteredRowActions.map((action) => {
+                            const {name, icon, color} = action;
+                            return (
+                                <MenuItem
+                                    key={name}
+                                    onClick={(e) => {
+                                        e.stopPropagation();
+                                        handleActionClick(name, true, currentObject);
+                                    }}
+                                    sx={{
+                                        display: "flex",
+                                        alignItems: "center",
+                                        gap: 1,
+                                        color: color === "red" ? "error.main" : "inherit",
+                                    }}
+                                    aria-label={`${name} action for object ${currentObject}`}
+                                >
+                                    <ListItemIcon sx={{color: color === "red" ? "error.main" : "inherit"}}>
+                                        {icon}
+                                    </ListItemIcon>
+                                    {name.charAt(0).toUpperCase() + name.slice(1)}
+                                </MenuItem>
+                            );
+                        })}
                     </Menu>
 
                     {/* Menu for global actions */}
@@ -1235,13 +1247,15 @@ const Objects = () => {
                             horizontal: 'right',
                         }}
                         sx={{
+                            zIndex: 10000,
                             "& .MuiPaper-root": {
                                 minWidth: 200,
                                 boxShadow: "0px 5px 15px rgba(0,0,0,0.2)"
                             }
                         }}
                     >
-                        {OBJECT_ACTIONS.map(({name, icon}) => {
+                        {OBJECT_ACTIONS.map((action) => {
+                            const {name, icon, color} = action;
                             const isAllowed = isActionAllowedForSelection(name, selectedObjects);
                             return (
                                 <MenuItem
@@ -1249,12 +1263,18 @@ const Objects = () => {
                                     onClick={() => handleActionClick(name)}
                                     disabled={!isAllowed}
                                     sx={{
-                                        color: isAllowed ? "inherit" : "text.disabled",
+                                        color: isAllowed
+                                            ? (color === "red" ? "error.main" : "inherit")
+                                            : "text.disabled",
                                         "&.Mui-disabled": {opacity: 0.5}
                                     }}
                                     aria-label={`${name} action for selected objects`}
                                 >
-                                    <ListItemIcon sx={{color: isAllowed ? "inherit" : "text.disabled"}}>
+                                    <ListItemIcon sx={{
+                                        color: isAllowed
+                                            ? (color === "red" ? "error.main" : "inherit")
+                                            : "text.disabled"
+                                    }}>
                                         {icon}
                                     </ListItemIcon>
                                     <ListItemText>{name.charAt(0).toUpperCase() + name.slice(1)}</ListItemText>
diff --git a/src/components/StatCard.jsx b/src/components/StatCard.jsx
index 04521fd8..2bbec8cc 100644
--- a/src/components/StatCard.jsx
+++ b/src/components/StatCard.jsx
@@ -10,45 +10,55 @@ const StatCard = memo(({title, value, subtitle, onClick, dynamicHeight = false,
         <Paper
             elevation={3}
             sx={{
-                p: 3,
+                p: 2,
                 height: dynamicHeight ? 'auto' : '240px',
-                minHeight: '240px',
+                minHeight: dynamicHeight ? '240px' : undefined,
                 display: 'flex',
                 flexDirection: 'column',
                 cursor: onClick && !isLoading ? 'pointer' : 'default',
-                transition: 'box-shadow 0.3s, opacity 0.3s',
+                transition: 'box-shadow 0.3s',
                 '&:hover': onClick && !isLoading ? {boxShadow: 6} : {},
                 borderRadius: 2,
                 textAlign: 'center',
                 opacity: isLoading ? 0.7 : 1,
-                position: 'relative'
+                position: 'relative',
+                overflow: 'hidden'
             }}
             onClick={handleClick}
         >
             {isLoading && (
-                <Box sx={{
-                    position: 'absolute',
-                    top: 8,
-                    right: 8
-                }}>
+                <Box sx={{position: 'absolute', top: 8, right: 8}}>
                     <CircularProgress size={24}/>
                 </Box>
             )}
             <Typography variant="h6" gutterBottom>{title}</Typography>
-            <Box sx={{flex: 1, display: 'flex', flexDirection: 'column', justifyContent: 'center'}}>
-                {isLoading ? (
-                    <CircularProgress sx={{alignSelf: 'center'}}/>
-                ) : (
-                    <Typography variant="h3" color="primary">{value}</Typography>
-                )}
-            </Box>
+            <Typography variant="h3" color="primary" sx={{mb: 1}}>
+                {isLoading ? <CircularProgress/> : value}
+            </Typography>
             {subtitle && (
-                <Box onClick={(e) => e.stopPropagation()}>
-                    {typeof subtitle === 'string' ? (
-                        <Typography variant="body2">{subtitle}</Typography>
-                    ) : (
-                        subtitle
-                    )}
+                <Box
+                    sx={{
+                        flex: 1,
+                        minHeight: 0,
+                        display: 'flex',
+                        flexDirection: 'column',
+                        justifyContent: 'flex-end'
+                    }}
+                    onClick={(e) => e.stopPropagation()}
+                >
+                    <Box
+                        sx={{
+                            maxHeight: '100%',
+                            overflowY: 'auto',
+                            WebkitOverflowScrolling: 'touch'
+                        }}
+                    >
+                        {typeof subtitle === 'string' ? (
+                            <Typography variant="body2">{subtitle}</Typography>
+                        ) : (
+                            subtitle
+                        )}
+                    </Box>
                 </Box>
             )}
         </Paper>
diff --git a/src/components/tests/ActionDialogs.test.jsx b/src/components/tests/ActionDialogs.test.jsx
index da614321..af709a27 100644
--- a/src/components/tests/ActionDialogs.test.jsx
+++ b/src/components/tests/ActionDialogs.test.jsx
@@ -9,24 +9,30 @@ import {
 
 // Mock MUI components to simplify rendering and add accessibility labels
 jest.mock('@mui/material', () => ({
-    Dialog: ({open, children}) => (open ? <div>{children}</div> : null),
+    Dialog: ({open, children}) => (open ? <div data-testid="dialog">{children}</div> : null),
     DialogTitle: ({children}) => <h2>{children}</h2>,
     DialogContent: ({children}) => <div>{children}</div>,
     DialogActions: ({children}) => <div>{children}</div>,
-    Button: ({onClick, disabled, children, 'aria-label': ariaLabel}) =>
-        <button onClick={onClick} disabled={disabled} aria-label={ariaLabel}>{children}</button>,
+    Button: ({onClick, disabled, children, 'aria-label': ariaLabel, variant}) =>
+        <button onClick={onClick} disabled={disabled} aria-label={ariaLabel} data-variant={variant}>{children}</button>,
     Checkbox: ({checked, onChange, 'aria-label': ariaLabel}) =>
         <input type="checkbox" checked={checked} onChange={onChange} aria-label={ariaLabel}/>,
     FormControlLabel: ({control, label}) => <label>{control}{label}</label>,
     Typography: ({children}) => <span>{children}</span>,
-    TextField: ({value, onChange, 'aria-label': ariaLabel}) =>
-        <input aria-label={ariaLabel} value={value} onChange={onChange}/>,
+    TextField: ({value, onChange, 'aria-label': ariaLabel, multiline, placeholder, rows, sx}) => {
+        if (multiline) {
+            return <textarea aria-label={ariaLabel} value={value} onChange={onChange} placeholder={placeholder}
+                             rows={rows}/>;
+        }
+        return <input aria-label={ariaLabel} value={value} onChange={onChange} placeholder={placeholder}/>;
+    },
     Box: ({children}) => <div>{children}</div>,
 }));
 
 describe('ActionDialogs', () => {
     const onClose = jest.fn();
     const onConfirm = jest.fn();
+    const defaultSetState = jest.fn();
 
     afterEach(() => jest.clearAllMocks());
 
@@ -39,9 +45,10 @@ describe('ActionDialogs', () => {
                 <DialogComponent open onClose={onClose} onConfirm={onConfirm}
                                  checked={checked} setChecked={setChecked} disabled={false}/>
             );
-            // Confirm starts disabled
+
             const buttonName = confirmLabel === 'Confirm' ? /Confirm/i : new RegExp(`Confirm ${confirmLabel.toLowerCase()}`, 'i');
-            expect(screen.getByRole('button', {name: buttonName})).toBeDisabled();
+            const confirmBtn = screen.getByRole('button', {name: buttonName});
+            expect(confirmBtn).toBeDisabled();
 
             // Check the box
             fireEvent.click(screen.getByRole('checkbox'));
@@ -52,14 +59,34 @@ describe('ActionDialogs', () => {
                 <DialogComponent open onClose={onClose} onConfirm={onConfirm}
                                  checked={true} setChecked={setChecked} disabled={false}/>
             );
-            expect(screen.getByRole('button', {name: buttonName})).not.toBeDisabled();
+            expect(confirmBtn).not.toBeDisabled();
 
-            fireEvent.click(screen.getByRole('button', {name: buttonName}));
+            fireEvent.click(confirmBtn);
             expect(onConfirm).toHaveBeenCalled();
         });
+
+        test(`${dialogTitleText} calls onClose when cancel button is clicked`, () => {
+            render(
+                <DialogComponent open onClose={onClose} onConfirm={onConfirm}
+                                 checked={true} setChecked={defaultSetState} disabled={false}/>
+            );
+            const cancelBtn = screen.getByRole('button', {name: /Cancel/i});
+            fireEvent.click(cancelBtn);
+            expect(onClose).toHaveBeenCalled();
+        });
+
+        test(`${dialogTitleText} confirm button is disabled when disabled prop is true`, () => {
+            render(
+                <DialogComponent open onClose={onClose} onConfirm={onConfirm}
+                                 checked={true} setChecked={defaultSetState} disabled={true}/>
+            );
+            const buttonName = confirmLabel === 'Confirm' ? /Confirm/i : new RegExp(`Confirm ${confirmLabel.toLowerCase()}`, 'i');
+            const confirmBtn = screen.getByRole('button', {name: buttonName});
+            expect(confirmBtn).toBeDisabled();
+        });
     }
 
-    // Tests for simple checkbox dialogs (adjust confirm label accordingly)
+    // Tests for simple checkbox dialogs
     testCheckboxDialog(FreezeDialog, 'Confirm Freeze');
     testCheckboxDialog(StopDialog, 'Confirm Stop', 'Stop');
     testCheckboxDialog(RestartDialog, 'Confirm Restart', 'Restart');
@@ -68,216 +95,371 @@ describe('ActionDialogs', () => {
     testCheckboxDialog(SwitchDialog, 'Confirm Switch');
     testCheckboxDialog(GivebackDialog, 'Confirm Giveback');
 
-    test('UnprovisionDialog requires all checkboxes', async () => {
-        const cb = {dataLoss: false, clusterwide: false, serviceInterruption: false};
-        const setCb = jest.fn(newState => Object.assign(cb, newState));
-
-        const {rerender} = render(
-            <UnprovisionDialog open pendingAction={{}} onClose={onClose} onConfirm={onConfirm}
-                               checkboxes={cb} setCheckboxes={setCb} disabled={false}/>
-        );
-
-        const confirmBtn = screen.getByRole('button', {name: /Confirm unprovision action/i});
-        expect(confirmBtn).toBeDisabled();
-
-        // Simuler les clics et mettre à jour les props
-        fireEvent.click(screen.getByLabelText(/Confirm data loss/i));
-        fireEvent.click(screen.getByLabelText(/Confirm service interruption/i));
-        fireEvent.click(screen.getByLabelText(/Confirm clusterwide orchestration/i));
-
-        // Re-rendre avec les nouvelles valeurs
-        rerender(
-            <UnprovisionDialog open pendingAction={{}} onClose={onClose} onConfirm={onConfirm}
-                               checkboxes={{
-                                   dataLoss: true,
-                                   clusterwide: true,
-                                   serviceInterruption: true
-                               }}
-                               setCheckboxes={setCb}
-                               disabled={false}/>
-        );
-
-        expect(setCb).toHaveBeenCalledTimes(3);
-        expect(confirmBtn).not.toBeDisabled();
-
-        fireEvent.click(confirmBtn);
-        expect(onConfirm).toHaveBeenCalled();
+    // ----- UnprovisionDialog specific tests (including isNodeAction branch) -----
+    describe('UnprovisionDialog', () => {
+        const baseCheckboxes = {dataLoss: false, clusterwide: false, serviceInterruption: false};
+        const setCheckboxes = jest.fn();
+
+        afterEach(() => jest.clearAllMocks());
+
+        test('requires all three checkboxes when not a node action (clusterwide appears)', () => {
+            let checkboxes = {...baseCheckboxes};
+            const setCb = jest.fn(updater => {
+                checkboxes = updater(checkboxes);
+            });
+            const {rerender} = render(
+                <UnprovisionDialog open pendingAction={{}} onClose={onClose} onConfirm={onConfirm}
+                                   checkboxes={checkboxes} setCheckboxes={setCb} disabled={false}/>
+            );
+
+            const confirmBtn = screen.getByRole('button', {name: /Confirm unprovision action/i});
+            expect(confirmBtn).toBeDisabled();
+
+            // Check each checkbox individually
+            fireEvent.click(screen.getByLabelText(/I understand data will be lost/i));
+            fireEvent.click(screen.getByLabelText(/I understand the selected services may be temporarily interrupted/i));
+            fireEvent.click(screen.getByLabelText(/I understand this action will be orchestrated clusterwide/i));
+
+            // Simulate state updates
+            rerender(
+                <UnprovisionDialog open pendingAction={{}} onClose={onClose} onConfirm={onConfirm}
+                                   checkboxes={{dataLoss: true, clusterwide: true, serviceInterruption: true}}
+                                   setCheckboxes={setCb} disabled={false}/>
+            );
+            expect(confirmBtn).not.toBeDisabled();
+            fireEvent.click(confirmBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('requires only dataLoss and serviceInterruption when isNodeAction is true (no clusterwide checkbox)', () => {
+            let checkboxes = {dataLoss: false, clusterwide: false, serviceInterruption: false};
+            const setCb = jest.fn(updater => {
+                checkboxes = updater(checkboxes);
+            });
+            const pendingAction = {node: 'some-node'}; // makes isNodeAction true
+
+            const {rerender} = render(
+                <UnprovisionDialog open pendingAction={pendingAction} onClose={onClose} onConfirm={onConfirm}
+                                   checkboxes={checkboxes} setCheckboxes={setCb} disabled={false}/>
+            );
+
+            // Clusterwide checkbox should NOT be present
+            expect(screen.queryByLabelText(/I understand this action will be orchestrated clusterwide/i)).not.toBeInTheDocument();
+
+            const confirmBtn = screen.getByRole('button', {name: /Confirm unprovision action/i});
+            expect(confirmBtn).toBeDisabled();
+
+            // Check only dataLoss and serviceInterruption
+            fireEvent.click(screen.getByLabelText(/I understand data will be lost/i));
+            fireEvent.click(screen.getByLabelText(/I understand the selected services may be temporarily interrupted/i));
+
+            rerender(
+                <UnprovisionDialog open pendingAction={pendingAction} onClose={onClose} onConfirm={onConfirm}
+                                   checkboxes={{dataLoss: true, clusterwide: false, serviceInterruption: true}}
+                                   setCheckboxes={setCb} disabled={false}/>
+            );
+            expect(confirmBtn).not.toBeDisabled();
+            fireEvent.click(confirmBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('calls onClose when cancel is clicked', () => {
+            render(
+                <UnprovisionDialog open pendingAction={{}} onClose={onClose} onConfirm={onConfirm}
+                                   checkboxes={baseCheckboxes} setCheckboxes={setCheckboxes} disabled={false}/>
+            );
+            fireEvent.click(screen.getByRole('button', {name: /Cancel/i}));
+            expect(onClose).toHaveBeenCalled();
+        });
+
+        test('confirm button disabled when disabled prop is true', () => {
+            render(
+                <UnprovisionDialog open pendingAction={{}} onClose={onClose} onConfirm={onConfirm}
+                                   checkboxes={{dataLoss: true, clusterwide: true, serviceInterruption: true}}
+                                   setCheckboxes={setCheckboxes} disabled={true}/>
+            );
+            const confirmBtn = screen.getByRole('button', {name: /Confirm unprovision action/i});
+            expect(confirmBtn).toBeDisabled();
+        });
     });
 
-    test('PurgeDialog requires 3 checkboxes', async () => {
-        const cb = {dataLoss: false, configLoss: false, serviceInterruption: false};
-        const setCb = jest.fn(newState => Object.assign(cb, newState));
-
-        const {rerender} = render(
-            <PurgeDialog open onClose={onClose} onConfirm={onConfirm}
-                         checkboxes={cb} setCheckboxes={setCb} disabled={false}/>
-        );
-
-        const confirmBtn = screen.getByRole('button', {name: /Confirm purge action/i});
-        expect(confirmBtn).toBeDisabled();
-
-        // Simuler les clics et mettre à jour les props
-        fireEvent.click(screen.getByLabelText(/Confirm data loss/i));
-        fireEvent.click(screen.getByLabelText(/Confirm configuration loss/i));
-        fireEvent.click(screen.getByLabelText(/Confirm service interruption/i));
-
-        // Re-rendre avec les nouvelles valeurs
-        rerender(
-            <PurgeDialog open onClose={onClose} onConfirm={onConfirm}
-                         checkboxes={{
-                             dataLoss: true,
-                             configLoss: true,
-                             serviceInterruption: true
-                         }}
-                         setCheckboxes={setCb}
-                         disabled={false}/>
-        );
-
-        expect(setCb).toHaveBeenCalledTimes(3);
-        expect(confirmBtn).not.toBeDisabled();
-
-        fireEvent.click(confirmBtn);
-        expect(onConfirm).toHaveBeenCalled();
+    // ----- PurgeDialog -----
+    describe('PurgeDialog', () => {
+        const baseCheckboxes = {dataLoss: false, configLoss: false, serviceInterruption: false};
+        const setCheckboxes = jest.fn();
+
+        test('requires all three checkboxes', () => {
+            let checkboxes = {...baseCheckboxes};
+            const setCb = jest.fn(updater => {
+                checkboxes = updater(checkboxes);
+            });
+            const {rerender} = render(
+                <PurgeDialog open onClose={onClose} onConfirm={onConfirm}
+                             checkboxes={checkboxes} setCheckboxes={setCb} disabled={false}/>
+            );
+            const confirmBtn = screen.getByRole('button', {name: /Confirm purge action/i});
+            expect(confirmBtn).toBeDisabled();
+
+            fireEvent.click(screen.getByLabelText(/I understand data will be lost/i));
+            fireEvent.click(screen.getByLabelText(/I understand the configuration will be lost/i));
+            fireEvent.click(screen.getByLabelText(/I understand the selected services may be temporarily interrupted/i));
+
+            rerender(
+                <PurgeDialog open onClose={onClose} onConfirm={onConfirm}
+                             checkboxes={{dataLoss: true, configLoss: true, serviceInterruption: true}}
+                             setCheckboxes={setCb} disabled={false}/>
+            );
+            expect(confirmBtn).not.toBeDisabled();
+            fireEvent.click(confirmBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('calls onClose on cancel', () => {
+            render(
+                <PurgeDialog open onClose={onClose} onConfirm={onConfirm}
+                             checkboxes={baseCheckboxes} setCheckboxes={setCheckboxes} disabled={false}/>
+            );
+            fireEvent.click(screen.getByRole('button', {name: /Cancel/i}));
+            expect(onClose).toHaveBeenCalled();
+        });
     });
 
-    test('DeleteDialog requires both checkboxes', async () => {
-        const cb = {configLoss: false, clusterwide: false};
-        const setCb = jest.fn(newState => Object.assign(cb, newState));
-
-        const {rerender} = render(
-            <DeleteDialog open onClose={onClose} onConfirm={onConfirm}
-                          checkboxes={cb} setCheckboxes={setCb} disabled={false}/>
-        );
-
-        const confirmBtn = screen.getByRole('button', {name: /Confirm delete action/i});
-        expect(confirmBtn).toBeDisabled();
-
-        // Simuler les clics et mettre à jour les props
-        fireEvent.click(screen.getByLabelText(/Confirm configuration loss/i));
-        fireEvent.click(screen.getByLabelText(/Confirm clusterwide orchestration/i));
-
-        // Re-rendre avec les nouvelles valeurs
-        rerender(
-            <DeleteDialog open onClose={onClose} onConfirm={onConfirm}
-                          checkboxes={{
-                              configLoss: true,
-                              clusterwide: true
-                          }}
-                          setCheckboxes={setCb}
-                          disabled={false}/>
-        );
-
-        expect(setCb).toHaveBeenCalledTimes(2);
-        expect(confirmBtn).not.toBeDisabled();
-
-        fireEvent.click(confirmBtn);
-        expect(onConfirm).toHaveBeenCalled();
+    // ----- DeleteDialog -----
+    describe('DeleteDialog', () => {
+        const baseCheckboxes = {configLoss: false, clusterwide: false};
+        const setCheckboxes = jest.fn();
+
+        test('requires both checkboxes', () => {
+            let checkboxes = {...baseCheckboxes};
+            const setCb = jest.fn(updater => {
+                checkboxes = updater(checkboxes);
+            });
+            const {rerender} = render(
+                <DeleteDialog open onClose={onClose} onConfirm={onConfirm}
+                              checkboxes={checkboxes} setCheckboxes={setCb} disabled={false}/>
+            );
+            const confirmBtn = screen.getByRole('button', {name: /Confirm delete action/i});
+            expect(confirmBtn).toBeDisabled();
+
+            fireEvent.click(screen.getByLabelText(/I understand the configuration will be lost/i));
+            fireEvent.click(screen.getByLabelText(/I understand this action will be orchestrated clusterwide/i));
+
+            rerender(
+                <DeleteDialog open onClose={onClose} onConfirm={onConfirm}
+                              checkboxes={{configLoss: true, clusterwide: true}}
+                              setCheckboxes={setCb} disabled={false}/>
+            );
+            expect(confirmBtn).not.toBeDisabled();
+            fireEvent.click(confirmBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('calls onClose on cancel', () => {
+            render(
+                <DeleteDialog open onClose={onClose} onConfirm={onConfirm}
+                              checkboxes={baseCheckboxes} setCheckboxes={setCheckboxes} disabled={false}/>
+            );
+            fireEvent.click(screen.getByRole('button', {name: /Cancel/i}));
+            expect(onClose).toHaveBeenCalled();
+        });
     });
 
-    test('DeleteKeyDialog shows key and enables delete', () => {
-        render(<DeleteKeyDialog open onClose={onClose} onConfirm={onConfirm}
-                                keyToDelete="SECRET_KEY" disabled={false}/>);
-        expect(screen.getByText(/SECRET_KEY/)).toBeInTheDocument();
+    // ----- DeleteKeyDialog -----
+    describe('DeleteKeyDialog', () => {
+        test('shows key and calls onConfirm on delete, onClose on cancel', () => {
+            render(<DeleteKeyDialog open onClose={onClose} onConfirm={onConfirm}
+                                    keyToDelete="MY_SECRET_KEY" disabled={false}/>);
+            expect(screen.getByText(/MY_SECRET_KEY/)).toBeInTheDocument();
+
+            const deleteBtn = screen.getByRole('button', {name: /Delete/i});
+            fireEvent.click(deleteBtn);
+            expect(onConfirm).toHaveBeenCalled();
 
-        const deleteBtn = screen.getByRole('button', {name: /Delete/i});
-        fireEvent.click(deleteBtn);
-        expect(onConfirm).toHaveBeenCalled();
+            const cancelBtn = screen.getByRole('button', {name: /Cancel/i});
+            fireEvent.click(cancelBtn);
+            expect(onClose).toHaveBeenCalled();
+        });
+
+        test('delete button is disabled when disabled prop is true', () => {
+            render(<DeleteKeyDialog open onClose={onClose} onConfirm={onConfirm}
+                                    keyToDelete="KEY" disabled={true}/>);
+            expect(screen.getByRole('button', {name: /Delete/i})).toBeDisabled();
+        });
     });
 
-    test('CreateKeyDialog requires name and file', () => {
-        let name = '', file = null;
-        const setName = jest.fn(v => name = v);
-        const setFile = jest.fn(v => file = v);
-
-        const {rerender} = render(
-            <CreateKeyDialog open onClose={onClose} onConfirm={onConfirm}
-                             newKeyName={name} setNewKeyName={setName}
-                             newKeyFile={file} setNewKeyFile={setFile}
-                             disabled={false}/>
-        );
-
-        const inputName = screen.getByRole('textbox', {name: /Key Name/i});
-        expect(inputName).toBeInTheDocument();
-        expect(screen.getByRole('button', {name: /Create/i})).toBeDisabled();
-
-        fireEvent.change(inputName, {target: {value: 'KEY'}});
-        expect(setName).toHaveBeenCalledWith('KEY');
-
-        // File input simulation is limited, just check button exists
-        fireEvent.click(screen.getByRole('button', {name: /Create/i}));
-        expect(onConfirm).not.toHaveBeenCalled();
-
-        // Simulate both name and file set to enable confirm
-        rerender(
-            <CreateKeyDialog open onClose={onClose} onConfirm={onConfirm}
-                             newKeyName="KEY" setNewKeyName={setName}
-                             newKeyFile={{name: 'file.key'}} setNewKeyFile={setFile}
-                             disabled={false}/>
-        );
-
-        const createBtn = screen.getByRole('button', {name: /Create/i});
-        expect(createBtn).not.toBeDisabled();
-
-        fireEvent.click(createBtn);
-        expect(onConfirm).toHaveBeenCalled();
+    // ----- CreateKeyDialog -----
+    describe('CreateKeyDialog', () => {
+        const defaultProps = {
+            open: true,
+            onClose,
+            onConfirm,
+            newKeyName: '',
+            setNewKeyName: jest.fn(),
+            newKeyFile: null,
+            setNewKeyFile: jest.fn(),
+            disabled: false,
+        };
+
+        test('requires key name and file to enable Create button', () => {
+            let props = {...defaultProps};
+            const {rerender} = render(<CreateKeyDialog {...props} />);
+            const nameInput = screen.getByRole('textbox', {name: /Key Name/i});
+            const createBtn = screen.getByRole('button', {name: /Create/i});
+            expect(createBtn).toBeDisabled();
+
+            // Fill name only
+            fireEvent.change(nameInput, {target: {value: 'mykey'}});
+            expect(props.setNewKeyName).toHaveBeenCalledWith('mykey');
+            // Create still disabled without file
+            rerender(<CreateKeyDialog {...props} newKeyName="mykey"/>);
+            expect(createBtn).toBeDisabled();
+
+            // Simulate file selection
+            const file = new File(['file content'], 'key.pem', {type: 'text/plain'});
+            const fileInput = document.getElementById('create-key-file-upload');
+            // Since input is hidden, we need to get it by id
+            fireEvent.change(fileInput, {target: {files: [file]}});
+            expect(props.setNewKeyFile).toHaveBeenCalledWith(file);
+
+            rerender(<CreateKeyDialog {...props} newKeyName="mykey" newKeyFile={file}/>);
+            expect(createBtn).not.toBeDisabled();
+
+            fireEvent.click(createBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('calls onClose when cancel is clicked', () => {
+            render(<CreateKeyDialog {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', {name: /Cancel/i}));
+            expect(onClose).toHaveBeenCalled();
+        });
+
+        test('Create button is disabled when disabled prop is true', () => {
+            render(<CreateKeyDialog {...defaultProps} disabled={true} newKeyName="key" newKeyFile={{}}/>);
+            expect(screen.getByRole('button', {name: /Create/i})).toBeDisabled();
+        });
     });
 
-    test('UpdateConfigDialog enables update only with file', () => {
-        let file = null;
-        const setFile = jest.fn(v => file = v);
-        const {rerender} = render(
-            <UpdateConfigDialog open onClose={onClose} onConfirm={onConfirm}
-                                newConfigFile={file} setNewConfigFile={setFile} disabled={false}/>
-        );
-        const updateBtn = screen.getByRole('button', {name: /Update/i});
-        expect(updateBtn).toBeDisabled();
-
-        rerender(
-            <UpdateConfigDialog open onClose={onClose} onConfirm={onConfirm}
-                                newConfigFile={{name: 'cfg.yml'}}
-                                setNewConfigFile={setFile} disabled={false}/>
-        );
-        expect(updateBtn).not.toBeDisabled();
-
-        fireEvent.click(updateBtn);
-        expect(onConfirm).toHaveBeenCalled();
+    // ----- UpdateConfigDialog -----
+    describe('UpdateConfigDialog', () => {
+        const defaultProps = {
+            open: true,
+            onClose,
+            onConfirm,
+            newConfigFile: null,
+            setNewConfigFile: jest.fn(),
+            disabled: false,
+        };
+
+        test('enables Update button only when a file is selected', () => {
+            let props = {...defaultProps};
+            const {rerender} = render(<UpdateConfigDialog {...props} />);
+            const updateBtn = screen.getByRole('button', {name: /Update/i});
+            expect(updateBtn).toBeDisabled();
+
+            // Simulate file selection
+            const file = new File(['config'], 'config.yaml', {type: 'text/yaml'});
+            const fileInput = document.getElementById('update-config-file-upload');
+            fireEvent.change(fileInput, {target: {files: [file]}});
+            expect(props.setNewConfigFile).toHaveBeenCalledWith(file);
+
+            rerender(<UpdateConfigDialog {...props} newConfigFile={file}/>);
+            expect(updateBtn).not.toBeDisabled();
+
+            fireEvent.click(updateBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('calls onClose on cancel', () => {
+            render(<UpdateConfigDialog {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', {name: /Cancel/i}));
+            expect(onClose).toHaveBeenCalled();
+        });
+
+        test('Update button disabled when disabled prop is true', () => {
+            render(<UpdateConfigDialog {...defaultProps} disabled={true} newConfigFile={{name: 'cfg'}}/>);
+            expect(screen.getByRole('button', {name: /Update/i})).toBeDisabled();
+        });
     });
 
-    test('ManageConfigParamsDialog enables apply when params present', () => {
-        let set1 = '', set2 = '', set3 = '';
-        const funcs = {
-            setParamsToSet: v => set1 = v,
-            setParamsToUnset: v => set2 = v,
-            setParamsToDelete: v => set3 = v,
+    // ----- ManageConfigParamsDialog -----
+    describe('ManageConfigParamsDialog', () => {
+        const defaultProps = {
+            open: true,
+            onClose,
+            onConfirm,
+            paramsToSet: '',
+            setParamsToSet: jest.fn(),
+            paramsToUnset: '',
+            setParamsToUnset: jest.fn(),
+            paramsToDelete: '',
+            setParamsToDelete: jest.fn(),
+            disabled: false,
         };
-        const {rerender} = render(
-            <ManageConfigParamsDialog open onClose={onClose} onConfirm={onConfirm}
-                                      paramsToSet={set1} setParamsToSet={funcs.setParamsToSet}
-                                      paramsToUnset={set2} setParamsToUnset={funcs.setParamsToUnset}
-                                      paramsToDelete={set3} setParamsToDelete={funcs.setParamsToDelete}
-                                      disabled={false}/>
-        );
-        const applyBtn = screen.getByRole('button', {name: /Apply/i});
-        expect(applyBtn).toBeDisabled();
-
-        rerender(
-            <ManageConfigParamsDialog open onClose={onClose} onConfirm={onConfirm}
-                                      paramsToSet="a=b" setParamsToSet={funcs.setParamsToSet}
-                                      paramsToUnset="" setParamsToUnset={funcs.setParamsToUnset}
-                                      paramsToDelete="" setParamsToDelete={funcs.setParamsToDelete}
-                                      disabled={false}/>
-        );
-        expect(applyBtn).not.toBeDisabled();
-
-        fireEvent.click(applyBtn);
-        expect(onConfirm).toHaveBeenCalled();
+
+        test('enables Apply button when any of the three fields has content', () => {
+            let props = {...defaultProps};
+            const {rerender} = render(<ManageConfigParamsDialog {...props} />);
+            const applyBtn = screen.getByRole('button', {name: /Apply/i});
+            expect(applyBtn).toBeDisabled();
+
+            // Only paramsToSet
+            rerender(<ManageConfigParamsDialog {...props} paramsToSet="a=b"/>);
+            expect(applyBtn).not.toBeDisabled();
+
+            // Reset
+            rerender(<ManageConfigParamsDialog {...props} paramsToSet="" paramsToUnset="section.key"/>);
+            expect(applyBtn).not.toBeDisabled();
+
+            rerender(<ManageConfigParamsDialog {...props} paramsToSet="" paramsToUnset="" paramsToDelete="section"/>);
+            expect(applyBtn).not.toBeDisabled();
+
+            fireEvent.click(applyBtn);
+            expect(onConfirm).toHaveBeenCalled();
+        });
+
+        test('calls onClose on cancel', () => {
+            render(<ManageConfigParamsDialog {...defaultProps} />);
+            fireEvent.click(screen.getByRole('button', {name: /Cancel/i}));
+            expect(onClose).toHaveBeenCalled();
+        });
+
+        test('Apply button disabled when disabled prop is true', () => {
+            render(<ManageConfigParamsDialog {...defaultProps} disabled={true} paramsToSet="a=b"/>);
+            expect(screen.getByRole('button', {name: /Apply/i})).toBeDisabled();
+        });
+
+        test('textarea fields handle multiline input', () => {
+            const setParamsToSet = jest.fn();
+            render(
+                <ManageConfigParamsDialog
+                    {...defaultProps}
+                    paramsToSet=""
+                    setParamsToSet={setParamsToSet}
+                />
+            );
+            const textarea = screen.getByRole('textbox', {name: /Parameters to set/i});
+            fireEvent.change(textarea, {target: {value: 'key1=val1\nkey2=val2'}});
+            expect(setParamsToSet).toHaveBeenCalledWith('key1=val1\nkey2=val2');
+        });
     });
 
-    test('SimpleConfirmDialog shows action and deletes', () => {
-        render(<SimpleConfirmDialog open onClose={onClose} onConfirm={onConfirm} action="foo" target="bar"/>);
-        expect(screen.getByText(/Confirm foo/i)).toBeInTheDocument();
-        const confirmBtn = screen.getByRole('button', {name: /Confirm/i});
-        fireEvent.click(confirmBtn);
-        expect(onConfirm).toHaveBeenCalled();
+    // ----- SimpleConfirmDialog -----
+    describe('SimpleConfirmDialog', () => {
+        test('renders action and target, calls onConfirm and onClose', () => {
+            render(<SimpleConfirmDialog open onClose={onClose} onConfirm={onConfirm} action="reboot" target="node-1"/>);
+
+            expect(screen.getByText(/Confirm reboot/i)).toBeInTheDocument();
+
+            expect(screen.getByText(/Are you sure you want to/i)).toBeInTheDocument();
+
+            const confirmBtn = screen.getByRole('button', {name: /Confirm reboot action/i});
+            fireEvent.click(confirmBtn);
+            expect(onConfirm).toHaveBeenCalled();
+
+            const cancelBtn = screen.getByRole('button', {name: /Cancel/i});
+            fireEvent.click(cancelBtn);
+            expect(onClose).toHaveBeenCalled();
+        });
     });
 });
diff --git a/src/components/tests/App.test.jsx b/src/components/tests/App.test.jsx
index 25c8cbcc..8a507f39 100644
--- a/src/components/tests/App.test.jsx
+++ b/src/components/tests/App.test.jsx
@@ -5,10 +5,14 @@ import App from '../App';
 import {DarkModeProvider} from '../../context/DarkModeContext';
 import {ThemeProvider, createTheme} from '@mui/material/styles';
 
-// Mock CSS imports
 jest.mock('../../styles/main.css', () => ({}));
-
-// Mock dependencies
+jest.mock('../../utils/logger.js', () => ({
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+}));
+const logger = require('../../utils/logger.js');
 jest.mock('../NavBar', () => () => <div data-testid="navbar">NavBar</div>);
 jest.mock('../Cluster', () => () => <div data-testid="cluster">ClusterOverview</div>);
 jest.mock('../NodesTable', () => () => <div data-testid="nodes">NodesTable</div>);
@@ -23,8 +27,6 @@ jest.mock('../WhoAmI', () => () => <div data-testid="whoami">WhoAmI</div>);
 jest.mock('../SilentRenew.jsx', () => () => <div data-testid="silent-renew">SilentRenew</div>);
 jest.mock('../AuthChoice.jsx', () => () => <div data-testid="auth-choice">AuthChoice</div>);
 jest.mock('../OidcCallback', () => () => <div data-testid="auth-callback">OidcCallback</div>);
-
-// Mock Login
 jest.mock('../Login', () => ({
     __esModule: true,
     default: () => <div data-testid="login">Login</div>,
@@ -32,14 +34,10 @@ jest.mock('../Login', () => ({
     refreshToken: jest.fn(),
 }));
 
-// Mock decodeToken
 const mockDecodeToken = jest.requireMock('../Login').decodeToken;
 
 jest.mock('../../hooks/AuthInfo.jsx', () => jest.fn(() => ({
-    openid: {
-        issuer: 'https://test-issuer.com',
-        client_id: 'test-client'
-    }
+    openid: {issuer: 'https://test-issuer.com', client_id: 'test-client'}
 })));
 
 jest.mock('../../config/oidcConfiguration.js', () => jest.fn(() => Promise.resolve({
@@ -50,13 +48,7 @@ jest.mock('../../config/oidcConfiguration.js', () => jest.fn(() => Promise.resol
 const oidcConfiguration = require('../../config/oidcConfiguration.js');
 
 const mockAuthDispatch = jest.fn();
-const mockAuthState = {
-    user: null,
-    isAuthenticated: false,
-    authChoice: null,
-    authInfo: null,
-    accessToken: null,
-};
+const mockAuthState = {user: null, isAuthenticated: false, authChoice: null, authInfo: null, accessToken: null};
 
 jest.mock('../../context/AuthProvider', () => ({
     AuthProvider: ({children}) => <div>{children}</div>,
@@ -71,1334 +63,595 @@ let mockUserManager = {
     getUser: jest.fn(() => Promise.resolve(null)),
     signinSilent: jest.fn(() => Promise.resolve(null)),
     events: {
-        addUserLoaded: jest.fn(),
-        addAccessTokenExpiring: jest.fn(),
-        addAccessTokenExpired: jest.fn(),
-        addSilentRenewError: jest.fn(),
-        removeUserLoaded: jest.fn(),
-        removeAccessTokenExpired: jest.fn(),
+        addUserLoaded: jest.fn(), addAccessTokenExpiring: jest.fn(),
+        addAccessTokenExpired: jest.fn(), addSilentRenewError: jest.fn(),
+        removeUserLoaded: jest.fn(), removeAccessTokenExpired: jest.fn(),
         removeSilentRenewError: jest.fn(),
     }
 };
 let mockRecreateUserManager = jest.fn();
 let mockIsInitialized = true;
 
-jest.mock('../../context/OidcAuthContext.tsx', () => {
-    return {
-        OidcProvider: ({children}) => <div>{children}</div>,
-        useOidc: () => ({
-            userManager: mockUserManager,
-            recreateUserManager: mockRecreateUserManager,
-            isInitialized: mockIsInitialized,
-        }),
-        __setMockRecreateUserManager: (fn) => {
-            mockRecreateUserManager = fn;
-        },
-        __setMockIsInitialized: (v) => {
-            mockIsInitialized = v;
-        },
-    };
-});
+jest.mock('../../context/OidcAuthContext.tsx', () => ({
+    OidcProvider: ({children}) => <div>{children}</div>,
+    useOidc: () => ({
+        userManager: mockUserManager,
+        recreateUserManager: mockRecreateUserManager,
+        isInitialized: mockIsInitialized,
+    }),
+    __setMockRecreateUserManager: (fn) => {
+        mockRecreateUserManager = fn;
+    },
+    __setMockIsInitialized: (v) => {
+        mockIsInitialized = v;
+    },
+}));
 const mockOidcModule = require('../../context/OidcAuthContext.tsx');
 
-const mockLocalStorage = {
-    getItem: jest.fn(),
-    setItem: jest.fn(),
-    removeItem: jest.fn(),
-};
+const mockLocalStorage = {getItem: jest.fn(), setItem: jest.fn(), removeItem: jest.fn()};
 Object.defineProperty(window, 'localStorage', {value: mockLocalStorage});
 
-jest.spyOn(console, 'log').mockImplementation(() => {
-});
-jest.spyOn(console, 'error').mockImplementation(() => {
-});
-jest.spyOn(console, 'warn').mockImplementation(() => {
-});
-jest.spyOn(console, 'debug').mockImplementation(() => {
-});
-
-const makeTokenWithExp = (expSecondsFromNow) => {
-    const payload = {exp: Math.floor(Date.now() / 1000) + expSecondsFromNow};
-    return 'h.' + btoa(JSON.stringify(payload)) + '.s';
+const consoleSpy = {
+    log: jest.spyOn(console, 'log').mockImplementation(() => {
+    }),
+    error: jest.spyOn(console, 'error').mockImplementation(() => {
+    }),
+    warn: jest.spyOn(console, 'warn').mockImplementation(() => {
+    }),
+    debug: jest.spyOn(console, 'debug').mockImplementation(() => {
+    }),
 };
 
-// Mock useNavigate
 const mockNavigate = jest.fn();
 jest.mock('react-router-dom', () => ({
     ...jest.requireActual('react-router-dom'),
     useNavigate: () => mockNavigate,
 }));
 
+// --- Helpers ---
+
+const makeTokenWithExp = (expSecondsFromNow) => {
+    const payload = {exp: Math.floor(Date.now() / 1000) + expSecondsFromNow};
+    return 'h.' + btoa(JSON.stringify(payload)) + '.s';
+};
+
+const renderApp = (initialEntries = ['/']) => {
+    const theme = createTheme();
+    return render(
+        <DarkModeProvider>
+            <ThemeProvider theme={theme}>
+                <MemoryRouter initialEntries={initialEntries}>
+                    <App/>
+                </MemoryRouter>
+            </ThemeProvider>
+        </DarkModeProvider>
+    );
+};
+
+const setupBasicAuth = (tokenExpOffset = 3600) => {
+    const token = makeTokenWithExp(tokenExpOffset);
+    mockLocalStorage.getItem.mockImplementation((k) =>
+        k === 'authToken' ? token : k === 'authChoice' ? 'basic' : null
+    );
+    mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + tokenExpOffset});
+    return token;
+};
+
+const setupOidcAuth = (token = 'dummy') => {
+    mockLocalStorage.getItem.mockImplementation((k) =>
+        k === 'authToken' ? token : k === 'authChoice' ? 'openid' : null
+    );
+    mockAuthState.authChoice = 'openid';
+};
+
+// --- Tests ---
+
 describe('App Component', () => {
     beforeEach(() => {
-        jest.clearAllMocks();
-
-        mockLocalStorage.getItem.mockImplementation(() => null);
-        mockLocalStorage.setItem.mockImplementation(() => {
-        });
-        mockLocalStorage.removeItem.mockImplementation(() => {
+        // Use mockClear (preserves implementations) not mockReset (strips them)
+        mockAuthDispatch.mockClear();
+        mockLocalStorage.getItem.mockClear().mockReturnValue(null);
+        mockLocalStorage.setItem.mockClear().mockImplementation(() => {
         });
-
+        mockLocalStorage.removeItem.mockClear();
+        mockDecodeToken.mockClear();
+        mockNavigate.mockClear();
+        oidcConfiguration.mockClear();
+        // mockClear on console spies preserves their mockImplementation(() => {})
+        Object.values(consoleSpy).forEach(spy => spy.mockClear());
+        Object.values(logger).forEach(fn => fn.mockClear());
         mockAuthState.authChoice = null;
         mockAuthState.accessToken = null;
         mockAuthState.isAuthenticated = false;
-
         mockUserManager.getUser.mockResolvedValue(null);
         mockUserManager.signinSilent.mockResolvedValue(null);
-        mockUserManager.events.addUserLoaded.mockClear();
-        mockUserManager.events.addAccessTokenExpiring.mockClear();
-        mockUserManager.events.addAccessTokenExpired.mockClear();
-        mockUserManager.events.addSilentRenewError.mockClear();
-        mockUserManager.events.removeUserLoaded.mockClear();
-        mockUserManager.events.removeAccessTokenExpired.mockClear();
-        mockUserManager.events.removeSilentRenewError.mockClear();
-
+        Object.values(mockUserManager.events).forEach(fn => fn.mockClear?.());
         mockRecreateUserManager = jest.fn();
         mockOidcModule.__setMockRecreateUserManager(mockRecreateUserManager);
         mockOidcModule.__setMockIsInitialized(true);
-
-        oidcConfiguration.mockClear();
-        mockNavigate.mockClear();
-        mockDecodeToken.mockClear();
     });
 
-    // Helper function to render with all providers
-    const renderAppWithProviders = (initialEntries = ['/']) => {
-        const theme = createTheme();
-
-        return render(
-            <DarkModeProvider>
-                <ThemeProvider theme={theme}>
-                    <MemoryRouter initialEntries={initialEntries}>
-                        <App/>
-                    </MemoryRouter>
-                </ThemeProvider>
-            </DarkModeProvider>
-        );
-    };
-
-    test('renders NavBar and redirects from / to /cluster', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((key) => {
-            if (key === 'authToken') return validToken;
-            if (key === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/']);
+    // --- Routing ---
 
+    test('renders NavBar and redirects / to /cluster', async () => {
+        setupBasicAuth();
+        renderApp(['/']);
         expect(await screen.findByTestId('navbar')).toBeInTheDocument();
         expect(await screen.findByTestId('cluster')).toBeInTheDocument();
     });
 
-    test('ProtectedRoute with valid basic token shows cluster', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? validToken : (k === 'authChoice' ? 'basic' : null)
-        );
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
+    test('unknown route redirects to /cluster', async () => {
+        setupBasicAuth();
+        renderApp(['/unknown-route']);
         expect(await screen.findByTestId('cluster')).toBeInTheDocument();
     });
 
-    test('invalid basic token redirects to auth-choice and clears storage', async () => {
-        const invalidToken = makeTokenWithExp(-3600);
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? invalidToken : (k === 'authChoice' ? 'basic' : null)
-        );
+    test.each([
+        ['/namespaces', 'namespaces'],
+        ['/nodes', 'nodes'],
+        ['/pools', 'pools'],
+        ['/network', 'network'],
+        ['/objects', 'objects'],
+        ['/whoami', 'whoami'],
+        ['/network/test-network', 'network-details'],
+        ['/objects/test-object', 'object-details'],
+    ])('protected route %s renders %s', async (path, testId) => {
+        setupBasicAuth();
+        const {unmount} = renderApp([path]);
+        expect(await screen.findByTestId(testId)).toBeInTheDocument();
+        unmount();
+    });
 
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
+    test.each([
+        ['/heartbeats', 'heartbeats'],
+        ['/silent-renew', 'silent-renew'],
+        ['/auth-callback', 'auth-callback'],
+        ['/auth-choice', 'auth-choice'],
+        ['/auth/login', 'login'],
+    ])('unprotected route %s renders %s', async (path, testId) => {
+        const {unmount} = renderApp([path]);
+        expect(await screen.findByTestId(testId)).toBeInTheDocument();
+        unmount();
+    });
+
+    // --- ProtectedRoute ---
 
-        renderAppWithProviders(['/cluster']);
+    test('ProtectedRoute: valid basic token shows content', async () => {
+        setupBasicAuth();
+        renderApp(['/cluster']);
+        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
+    });
 
+    test('ProtectedRoute: expired basic token redirects and clears storage', async () => {
+        setupBasicAuth(-3600);
+        renderApp(['/cluster']);
         expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
         expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('tokenExpiration');
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authChoice');
+    });
+
+    test('ProtectedRoute: null token + null authChoice redirects', async () => {
+        renderApp(['/cluster']);
+        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
     });
 
-    test('openid authChoice with malformed token present still allows render', async () => {
+    test('ProtectedRoute: OIDC without token redirects', async () => {
         mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'not-a-valid-jwt' : (k === 'authChoice' ? 'openid' : null)
+            k === 'authChoice' ? 'openid' : null
         );
-        mockAuthState.authChoice = 'openid';
+        renderApp(['/cluster']);
+        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
+    });
 
+    test('ProtectedRoute: OIDC with malformed token still renders', async () => {
+        setupOidcAuth('not-a-valid-jwt');
         mockDecodeToken.mockReturnValue(null);
-
-        renderAppWithProviders(['/cluster']);
-
+        renderApp(['/cluster']);
         expect(await screen.findByTestId('cluster')).toBeInTheDocument();
     });
 
-    test('initializeOidcOnStartup calls oidcConfiguration and recreateUserManager when not initialized', async () => {
-        mockOidcModule.__setMockIsInitialized(false);
-        const validToken = makeTokenWithExp(3600);
-
+    test('ProtectedRoute: null token + null authChoice clears storage', async () => {
         mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? validToken : (k === 'authChoice' ? 'openid' : null)
+            k === 'authToken' ? makeTokenWithExp(-3600) : k === 'authChoice' ? null : null
         );
-        mockAuthState.authChoice = 'openid';
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
+        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
+        renderApp(['/cluster']);
+        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
+        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken');
+    });
 
-        renderAppWithProviders(['/cluster']);
+    // --- OIDC Initialization ---
 
+    test('initializeOidcOnStartup calls oidcConfiguration and recreateUserManager when not initialized', async () => {
+        mockOidcModule.__setMockIsInitialized(false);
+        setupOidcAuth(makeTokenWithExp(3600));
+        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
+        renderApp(['/cluster']);
         await waitFor(() => expect(oidcConfiguration).toHaveBeenCalled());
         await waitFor(() => expect(mockRecreateUserManager).toHaveBeenCalled());
-
         mockOidcModule.__setMockIsInitialized(true);
     });
 
-    test('initializeOidcOnStartup handles oidcConfiguration rejection gracefully', async () => {
-        mockOidcModule.__setMockIsInitialized(false);
-        oidcConfiguration.mockImplementationOnce(() =>
-            Promise.reject(new Error('config failed'))
-        );
+    test('initializeOidcOnStartup does not run if already initialized', async () => {
+        setupOidcAuth(makeTokenWithExp(3600));
+        renderApp(['/']);
+        await waitFor(() => {
+            expect(oidcConfiguration).not.toHaveBeenCalled();
+            expect(mockRecreateUserManager).not.toHaveBeenCalled();
+        });
+    });
 
-        const validToken = makeTokenWithExp(3600);
+    test('initializeOidcOnStartup does not run without token', async () => {
         mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? validToken : (k === 'authChoice' ? 'openid' : null)
+            k === 'authChoice' ? 'openid' : null
         );
         mockAuthState.authChoice = 'openid';
+        renderApp(['/']);
+        await waitFor(() => expect(oidcConfiguration).not.toHaveBeenCalled());
+    });
 
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
+    test('initializeOidcOnStartup does not run for non-openid authChoice', async () => {
+        setupBasicAuth();
+        renderApp(['/']);
+        await waitFor(() => expect(oidcConfiguration).not.toHaveBeenCalled());
+    });
 
-        renderAppWithProviders(['/cluster']);
+    test('initializeOidcOnStartup does not run if authInfo is null', async () => {
+        mockOidcModule.__setMockIsInitialized(false);
+        const authInfoMock = require('../../hooks/AuthInfo.jsx');
+        authInfoMock.mockImplementation(() => null);
+        setupOidcAuth(makeTokenWithExp(3600));
+        renderApp(['/']);
+        await new Promise(r => setTimeout(r, 200));
+        expect(oidcConfiguration).not.toHaveBeenCalled();
+        authInfoMock.mockImplementation(() => ({
+            openid: {
+                issuer: 'https://test-issuer.com',
+                client_id: 'test-client'
+            }
+        }));
+        mockOidcModule.__setMockIsInitialized(true);
+    });
 
+    test('initializeOidcOnStartup handles oidcConfiguration rejection', async () => {
+        mockOidcModule.__setMockIsInitialized(false);
+        oidcConfiguration.mockImplementationOnce(() => Promise.reject(new Error('config failed')));
+        setupOidcAuth(makeTokenWithExp(3600));
+        renderApp(['/cluster']);
         await new Promise(r => setTimeout(r, 200));
         expect(oidcConfiguration).toHaveBeenCalled();
         expect(mockRecreateUserManager).not.toHaveBeenCalled();
-        expect(console.error).toHaveBeenCalled();
-
+        expect(logger.error).toHaveBeenCalled();
         mockOidcModule.__setMockIsInitialized(true);
     });
 
     test('initializeOidcOnStartup handles recreateUserManager throwing', async () => {
         mockOidcModule.__setMockIsInitialized(false);
-
-        oidcConfiguration.mockImplementationOnce(() =>
-            Promise.resolve({client_id: 'x'})
-        );
-
+        oidcConfiguration.mockImplementationOnce(() => Promise.resolve({client_id: 'x'}));
         mockRecreateUserManager = jest.fn(() => {
             throw new Error('boom create');
         });
         mockOidcModule.__setMockRecreateUserManager(mockRecreateUserManager);
-
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? validToken : (k === 'authChoice' ? 'openid' : null)
-        );
-        mockAuthState.authChoice = 'openid';
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
+        setupOidcAuth(makeTokenWithExp(3600));
+        renderApp(['/cluster']);
         await new Promise(r => setTimeout(r, 200));
-        expect(oidcConfiguration).toHaveBeenCalled();
         expect(mockRecreateUserManager).toHaveBeenCalled();
-        expect(console.error).toHaveBeenCalled();
-
+        expect(logger.error).toHaveBeenCalled();
         mockOidcModule.__setMockIsInitialized(true);
     });
 
-    test('initializeOidcOnStartup does not run if authInfo hook returns null', async () => {
-        mockOidcModule.__setMockIsInitialized(false);
-
-        const authInfoMock = require('../../hooks/AuthInfo.jsx');
-        authInfoMock.mockImplementationOnce(() => null);
-
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? validToken : (k === 'authChoice' ? 'openid' : null)
-        );
-        mockAuthState.authChoice = 'openid';
-
-        renderAppWithProviders(['/cluster']);
-
-        await new Promise(r => setTimeout(r, 200));
-        expect(oidcConfiguration).not.toHaveBeenCalled();
-        expect(mockRecreateUserManager).not.toHaveBeenCalled();
+    // --- OIDC User Events ---
 
-        authInfoMock.mockImplementation(() => ({
-            openid: {issuer: 'https://test-issuer.com', client_id: 'test-client'}
-        }));
-        mockOidcModule.__setMockIsInitialized(true);
-    });
-
-    test('userManager.getUser valid user triggers login + token refresh', async () => {
+    test('valid user from getUser triggers SetAccessToken and Login dispatch', async () => {
         const validUser = {
             profile: {preferred_username: 'test-user'},
             access_token: 'new-token',
             expires_at: Math.floor(Date.now() / 1000) + 3600,
             expired: false,
         };
-
         mockUserManager.getUser.mockResolvedValue(validUser);
-        mockAuthState.authChoice = 'openid';
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockAuthDispatch).toHaveBeenCalledWith({type: 'SetAccessToken', data: 'new-token'}));
+        await waitFor(() => expect(mockAuthDispatch).toHaveBeenCalledWith({type: 'Login', data: 'test-user'}));
+        await waitFor(() => expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authToken', 'new-token'));
+        await waitFor(() => expect(mockLocalStorage.setItem).toHaveBeenCalledWith('tokenExpiration', expect.any(String)));
+    });
+
+    test('expired user from getUser does not trigger SetAccessToken', async () => {
+        mockUserManager.getUser.mockResolvedValue({profile: {preferred_username: 'x'}, expired: true});
+        setupOidcAuth();
+        renderApp(['/cluster']);
         await waitFor(() => expect(mockUserManager.getUser).toHaveBeenCalled());
-        await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'SetAccessToken',
-                data: 'new-token'
-            })
-        );
-
-        await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'Login',
-                data: 'test-user'
-            })
-        );
-
-        await waitFor(() =>
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
-                'authToken',
-                'new-token'
-            )
-        );
-
-        await waitFor(() =>
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
-                'tokenExpiration',
-                expect.any(String)
-            )
-        );
+        expect(mockAuthDispatch).not.toHaveBeenCalledWith(expect.objectContaining({type: 'SetAccessToken'}));
     });
 
-    test('expired user does not trigger SetAccessToken dispatch', async () => {
-        const expiredUser = {
-            profile: {preferred_username: 'expired-user'},
-            expired: true
+    test('expired user triggers silent renew; success dispatches tokens', async () => {
+        const refreshedUser = {
+            profile: {preferred_username: 'refreshed-user'},
+            access_token: 'refreshed-token',
+            expires_at: Math.floor(Date.now() / 1000) + 3600,
+            expired: false,
         };
-
-        mockUserManager.getUser.mockResolvedValue(expiredUser);
-        mockAuthState.authChoice = 'openid';
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() => expect(mockUserManager.getUser).toHaveBeenCalled());
-        expect(mockAuthDispatch).not.toHaveBeenCalledWith(
-            expect.objectContaining({type: 'SetAccessToken'})
-        );
+        mockUserManager.getUser.mockResolvedValue({profile: {preferred_username: 'x'}, expired: true});
+        mockUserManager.signinSilent.mockResolvedValue(refreshedUser);
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
+        await waitFor(() => expect(mockAuthDispatch).toHaveBeenCalledWith({
+            type: 'SetAccessToken',
+            data: 'refreshed-token'
+        }));
+        await waitFor(() => expect(mockAuthDispatch).toHaveBeenCalledWith({type: 'Login', data: 'refreshed-user'}));
     });
 
-    test('addAccessTokenExpired handler clears storage', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
+    test('expired user silent renew failure logs error', async () => {
+        mockUserManager.getUser.mockResolvedValue({profile: {preferred_username: 'x'}, expired: true});
+        mockUserManager.signinSilent.mockRejectedValue(new Error('Renew failed'));
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
+        expect(logger.error).toHaveBeenCalledWith('Silent renew failed:', expect.any(Error));
+    });
 
-        renderAppWithProviders(['/cluster']);
+    test('addAccessTokenExpired handler clears storage and navigates', async () => {
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.events.addAccessTokenExpired).toHaveBeenCalled());
+        act(() => mockUserManager.events.addAccessTokenExpired.mock.calls[0][0]());
+        await waitFor(() => expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken'));
+        await waitFor(() => expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('tokenExpiration'));
+        await waitFor(() => expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true}));
+    });
 
-        await waitFor(() =>
-            expect(mockUserManager.events.addAccessTokenExpired).toHaveBeenCalled()
-        );
+    test('addSilentRenewError handler clears storage and navigates', async () => {
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.events.addSilentRenewError).toHaveBeenCalled());
+        act(() => mockUserManager.events.addSilentRenewError.mock.calls[0][0](new Error('renew failed')));
+        await waitFor(() => expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken'));
+        await waitFor(() => expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true}));
+    });
 
-        const expiredCb = mockUserManager.events.addAccessTokenExpired.mock.calls[0][0];
+    test('addAccessTokenExpiring listener logs debug', async () => {
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.events.addAccessTokenExpiring).toHaveBeenCalled());
+        act(() => mockUserManager.events.addAccessTokenExpiring.mock.calls[0][0]());
+        expect(logger.debug).toHaveBeenCalled();
+    });
 
-        act(() => expiredCb());
+    test('removes old event listeners before adding new ones', async () => {
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.events.removeUserLoaded).toHaveBeenCalled());
+        await waitFor(() => expect(mockUserManager.events.removeAccessTokenExpired).toHaveBeenCalled());
+        await waitFor(() => expect(mockUserManager.events.removeSilentRenewError).toHaveBeenCalled());
+    });
 
-        await waitFor(() =>
-            expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken')
-        );
+    test('onUserRefreshed: user without profile does not dispatch Login', async () => {
+        setupOidcAuth();
+        mockUserManager.getUser.mockResolvedValue({
+            access_token: 'new-token',
+            expires_at: Math.floor(Date.now() / 1000) + 3600
+        });
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockAuthDispatch).toHaveBeenCalledWith({type: 'SetAccessToken', data: 'new-token'}));
+        expect(mockAuthDispatch).not.toHaveBeenCalledWith(expect.objectContaining({
+            type: 'Login',
+            data: expect.anything()
+        }));
+    });
 
-        await waitFor(() =>
-            expect(mockLocalStorage.removeItem).toHaveBeenCalledWith(
-                'tokenExpiration'
-            )
-        );
+    test('onUserRefreshed via addUserLoaded event fires correctly', async () => {
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.events.addUserLoaded).toHaveBeenCalled());
+        act(() => mockUserManager.events.addUserLoaded.mock.calls[0][0]({
+            profile: {preferred_username: 'event-user'},
+            access_token: 'event-token',
+            expires_at: Math.floor(Date.now() / 1000) + 3600,
+        }));
+        await waitFor(() => expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authToken', 'event-token'));
     });
 
-    test('addSilentRenewError handler clears storage', async () => {
-        mockAuthState.authChoice = 'openid';
+    // --- Auth Choice Persistence ---
 
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
+    test('saves auth.authChoice to localStorage', async () => {
+        mockAuthState.authChoice = 'basic';
+        renderApp(['/']);
+        await waitFor(() => expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authChoice', 'basic'));
+    });
 
-        renderAppWithProviders(['/cluster']);
+    test('does not save authChoice if null', async () => {
+        renderApp(['/']);
+        await waitFor(() => {
+            expect(mockLocalStorage.setItem).not.toHaveBeenCalledWith('authChoice', expect.anything());
+        });
+    });
 
-        await waitFor(() =>
-            expect(mockUserManager.events.addSilentRenewError).toHaveBeenCalled()
-        );
+    // --- Auth Resume (visibility/focus) ---
 
-        const errorCb = mockUserManager.events.addSilentRenewError.mock.calls[0][0];
+    test('focus triggers redirect when basic token is expired', async () => {
+        setupBasicAuth(-3600);
+        renderApp(['/cluster']);
+        act(() => window.dispatchEvent(new Event('focus')));
+        await act(async () => {
+            await new Promise(r => setTimeout(r, 600));
+        });
+        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
+    });
 
-        act(() => errorCb(new Error('renew failed')));
+    test('focus does not redirect when OIDC token is present', async () => {
+        setupOidcAuth('dummy-token');
+        renderApp(['/cluster']);
+        act(() => window.dispatchEvent(new Event('focus')));
+        await act(async () => {
+            await new Promise(r => setTimeout(r, 10));
+        });
+        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
+        expect(mockNavigate).not.toHaveBeenCalledWith('/auth-choice', {replace: true});
+    });
 
-        await waitFor(() =>
-            expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken')
-        );
+    test('focus does not redirect when basic token is valid', async () => {
+        setupBasicAuth();
+        renderApp(['/cluster']);
+        act(() => window.dispatchEvent(new Event('focus')));
+        await act(async () => {
+            await new Promise(r => setTimeout(r, 10));
+        });
+        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
+    });
 
-        await waitFor(() =>
-            expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('tokenExpiration')
-        );
+    test('visibilitychange triggers auth check without redirect for valid token', async () => {
+        setupBasicAuth();
+        renderApp(['/cluster']);
+        Object.defineProperty(document, 'visibilityState', {value: 'visible', configurable: true});
+        act(() => document.dispatchEvent(new Event('visibilitychange')));
+        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
     });
 
-    test('addAccessTokenExpiring listener logs debug', async () => {
-        mockAuthState.authChoice = 'openid';
+    test('OIDC expired token on resume triggers silent renew and updates storage', async () => {
+        setupOidcAuth(makeTokenWithExp(-3600));
+        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
+        mockUserManager.signinSilent.mockResolvedValue({
+            profile: {preferred_username: 'refreshed-user'},
+            access_token: 'refreshed-token',
+            expires_at: Math.floor(Date.now() / 1000) + 3600,
+            expired: false,
+        });
+        renderApp(['/cluster']);
+        act(() => window.dispatchEvent(new Event('focus')));
+        await act(async () => {
+            await new Promise(r => setTimeout(r, 600));
+        });
+        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
+        await waitFor(() => expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authToken', 'refreshed-token'));
+    });
 
+    test('OIDC with no token on resume redirects', async () => {
         mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() =>
-            expect(mockUserManager.events.addAccessTokenExpiring).toHaveBeenCalled()
+            k === 'authChoice' ? 'openid' : null
         );
-
-        const expiringCb =
-            mockUserManager.events.addAccessTokenExpiring.mock.calls[0][0];
-
-        act(() => expiringCb());
-
-        expect(console.debug).toHaveBeenCalled();
+        renderApp(['/cluster']);
+        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
     });
 
-    test('removes old listeners when setting up new ones', async () => {
-        mockAuthState.authChoice = 'openid';
-
+    test('handleCheckAuthOnResume: OIDC no token on focus redirects', async () => {
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        // After initial render, simulate focus with no token
         mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() =>
-            expect(mockUserManager.events.removeUserLoaded).toHaveBeenCalled()
-        );
-        await waitFor(() =>
-            expect(mockUserManager.events.removeAccessTokenExpired).toHaveBeenCalled()
-        );
-        await waitFor(() =>
-            expect(mockUserManager.events.removeSilentRenewError).toHaveBeenCalled()
-        );
-    });
-
-    test('storage event triggers checkTokenChange', async () => {
-        mockLocalStorage.getItem.mockReturnValue(null);
-
-        renderAppWithProviders(['/auth-choice']);
-
-        act(() => {
-            window.dispatchEvent(
-                new StorageEvent('storage', {
-                    key: 'authToken',
-                    newValue: makeTokenWithExp(3600)
-                })
-            );
-        });
-
-        await waitFor(() =>
-            expect(mockLocalStorage.getItem).toHaveBeenCalledWith('authToken')
-        );
-    });
-
-    test('focus triggers redirect when token invalid', async () => {
-        const invalidToken = makeTokenWithExp(-3600);
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? invalidToken : (k === 'authChoice' ? 'basic' : null)
+            k === 'authChoice' ? 'openid' : null
         );
+        act(() => window.dispatchEvent(new Event('focus')));
+        await act(async () => {
+            await new Promise(r => setTimeout(r, 600));
+        });
+        expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true});
+    });
 
+    test('handleCheckAuthOnResume: OIDC expired token without userManager redirects', async () => {
+        // Simulate userManager being null at resume time
+        mockOidcModule.__setMockIsInitialized(false);
+        const expiredToken = makeTokenWithExp(-3600);
+        setupOidcAuth(expiredToken);
         mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
+        // Override userManager to null for this test
+        jest.spyOn(require('../../context/OidcAuthContext.tsx'), 'useOidc').mockReturnValue({
+            userManager: null,
+            recreateUserManager: mockRecreateUserManager,
+            isInitialized: false,
         });
-
+        renderApp(['/cluster']);
+        act(() => window.dispatchEvent(new Event('focus')));
         await act(async () => {
-            await new Promise(resolve => setTimeout(resolve, 600));
-        });
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('visibilitychange does not redirect for valid openid', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy-token' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        act(() => {
-            Object.defineProperty(document, 'visibilityState', {
-                value: 'visible',
-                configurable: true
-            });
-            document.dispatchEvent(new Event('visibilitychange'));
-        });
-
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-    });
-
-    test('saves auth.authChoice to localStorage', async () => {
-        mockAuthState.authChoice = 'basic';
-
-        renderAppWithProviders(['/']);
-
-        await waitFor(() =>
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
-                'authChoice',
-                'basic'
-            )
-        );
-    });
-
-    test('unknown route redirects to /cluster', async () => {
-        const validToken = makeTokenWithExp(3600);
-
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? validToken : (k === 'authChoice' ? 'basic' : null)
-        );
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/unknown-route']);
-
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-    });
-
-    test('initializeOidcOnStartup does not run if savedAuthChoice is not openid', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic'; // Not 'openid'
-            return null;
-        });
-        mockAuthState.authChoice = 'basic';
-
-        renderAppWithProviders(['/']);
-
-        await waitFor(() => {
-            expect(oidcConfiguration).not.toHaveBeenCalled();
-            expect(mockRecreateUserManager).not.toHaveBeenCalled();
-        });
-    });
-
-    test('initializeOidcOnStartup does not run without token', async () => {
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return null; // No token
-            if (k === 'authChoice') return 'openid';
-            return null;
+            await new Promise(r => setTimeout(r, 600));
         });
-        mockAuthState.authChoice = 'openid';
-
-        renderAppWithProviders(['/']);
-
-        await waitFor(() => {
-            expect(oidcConfiguration).not.toHaveBeenCalled();
-            expect(mockRecreateUserManager).not.toHaveBeenCalled();
-        });
-    });
-
-    test('initializeOidcOnStartup does not run if already initialized', async () => {
+        expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true});
+        jest.restoreAllMocks();
         mockOidcModule.__setMockIsInitialized(true);
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'openid';
-            return null;
-        });
-        mockAuthState.authChoice = 'openid';
-
-        renderAppWithProviders(['/']);
-
-        await waitFor(() => {
-            expect(oidcConfiguration).not.toHaveBeenCalled();
-            expect(mockRecreateUserManager).not.toHaveBeenCalled();
-        });
-    });
-
-    test('userManager.getUser returns null does not trigger login', async () => {
-        mockUserManager.getUser.mockResolvedValue(null);
-        mockAuthState.authChoice = 'openid';
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() => expect(mockUserManager.getUser).toHaveBeenCalled());
-
-        // Should not trigger SetAccessToken
-        expect(mockAuthDispatch).not.toHaveBeenCalledWith(
-            expect.objectContaining({type: 'SetAccessToken'})
-        );
-
-        // Should not trigger Login
-        expect(mockAuthDispatch).not.toHaveBeenCalledWith(
-            expect.objectContaining({type: 'Login'})
-        );
     });
 
-    test('silent renew fails on expired user', async () => {
-        const expiredUser = {
-            profile: {preferred_username: 'expired-user'},
-            expired: true,
-        };
-
-        mockUserManager.getUser.mockResolvedValue(expiredUser);
-        mockUserManager.signinSilent.mockRejectedValue(new Error('Renew failed'));
-
-        mockAuthState.authChoice = 'openid';
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() => expect(mockUserManager.getUser).toHaveBeenCalled());
-        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
-
-        expect(console.error).toHaveBeenCalledWith('Silent renew failed:', expect.any(Error));
-    });
-
-    test('ProtectedRoute redirects if authChoice openid without token', async () => {
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return null; // No token
-            if (k === 'authChoice') return 'openid';
-            return null;
-        });
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('ProtectedRoute with null authChoice and invalid token', async () => {
-        const invalidToken = makeTokenWithExp(-3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return invalidToken;
-            if (k === 'authChoice') return null; // authChoice null
-            return null;
-        });
-
+    test('handleCheckAuthOnResume: OIDC silent renew returns expired user redirects', async () => {
+        const expiredToken = makeTokenWithExp(-3600);
+        setupOidcAuth(expiredToken);
         mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken');
-        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('tokenExpiration');
-        expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authChoice');
-    });
-
-    test('handleCheckAuthOnResume does not redirect for OIDC with token', async () => {
-        mockAuthState.authChoice = 'openid';
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return 'oidc-token';
-            if (k === 'authChoice') return 'openid';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        // Simulate focus
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
-        });
-
+        // Silent renew returns an expired user
+        mockUserManager.signinSilent.mockResolvedValue({expired: true});
+        renderApp(['/cluster']);
+        act(() => window.dispatchEvent(new Event('focus')));
         await act(async () => {
-            await new Promise(resolve => setTimeout(resolve, 10));
+            await new Promise(r => setTimeout(r, 600));
         });
-
-        // Should not redirect
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-        expect(screen.queryByTestId('auth-choice')).not.toBeInTheDocument();
-    });
-
-    test('handleCheckAuthOnResume does not redirect for basic auth with valid token', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        // Simulate focus
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
-        });
-
-        await act(async () => {
-            await new Promise(resolve => setTimeout(resolve, 10));
-        });
-
-        // Should not redirect
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-        expect(screen.queryByTestId('auth-choice')).not.toBeInTheDocument();
-    });
-
-    test('does not save authChoice to localStorage if auth.authChoice is null', async () => {
-        mockAuthState.authChoice = null;
-
-        renderAppWithProviders(['/']);
-
-        await waitFor(() => {
-            expect(mockLocalStorage.setItem).not.toHaveBeenCalledWith('authChoice', expect.anything());
-        });
-    });
-
-    test('handles om3:auth-redirect event', async () => {
-        renderAppWithProviders(['/']);
-
-        act(() => {
-            window.dispatchEvent(new CustomEvent('om3:auth-redirect', {
-                detail: '/auth-choice'
-            }));
-        });
-
-        // Check that navigate was called
+        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
         expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true});
     });
 
-    test('handles storage event with new token', async () => {
-        const newToken = makeTokenWithExp(3600);
-
-        // First, set up the initial state with no token
-        mockLocalStorage.getItem.mockImplementation((key) => {
-            if (key === 'authToken') return null;
-            return null;
-        });
-
-        renderAppWithProviders(['/']);
-
-        // Now change the mock to return the new token when getItem is called after the storage event
-        mockLocalStorage.getItem.mockImplementation((key) => {
-            if (key === 'authToken') return newToken;
-            return null;
-        });
-
-        act(() => {
-            window.dispatchEvent(
-                new StorageEvent('storage', {
-                    key: 'authToken',
-                    newValue: newToken,
-                    oldValue: 'old-token',
-                    url: window.location.href
-                })
-            );
-        });
-
-        // Wait for the component to process the event
-        await waitFor(() => {
-            // Check that getItem was called with 'authToken'
-            expect(mockLocalStorage.getItem).toHaveBeenCalledWith('authToken');
-        });
-
-        // The component logs multiple debug messages, we need to find the storage event one
-        const debugCalls = console.debug.mock.calls;
-        const storageEventCalls = debugCalls.filter(call =>
-            call[0] === 'Storage event: newToken='
-        );
-
-        // Should have at least one storage event log
-        expect(storageEventCalls.length).toBeGreaterThan(0);
-
-        // The last storage event should have the newToken
-        const lastStorageCall = storageEventCalls[storageEventCalls.length - 1];
-        expect(lastStorageCall[0]).toBe('Storage event: newToken=');
-        expect(lastStorageCall[1]).toBe(newToken);
+    test('expired user silent renew returns still-expired user logs warning', async () => {
+        mockUserManager.getUser.mockResolvedValue({profile: {preferred_username: 'x'}, expired: true});
+        // signinSilent returns a still-expired user
+        mockUserManager.signinSilent.mockResolvedValue({expired: true, profile: {preferred_username: 'x'}});
+        setupOidcAuth();
+        renderApp(['/cluster']);
+        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
+        expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Silent renew failed or user still expired'));
     });
 
-    test('handles errors in handleCheckAuthOnResume', async () => {
-        mockLocalStorage.getItem.mockImplementation(() => {
-            throw new Error('Storage error');
-        });
-
-        // We need a valid token to reach the handleCheckAuthOnResume
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        // Now mock getItem to throw error for the focus event
+    test('handleCheckAuthOnResume handles storage errors gracefully', async () => {
+        setupBasicAuth();
+        renderApp(['/cluster']);
         mockLocalStorage.getItem.mockImplementation(() => {
             throw new Error('Storage error');
         });
-
-        // Simulate focus (which will trigger the error)
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
-        });
-
-        await waitFor(() => {
-            expect(console.error).toHaveBeenCalledWith(
-                'Error while checking auth on resume:',
-                expect.any(Error)
-            );
-        });
-    });
-
-    test('isTokenValid returns false for malformed token', async () => {
-        const invalidToken = 'not.a.valid.jwt';
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return invalidToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue(null);
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('isTokenValid returns false for expired token', async () => {
-        const expiredToken = makeTokenWithExp(-3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return expiredToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('handles silent renew error callback with error parameter', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() =>
-            expect(mockUserManager.events.addSilentRenewError).toHaveBeenCalled()
-        );
-
-        const errorCb = mockUserManager.events.addSilentRenewError.mock.calls[0][0];
-
-        act(() => errorCb(new Error('renew failed')));
-
-        await waitFor(() =>
-            expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('authToken')
-        );
-
-        await waitFor(() =>
-            expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('tokenExpiration')
-        );
-
-        expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true});
-    });
-
-    test('onUserRefreshed callback handles user without profile', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        const userWithoutProfile = {
-            access_token: 'new-token',
-            expires_at: Math.floor(Date.now() / 1000) + 3600,
-        };
-
-        // Simulate that getUser returns this user
-        mockUserManager.getUser.mockResolvedValue(userWithoutProfile);
-
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        // Wait for getUser to be called
-        await waitFor(() => expect(mockUserManager.getUser).toHaveBeenCalled());
-
-        // The onUserRefreshed callback should still be called
+        act(() => window.dispatchEvent(new Event('focus')));
         await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'SetAccessToken',
-                data: 'new-token'
-            })
-        );
-
-        // But Login action should not be dispatched since there's no profile
-        expect(mockAuthDispatch).not.toHaveBeenCalledWith(
-            expect.objectContaining({type: 'Login', data: expect.anything()})
+            expect(logger.error).toHaveBeenCalledWith('Error while checking auth on resume:', expect.any(Error))
         );
     });
 
-    test('visibilitychange triggers auth check on resume', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
+    // --- Miscellaneous ---
 
-        // Mock document.visibilityState
-        Object.defineProperty(document, 'visibilityState', {
-            value: 'visible',
-            configurable: true,
-        });
-
-        // Trigger visibilitychange event
-        act(() => {
-            document.dispatchEvent(new Event('visibilitychange'));
-        });
-
-        // Should not redirect since token is valid
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-    });
-
-    test('handleCheckAuthOnResume handles OIDC with valid token', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        // Mock valid token (not expired)
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'openid';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        // Simulate focus
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
-        });
-
-        await act(async () => {
-            await new Promise(resolve => setTimeout(resolve, 10));
-        });
-
-        // Should not redirect
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-        expect(mockNavigate).not.toHaveBeenCalledWith('/auth-choice', {replace: true});
+    test('handles om3:auth-redirect event', async () => {
+        renderApp(['/']);
+        act(() => window.dispatchEvent(new CustomEvent('om3:auth-redirect', {detail: '/auth-choice'})));
+        expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true});
     });
 
-    test('handleCheckAuthOnResume handles basic auth with expired token', async () => {
-        mockAuthState.authChoice = 'basic';
-
-        // Mock expired token
-        const expiredToken = makeTokenWithExp(-3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return expiredToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
-
-        renderAppWithProviders(['/cluster']);
-
-        // Simulate focus
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
-        });
-
-        await act(async () => {
-            await new Promise(resolve => setTimeout(resolve, 600));
-        });
-
-        // Should redirect
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-        expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true});
+    test('storage event calls getItem to check new token', async () => {
+        const newToken = makeTokenWithExp(3600);
+        // Render with auth-choice path to avoid ProtectedRoute interference
+        mockLocalStorage.getItem.mockImplementation((k) => k === 'authChoice' ? 'basic' : null);
+        renderApp(['/auth-choice']);
+        await screen.findByTestId('auth-choice');
+        mockLocalStorage.getItem.mockImplementation((k) => k === 'authToken' ? newToken : null);
+        act(() => window.dispatchEvent(new StorageEvent('storage', {key: 'authToken', newValue: newToken})));
+        await waitFor(() => expect(mockLocalStorage.getItem).toHaveBeenCalledWith('authToken'));
     });
 
     test('event listeners are cleaned up on unmount', async () => {
-        const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
-        const documentAddEventListenerSpy = jest.spyOn(document, 'addEventListener');
-        const documentRemoveEventListenerSpy = jest.spyOn(document, 'removeEventListener');
-
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        const {unmount} = renderAppWithProviders(['/']);
-
-        // Wait for initial render
+        const removeListenerSpy = jest.spyOn(window, 'removeEventListener');
+        const docRemoveListenerSpy = jest.spyOn(document, 'removeEventListener');
+        setupBasicAuth();
+        const {unmount} = renderApp(['/']);
         await screen.findByTestId('navbar');
-
-        // Unmount the component
         unmount();
-
-        // Check that event listeners were removed
-        expect(removeEventListenerSpy).toHaveBeenCalledWith('storage', expect.any(Function));
-        expect(removeEventListenerSpy).toHaveBeenCalledWith('focus', expect.any(Function));
-        expect(removeEventListenerSpy).toHaveBeenCalledWith('om3:auth-redirect', expect.any(Function));
-        expect(documentRemoveEventListenerSpy).toHaveBeenCalledWith('visibilitychange', expect.any(Function));
+        expect(removeListenerSpy).toHaveBeenCalledWith('storage', expect.any(Function));
+        expect(removeListenerSpy).toHaveBeenCalledWith('focus', expect.any(Function));
+        expect(removeListenerSpy).toHaveBeenCalledWith('om3:auth-redirect', expect.any(Function));
+        expect(docRemoveListenerSpy).toHaveBeenCalledWith('visibilitychange', expect.any(Function));
     });
 
-    test('handles all route paths correctly', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        // Test each protected route
-        const routes = [
-            {path: '/namespaces', testId: 'namespaces'},
-            {path: '/nodes', testId: 'nodes'},
-            {path: '/pools', testId: 'pools'},
-            {path: '/network', testId: 'network'},
-            {path: '/objects', testId: 'objects'},
-            {path: '/whoami', testId: 'whoami'},
-        ];
-
-        for (const route of routes) {
-            mockNavigate.mockClear();
-            const {unmount} = renderAppWithProviders([route.path]);
-
-            await waitFor(() => {
-                expect(screen.getByTestId(route.testId)).toBeInTheDocument();
-            });
-
-            unmount();
-        }
-
-        // Test non-protected routes
-        const nonProtectedRoutes = [
-            {path: '/heartbeats', testId: 'heartbeats'},
-            {path: '/silent-renew', testId: 'silent-renew'},
-            {path: '/auth-callback', testId: 'auth-callback'},
-            {path: '/auth-choice', testId: 'auth-choice'},
-            {path: '/auth/login', testId: 'login'},
-        ];
-
-        for (const route of nonProtectedRoutes) {
-            mockNavigate.mockClear();
-            const {unmount} = renderAppWithProviders([route.path]);
-
-            await waitFor(() => {
-                expect(screen.getByTestId(route.testId)).toBeInTheDocument();
-            });
-
+    test('isTokenValid: null, empty, and malformed tokens fail', async () => {
+        for (const token of [null, '', 'not.a.valid.jwt']) {
+            mockLocalStorage.getItem.mockImplementation((k) =>
+                k === 'authToken' ? token : k === 'authChoice' ? 'basic' : null
+            );
+            mockDecodeToken.mockReturnValue(null);
+            const {unmount} = renderApp(['/cluster']);
+            expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
             unmount();
         }
     });
-
-    test('ProtectedRoute with null token and null authChoice', async () => {
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return null;
-            if (k === 'authChoice') return null;
-            return null;
-        });
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('onUserRefreshed callback is called when user loaded event fires', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() =>
-            expect(mockUserManager.events.addUserLoaded).toHaveBeenCalled()
-        );
-
-        const userLoadedCallback = mockUserManager.events.addUserLoaded.mock.calls[0][0];
-        expect(userLoadedCallback).toBeDefined();
-
-        const testUser = {
-            profile: {preferred_username: 'event-user'},
-            access_token: 'event-token',
-            expires_at: Math.floor(Date.now() / 1000) + 3600,
-        };
-
-        // Call the callback directly
-        act(() => {
-            userLoadedCallback(testUser);
-        });
-
-        await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'SetAccessToken',
-                data: 'event-token'
-            })
-        );
-
-        await waitFor(() =>
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authToken', 'event-token')
-        );
-    });
-
-    test('isTokenValid returns false for null token', async () => {
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return null; // null token
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('isTokenValid returns false for empty token string', async () => {
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return ''; // empty string token
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue(null);
-
-        renderAppWithProviders(['/cluster']);
-
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('onUserRefreshed handles user with profile but no preferred_username', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        const userWithProfileNoUsername = {
-            profile: {}, // Profile exists but no preferred_username
-            access_token: 'token-no-username',
-            expires_at: Math.floor(Date.now() / 1000) + 3600,
-        };
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() =>
-            expect(mockUserManager.events.addUserLoaded).toHaveBeenCalled()
-        );
-
-        const userLoadedCallback = mockUserManager.events.addUserLoaded.mock.calls[0][0];
-
-        // Call the callback with user without preferred_username
-        act(() => {
-            userLoadedCallback(userWithProfileNoUsername);
-        });
-
-        await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'SetAccessToken',
-                data: 'token-no-username'
-            })
-        );
-
-        // Login action should not be dispatched since there's no preferred_username
-        expect(mockAuthDispatch).not.toHaveBeenCalledWith(
-            expect.objectContaining({type: 'Login', data: expect.anything()})
-        );
-    });
-
-    test('handleTokenExpired callback navigates to auth-choice', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() =>
-            expect(mockUserManager.events.addAccessTokenExpired).toHaveBeenCalled()
-        );
-
-        const expiredCb = mockUserManager.events.addAccessTokenExpired.mock.calls[0][0];
-
-        act(() => expiredCb());
-
-        await waitFor(() =>
-            expect(mockNavigate).toHaveBeenCalledWith('/auth-choice', {replace: true})
-        );
-    });
-
-    test('silent renew on expired user with successful renew', async () => {
-        const expiredUser = {
-            profile: {preferred_username: 'expired-user'},
-            expired: true,
-        };
-
-        const refreshedUser = {
-            profile: {preferred_username: 'refreshed-user'},
-            access_token: 'refreshed-token',
-            expires_at: Math.floor(Date.now() / 1000) + 3600,
-            expired: false,
-        };
-
-        mockUserManager.getUser.mockResolvedValue(expiredUser);
-        mockUserManager.signinSilent.mockResolvedValue(refreshedUser);
-
-        mockAuthState.authChoice = 'openid';
-        mockLocalStorage.getItem.mockImplementation((k) =>
-            k === 'authToken' ? 'dummy' : (k === 'authChoice' ? 'openid' : null)
-        );
-
-        renderAppWithProviders(['/cluster']);
-
-        await waitFor(() => expect(mockUserManager.getUser).toHaveBeenCalled());
-        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
-
-        // Should dispatch actions for refreshed user
-        await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'SetAccessToken',
-                data: 'refreshed-token'
-            })
-        );
-
-        await waitFor(() =>
-            expect(mockAuthDispatch).toHaveBeenCalledWith({
-                type: 'Login',
-                data: 'refreshed-user'
-            })
-        );
-    });
-
-    test('network details route with parameter', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/network/test-network']);
-
-        expect(await screen.findByTestId('network-details')).toBeInTheDocument();
-    });
-
-    test('object details route with parameter', async () => {
-        const validToken = makeTokenWithExp(3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return validToken;
-            if (k === 'authChoice') return 'basic';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) + 3600});
-
-        renderAppWithProviders(['/objects/test-object']);
-
-        expect(await screen.findByTestId('object-details')).toBeInTheDocument();
-    });
-
-    test('auth choice saved to localStorage when authChoice changes', async () => {
-        // Simulate authChoice changing from null to 'basic'
-        let currentAuthChoice = null;
-        mockAuthState.authChoice = 'basic';
-
-        mockLocalStorage.setItem.mockImplementation((key, value) => {
-            if (key === 'authChoice') {
-                currentAuthChoice = value;
-            }
-        });
-
-        mockLocalStorage.getItem.mockImplementation((key) => {
-            if (key === 'authChoice') return currentAuthChoice;
-            return null;
-        });
-
-        renderAppWithProviders(['/']);
-
-        await waitFor(() => {
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authChoice', 'basic');
-        });
-    });
-
-    test('handleCheckAuthOnResume for OIDC with no token', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return null; // No token
-            if (k === 'authChoice') return 'openid';
-            return null;
-        });
-
-        renderAppWithProviders(['/cluster']);
-        expect(await screen.findByTestId('auth-choice')).toBeInTheDocument();
-    });
-
-    test('handleCheckAuthOnResume for OIDC with expired token and userManager', async () => {
-        mockAuthState.authChoice = 'openid';
-
-        // Mock expired token
-        const expiredToken = makeTokenWithExp(-3600);
-        mockLocalStorage.getItem.mockImplementation((k) => {
-            if (k === 'authToken') return expiredToken;
-            if (k === 'authChoice') return 'openid';
-            return null;
-        });
-
-        mockDecodeToken.mockReturnValue({exp: Math.floor(Date.now() / 1000) - 3600});
-
-        // Mock successful silent renew
-        const refreshedUser = {
-            profile: {preferred_username: 'refreshed-user'},
-            access_token: 'refreshed-token',
-            expires_at: Math.floor(Date.now() / 1000) + 3600,
-            expired: false,
-        };
-
-        mockUserManager.signinSilent.mockResolvedValue(refreshedUser);
-
-        renderAppWithProviders(['/cluster']);
-
-        // Simulate focus event
-        act(() => {
-            window.dispatchEvent(new Event('focus'));
-        });
-
-        await act(async () => {
-            await new Promise(resolve => setTimeout(resolve, 600));
-        });
-
-        // Wait for silent renew to complete
-        await waitFor(() => expect(mockUserManager.signinSilent).toHaveBeenCalled());
-
-        // Should update storage
-        await waitFor(() =>
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith('authToken', 'refreshed-token')
-        );
-
-        // Should not redirect
-        expect(await screen.findByTestId('cluster')).toBeInTheDocument();
-    });
 });
diff --git a/src/components/tests/ConfigSection.test.jsx b/src/components/tests/ConfigSection.test.jsx
index 79daeb17..c985966f 100644
--- a/src/components/tests/ConfigSection.test.jsx
+++ b/src/components/tests/ConfigSection.test.jsx
@@ -332,10 +332,9 @@ describe('ConfigSection Component', () => {
 
     test('shows no configuration available when configNode is missing', async () => {
         renderConfig({configNode: ''});
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/No node available to fetch configuration/i);
-        }, {timeout: 5000});
-        expect(global.fetch).not.toHaveBeenCalled();
+        await waitFor(() =>
+            expect(screen.getByText(/No instance selected to view configuration/i)).toBeInTheDocument()
+        );
     });
 
     test('shows "No configuration available" when config text is null', async () => {
diff --git a/src/components/tests/NodeRow.test.jsx b/src/components/tests/NodeRow.test.jsx
index 678b57c2..dd8839f2 100644
--- a/src/components/tests/NodeRow.test.jsx
+++ b/src/components/tests/NodeRow.test.jsx
@@ -26,7 +26,6 @@ jest.mock('../../constants/actions', () => ({
         {name: 'drain', icon: jest.fn(() => <span aria-label="Drain icon"/>)},
         {name: 'push/asset', icon: jest.fn(() => <span aria-label="Asset icon"/>)},
         {name: 'push/disk', icon: jest.fn(() => <span aria-label="Disk icon"/>)},
-        {name: 'push/patch', icon: jest.fn(() => <span aria-label="Patch icon"/>)},
         {name: 'push/pkg', icon: jest.fn(() => <span aria-label="Pkg icon"/>)},
         {name: 'scan/capabilities', icon: jest.fn(() => <span aria-label="Capabilities icon"/>)},
         {name: 'sysreport', icon: jest.fn(() => <span aria-label="Sysreport icon"/>)},
diff --git a/src/components/tests/ObjectDetails.test.jsx b/src/components/tests/ObjectDetails.test.jsx
index 2ba9657c..31a80339 100644
--- a/src/components/tests/ObjectDetails.test.jsx
+++ b/src/components/tests/ObjectDetails.test.jsx
@@ -1,63 +1,16 @@
 import React, {act} from 'react';
 import {render, screen, fireEvent, waitFor, within} from '@testing-library/react';
 import {MemoryRouter, Route, Routes} from 'react-router-dom';
+import userEvent from '@testing-library/user-event';
 import ObjectDetail, {getResourceType, parseProvisionedState} from '../ObjectDetails';
 import useEventStore from '../../hooks/useEventStore.js';
-import {closeEventSource, startEventReception} from '../../eventSourceManager.jsx';
-import userEvent from '@testing-library/user-event';
+import {closeEventSource, startEventReception, clearEventBuffers} from '../../eventSourceManager.jsx';
 import logger from '../../utils/logger';
 
-jest.mock('react-router-dom', () => ({
-    ...jest.requireActual('react-router-dom'),
-    useParams: jest.fn(),
-    useNavigate: jest.fn(),
-}));
-jest.mock('../../hooks/useEventStore.js');
-jest.mock('../../eventSourceManager.jsx', () => ({
-    closeEventSource: jest.fn(),
-    startEventReception: jest.fn(),
-    startLoggerReception: jest.fn(),
-    closeLoggerEventSource: jest.fn(),
-}));
-jest.mock('../../context/DarkModeContext', () => ({
-    useDarkMode: () => ({isDarkMode: false, toggleDarkMode: jest.fn()}),
-}));
-jest.mock("../../utils/logger", () => ({
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-}));
-
-jest.mock('../ConfigSection', () => ({
-    __esModule: true,
-    default: ({decodedObjectName, configNode, setConfigNode, openSnackbar, configDialogOpen, setConfigDialogOpen}) => (
-        <div>
-            <button onClick={() => setConfigDialogOpen(true)} data-testid="open-config-dialog">
-                View Configuration
-            </button>
-            {configDialogOpen && (
-                <div role="dialog" data-testid="config-dialog">
-                    <div>Configuration for {decodedObjectName}</div>
-                    {configNode && <div>Node: {configNode}</div>}
-                </div>
-            )}
-        </div>
-    ),
-}));
-
 jest.mock('@mui/material', () => {
     const actual = jest.requireActual('@mui/material');
     return {
         ...actual,
-        Accordion: ({children, expanded, onChange, ...props}) => (
-            <div role="region" className={expanded ? 'expanded' : ''} {...props}>{children}</div>
-        ),
-        AccordionSummary: ({children, id, onChange, expanded, expandIcon, ...props}) => (
-            <div role="button" aria-expanded={expanded ? 'true' : 'false'}
-                 aria-label={`expand configuration for ${id}`}
-                 onClick={() => onChange?.({}, !expanded)} {...props}>{children}</div>
-        ),
-        AccordionDetails: ({children, ...props}) => <div {...props}>{children}</div>,
         Menu: ({children, open, anchorEl, onClose, disablePortal, ...props}) =>
             open ? <div role="menu" {...props}>{children}</div> : null,
         MenuItem: ({children, onClick, ...props}) => (
@@ -79,7 +32,7 @@ jest.mock('@mui/material', () => {
             </div>
         ),
         Checkbox: ({checked, onChange, sx, ...props}) => (
-            <input type="checkbox" checked={checked} onChange={onChange} {...props}/>
+            <input type="checkbox" checked={checked} onChange={onChange} {...props} />
         ),
         IconButton: ({children, onClick, disabled, sx, ...props}) => (
             <button onClick={onClick} disabled={disabled} {...props}>{children}</button>
@@ -102,23 +55,23 @@ jest.mock('@mui/material', () => {
                 <div>
                     <label htmlFor={inputId}>{label}</label>
                     <input id={inputId} type="text" placeholder={label} value={value} onChange={onChange}
-                           disabled={disabled} {...(multiline ? {'data-multiline': true, rows} : {})} {...props}/>
+                           disabled={disabled} {...(multiline ? {'data-multiline': true, rows} : {})} {...props} />
                 </div>
             );
         },
         Input: ({type, onChange, disabled, ...props}) => (
-            <input type={type} onChange={onChange} disabled={disabled} {...props}/>
+            <input type={type} onChange={onChange} disabled={disabled} {...props} />
         ),
         CircularProgress: () => <div role="progressbar">Loading...</div>,
         Box: ({children, sx, ...props}) => <div {...props}>{children}</div>,
         Typography: ({children, sx, ...props}) => <span {...props}>{children}</span>,
-        FiberManualRecordIcon: ({sx, ...props}) => <svg {...props}/>,
+        FiberManualRecordIcon: ({sx, ...props}) => <svg {...props} />,
         Tooltip: ({children, title, ...props}) => <span {...props} title={title}>{children}</span>,
         Button: ({children, onClick, disabled, variant, component, htmlFor, sx, startIcon, ...props}) => (
             <button onClick={onClick} disabled={disabled} data-variant={variant}
                     {...(component === 'label' ? {htmlFor} : {})} {...props}>{children}</button>
         ),
-        Popper: ({open, anchorEl, children, ...props}) => open ? <div {...props}>{children}</div> : null,
+        Popper: ({open, anchorEl, children, ...props}) => (open ? <div {...props}>{children}</div> : null),
         Paper: ({elevation, children, ...props}) => <div {...props}>{children}</div>,
         ClickAwayListener: ({onClickAway, children, ...props}) => <div
             onClick={onClickAway} {...props}>{children}</div>,
@@ -133,12 +86,53 @@ jest.mock('@mui/icons-material/Edit', () => () => <span>Edit</span>);
 jest.mock('@mui/icons-material/AcUnit', () => () => <span>AcUnit</span>);
 jest.mock('@mui/icons-material/MoreVert', () => () => <span>MoreVertIcon</span>);
 
-const mockLocalStorage = {
-    getItem: jest.fn(() => 'mock-token'),
-    setItem: jest.fn(),
-    removeItem: jest.fn(),
-};
-Object.defineProperty(global, 'localStorage', {value: mockLocalStorage});
+jest.mock('react-router-dom', () => ({
+    ...jest.requireActual('react-router-dom'),
+    useParams: jest.fn(),
+    useNavigate: jest.fn(),
+}));
+jest.mock('../../hooks/useEventStore.js');
+jest.mock('../../eventSourceManager.jsx', () => ({
+    closeEventSource: jest.fn(),
+    startEventReception: jest.fn(),
+    clearEventBuffers: jest.fn(),
+    startLoggerReception: jest.fn(),
+    closeLoggerEventSource: jest.fn(),
+}));
+jest.mock('../../context/DarkModeContext', () => ({
+    useDarkMode: () => ({isDarkMode: false, toggleDarkMode: jest.fn()}),
+}));
+jest.mock('../../utils/logger', () => ({
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+}));
+
+jest.mock('../ConfigSection', () => ({
+    __esModule: true,
+    default: ({
+                  decodedObjectName,
+                  configNode,
+                  setConfigNode,
+                  openSnackbar,
+                  configDialogOpen,
+                  setConfigDialogOpen,
+                  configRefreshTrigger
+              }) => (
+        <div>
+            <button onClick={() => setConfigDialogOpen(true)} data-testid="open-config-dialog">
+                View Configuration
+            </button>
+            {configDialogOpen && (
+                <div role="dialog" data-testid="config-dialog">
+                    <div>Configuration for {decodedObjectName}</div>
+                    {configNode && <div>Node: {configNode}</div>}
+                </div>
+            )}
+        </div>
+    ),
+}));
 
 jest.mock('../../constants/actions', () => ({
     OBJECT_ACTIONS: [
@@ -166,37 +160,35 @@ jest.mock('../../constants/actions', () => ({
 }));
 
 jest.mock('../LogsViewer.jsx', () => ({nodename, height}) => (
-    <div data-testid="logs-viewer" data-nodename={nodename} style={{height}}>Logs Viewer Mock</div>
+    <div data-testid="logs-viewer" data-nodename={nodename} style={{height}}>
+        Logs Viewer Mock
+    </div>
 ));
 
-// ─── Shared helpers ───────────────────────────────────────────────────────────
+// ─── localStorage mock ─────────────────────────────────────────────────────
+const mockLocalStorage = {
+    getItem: jest.fn(() => 'mock-token'),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+};
+Object.defineProperty(global, 'localStorage', {value: mockLocalStorage});
 
 const buildState = (overrides = {}) => ({
     objectStatus: {'root/svc/svc1': {avail: 'up', frozen: null}},
     objectInstanceStatus: {
         'root/svc/svc1': {
             node1: {
-                avail: 'up', frozen_at: null,
+                avail: 'up',
+                frozen_at: null,
                 resources: {
-                    res1: {
-                        status: 'up',
-                        label: 'R1',
-                        type: 'disk',
-                        provisioned: {state: 'true'},
-                        running: true
-                    }
+                    res1: {status: 'up', label: 'R1', type: 'disk', provisioned: {state: 'true'}, running: true},
                 },
             },
             node2: {
-                avail: 'down', frozen_at: null,
+                avail: 'down',
+                frozen_at: null,
                 resources: {
-                    res2: {
-                        status: 'warn',
-                        label: 'R2',
-                        type: 'compute',
-                        provisioned: {state: 'true'},
-                        running: false
-                    }
+                    res2: {status: 'warn', label: 'R2', type: 'compute', provisioned: {state: 'true'}, running: false},
                 },
             },
         },
@@ -212,6 +204,9 @@ const buildState = (overrides = {}) => ({
     },
     configUpdates: [],
     clearConfigUpdate: jest.fn(),
+    removeObject: jest.fn(),
+    setObjectStatuses: jest.fn(),
+    setInstanceStatuses: jest.fn(),
     ...overrides,
 });
 
@@ -223,7 +218,8 @@ const fullMockState = {
     objectInstanceStatus: {
         'root/cfg/cfg1': {
             node1: {
-                avail: 'up', frozen_at: null,
+                avail: 'up',
+                frozen_at: null,
                 resources: {
                     res1: {
                         status: 'up',
@@ -242,7 +238,8 @@ const fullMockState = {
                 },
             },
             node2: {
-                avail: 'down', frozen_at: null,
+                avail: 'down',
+                frozen_at: null,
                 resources: {
                     res3: {
                         status: 'warn',
@@ -250,13 +247,14 @@ const fullMockState = {
                         type: 'compute',
                         provisioned: {state: 'true', mtime: '2023-01-01T12:00:00Z'},
                         running: false
-                    }
+                    },
                 },
             },
         },
         'root/svc/svc1': {
             node1: {
-                avail: 'up', frozen_at: null,
+                avail: 'up',
+                frozen_at: null,
                 resources: {
                     res1: {
                         status: 'up',
@@ -283,13 +281,14 @@ const fullMockState = {
                                 type: 'container',
                                 provisioned: {state: 'true', mtime: '2023-01-01T12:00:00Z'},
                                 running: true
-                            }
-                        }
+                            },
+                        },
                     },
                 },
             },
             node2: {
-                avail: 'down', frozen_at: null,
+                avail: 'down',
+                frozen_at: null,
                 resources: {
                     res3: {
                         status: 'warn',
@@ -297,7 +296,7 @@ const fullMockState = {
                         type: 'compute',
                         provisioned: {state: 'true', mtime: '2023-01-01T12:00:00Z'},
                         running: false
-                    }
+                    },
                 },
             },
         },
@@ -327,8 +326,12 @@ const fullMockState = {
     configUpdates: [],
     configNode: 'node1',
     clearConfigUpdate: jest.fn(),
+    removeObject: jest.fn(),
+    setObjectStatuses: jest.fn(),
+    setInstanceStatuses: jest.fn(),
 };
 
+// ─── Helpers ───────────────────────────────────────────────────────────────
 const renderComponent = (objectName) => {
     require('react-router-dom').useParams.mockReturnValue({objectName});
     return render(
@@ -341,31 +344,37 @@ const renderComponent = (objectName) => {
 };
 
 const renderSvc = (objectName = 'root/svc/svc1') => renderComponent(objectName);
+const waitForNode = async (nodeName) => screen.findByText(nodeName, {}, {timeout: 10000});
 
-const waitForObjectName = async (name = 'root/svc/svc1') =>
-    screen.findByText(new RegExp(name.replace(/\//g, '\\/'), 'i'), {}, {timeout: 10000});
+const renderReadySvc = async () => {
+    renderSvc();
+    await waitForNode('node1');
+    await waitForNode('node2');
+    return {node1: screen.getByText('node1'), node2: screen.getByText('node2')};
+};
 
-const waitForNode = async (nodeName) => screen.findByText(nodeName, {}, {timeout: 10000});
+const executeObjectAction = async (actionName) => {
+    await userEvent.click(screen.getByRole('button', {name: /object actions/i}));
+    await screen.findByRole('menu');
+    await userEvent.click(screen.getByRole('menuitem', {name: new RegExp(actionName, 'i')}));
+    const dialog = await screen.findByRole('dialog');
+    const confirmBtn = within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept/i});
+    await userEvent.click(confirmBtn);
+};
 
-const openLogsDrawer = async (user) => {
-    const logsButtons = screen.getAllByRole('button', {name: /logs/i});
-    const nodeLogsButton = logsButtons.find(b => b.textContent?.includes('Logs') && !b.textContent?.includes('Resource'))
-        || logsButtons[0];
-    if (!nodeLogsButton) return null;
-    await user.click(nodeLogsButton);
-    return nodeLogsButton;
+const mockNetworkFailure = (urlPattern) => {
+    global.fetch.mockImplementation((url, options) => {
+        if (url.includes(urlPattern)) return Promise.reject(new Error('Network error'));
+        return Promise.resolve({ok: true, text: () => Promise.resolve('')});
+    });
 };
 
-const withConsole = async (fn) => {
-    const {INSTANCE_ACTIONS} = require('../../constants/actions');
-    const orig = [...INSTANCE_ACTIONS];
-    INSTANCE_ACTIONS.push({name: 'console', icon: 'ConsoleIcon'});
-    try {
-        await fn();
-    } finally {
-        INSTANCE_ACTIONS.length = 0;
-        orig.forEach(a => INSTANCE_ACTIONS.push(a));
-    }
+const mockActionFailure = (status = 500, message = 'Server error') => {
+    global.fetch.mockImplementation((url, options) => {
+        if (options?.method === 'POST' && url.includes('/action/'))
+            return Promise.resolve({ok: false, status, text: () => Promise.resolve(message)});
+        return Promise.resolve({ok: true, text: () => Promise.resolve('')});
+    });
 };
 
 const openConsoleDialogFn = async () => {
@@ -377,13 +386,17 @@ const openConsoleDialogFn = async () => {
     if (consoleItems.length === 0) return null;
     await userEvent.click(consoleItems[0]);
     await waitFor(() => {
-        expect(screen.queryAllByRole('dialog').some(d =>
-            d.textContent.includes('terminal console') || d.textContent.includes('Open Console')
-        )).toBe(true);
+        expect(
+            screen.queryAllByRole('dialog').some(
+                (d) => d.textContent.includes('terminal console') || d.textContent.includes('Open Console')
+            )
+        ).toBe(true);
     }, {timeout: 5000});
-    return screen.queryAllByRole('dialog').find(d =>
-        d.textContent.includes('terminal console') || d.textContent.includes('Open Console')
-    ) || null;
+    return (
+        screen.queryAllByRole('dialog').find(
+            (d) => d.textContent.includes('terminal console') || d.textContent.includes('Open Console')
+        ) || null
+    );
 };
 
 const defaultFetchMock = (url, options) => {
@@ -391,11 +404,7 @@ const defaultFetchMock = (url, options) => {
         return Promise.resolve({
             ok: true, status: 200,
             json: () => Promise.resolve({
-                items: [{name: 'key1', node: 'node1', size: 2626}, {
-                    name: 'key2',
-                    node: 'node1',
-                    size: 6946
-                }]
+                items: [{name: 'key1', node: 'node1', size: 2626}, {name: 'key2', node: 'node1', size: 6946}]
             }),
             text: () => Promise.resolve(''),
         });
@@ -418,7 +427,7 @@ const defaultFetchMock = (url, options) => {
     if (url.includes('/console') && options?.method === 'POST') {
         return Promise.resolve({
             ok: true,
-            headers: {get: (h) => h === 'Location' ? 'http://console.example.com/session123' : null}
+            headers: {get: (h) => (h === 'Location' ? 'http://console.example.com/session123' : null)}
         });
     }
     if (options?.method === 'POST' && url.includes('/action/')) {
@@ -427,8 +436,7 @@ const defaultFetchMock = (url, options) => {
     return Promise.resolve({ok: true, status: 200, json: () => Promise.resolve({}), text: () => Promise.resolve('')});
 };
 
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
+// ─── Tests ─────────────────────────────────────────────────────────────────
 describe('ObjectDetail Component', () => {
     const user = userEvent.setup();
     const mockNavigate = jest.fn();
@@ -439,304 +447,137 @@ describe('ObjectDetail Component', () => {
         require('react-router-dom').useNavigate.mockReturnValue(mockNavigate);
         mockLocalStorage.getItem.mockReturnValue('mock-token');
         global.fetch = jest.fn(defaultFetchMock);
+
         useEventStore.mockImplementation((selector) => selector(fullMockState));
+        useEventStore.getState = jest.fn().mockReturnValue(fullMockState);
         useEventStore.subscribe = jest.fn(() => jest.fn());
     });
 
     afterEach(() => jest.clearAllMocks());
 
-    // ── Pure unit tests ────────────────────────────────────────────────────────
-
     describe('getResourceType', () => {
-        test('returns empty for null/empty/missing inputs', () => {
-            expect(getResourceType(null, {})).toBe('');
-            expect(getResourceType('', {})).toBe('');
-            expect(getResourceType('rid1', null)).toBe('');
-            expect(getResourceType('rid1', undefined)).toBe('');
-            expect(getResourceType(null, null)).toBe('');
-            expect(getResourceType(undefined, undefined)).toBe('');
-            expect(getResourceType('notfound', {resources: {}, encap: {c1: {resources: {}}}})).toBe('');
-            expect(getResourceType('rid1', {resources: {}, encap: {}})).toBe('');
-        });
-
-        test('returns top-level resource type', () => {
-            const nodeData = {resources: {rid1: {type: 'disk.disk'}, rid2: {type: 'fs.flag'}}};
-            expect(getResourceType('rid1', nodeData)).toBe('disk.disk');
-            expect(getResourceType('rid2', nodeData)).toBe('fs.flag');
-        });
-
-        test('searches encap containers when top-level missing', () => {
-            const nodeData = {
+        test.each([
+            [null, {}, ''], ['', {}, ''], ['rid1', null, ''], ['rid1', undefined, ''], [null, null, ''], [undefined, undefined, ''],
+            ['notfound', {resources: {}, encap: {c1: {resources: {}}}}, ''],
+            ['rid1', {resources: {}, encap: {}}, ''],
+            ['rid1', {resources: {rid1: {type: 'disk.disk'}}}, 'disk.disk'],
+            ['rid2', {resources: {rid2: {type: 'fs.flag'}}}, 'fs.flag'],
+            ['rid2', {
                 resources: {},
                 encap: {container1: {resources: {rid2: {type: 'container.docker'}}}}
-            };
-            expect(getResourceType('rid2', nodeData)).toBe('container.docker');
-        });
-
-        test('returns empty when rid not found anywhere', () => {
-            const nodeData = {
-                resources: {r1: {type: 'disk'}},
-                encap: {c1: {resources: {r2: {type: 'container'}}}}
-            };
-            expect(getResourceType('r3', nodeData)).toBe('');
-        });
+            }, 'container.docker'],
+            ['r3', {resources: {r1: {type: 'disk'}}, encap: {c1: {resources: {r2: {type: 'container'}}}}}, ''],
+        ])('getResourceType(%p, %p) => %p', (rid, nodeData, expected) => expect(getResourceType(rid, nodeData)).toBe(expected));
     });
 
     describe('parseProvisionedState', () => {
-        test('handles string "true" variants (case-insensitive)', () => {
-            ['true', 'True', 'TRUE', 'tRuE'].forEach(v => expect(parseProvisionedState(v)).toBe(true));
-        });
-
-        test('handles string "false" variants (case-insensitive)', () => {
-            ['false', 'False', 'FALSE', 'fAlSe'].forEach(v => expect(parseProvisionedState(v)).toBe(false));
-        });
-
-        test('treats non-boolean strings as false', () => {
-            ['yes', 'no', '', 'abc', '1', '0'].forEach(v => expect(parseProvisionedState(v)).toBe(false));
-        });
-
-        test('coerces non-string values correctly', () => {
-            expect(parseProvisionedState(true)).toBe(true);
-            expect(parseProvisionedState(false)).toBe(false);
-            expect(parseProvisionedState(1)).toBe(true);
-            expect(parseProvisionedState(0)).toBe(false);
-            expect(parseProvisionedState(42)).toBe(true);
-            expect(parseProvisionedState(-1)).toBe(true);
-            expect(parseProvisionedState({})).toBe(true);
-            expect(parseProvisionedState({state: true})).toBe(true);
-            expect(parseProvisionedState([])).toBe(true);
-            expect(parseProvisionedState(new Date())).toBe(true);
-            expect(parseProvisionedState(null)).toBe(false);
-            expect(parseProvisionedState(undefined)).toBe(false);
-            expect(parseProvisionedState(NaN)).toBe(false);
-        });
+        test.each([
+            ['true', true], ['True', true], ['TRUE', true], ['tRuE', true],
+            ['false', false], ['False', false], ['FALSE', false], ['fAlSe', false],
+            ['yes', false], ['no', false], ['', false], ['abc', false], ['1', false], ['0', false],
+            [true, true], [false, false], [1, true], [0, false], [42, true], [-1, true],
+            [{}, true], [{state: true}, true], [[], true], [new Date(), true],
+            [null, false], [undefined, false], [NaN, false],
+        ])('%p => %p', (input, expected) => expect(parseProvisionedState(input)).toBe(expected));
     });
 
-    // ── Mount/unmount lifecycle ────────────────────────────────────────────────
-
-    test('calls startEventReception on mount', () => {
-        renderComponent('root/cfg/cfg1');
-        expect(localStorage.getItem).toHaveBeenCalledWith('authToken');
-        expect(startEventReception).toHaveBeenCalledWith('mock-token', [
-            "ObjectStatusUpdated,path=root/cfg/cfg1",
-            "InstanceStatusUpdated,path=root/cfg/cfg1",
-            "ObjectDeleted,path=root/cfg/cfg1",
-            "InstanceMonitorUpdated,path=root/cfg/cfg1",
-            "InstanceConfigUpdated,path=root/cfg/cfg1",
-            "CONNECTION_OPENED", "CONNECTION_ERROR", "RECONNECTION_ATTEMPT",
-            "MAX_RECONNECTIONS_REACHED", "CONNECTION_CLOSED"
-        ]);
-    });
-
-    test('calls closeEventSource on unmount', () => {
+    test('mount/unmount lifecycle', () => {
         const {unmount} = renderComponent('root/cfg/cfg1');
+        expect(localStorage.getItem).toHaveBeenCalledWith('authToken');
+        expect(startEventReception).toHaveBeenCalled();
         unmount();
         expect(closeEventSource).toHaveBeenCalled();
     });
 
-    test('handles component unmount during async operations gracefully', async () => {
-        let resolveFetch;
-        global.fetch.mockImplementationOnce(() => new Promise(r => {
-            resolveFetch = r;
-        }));
-        const {unmount} = renderSvc();
-        unmount();
-        resolveFetch({ok: true, text: () => Promise.resolve('config data')});
-        await new Promise(r => setTimeout(r, 100));
-    });
-
-    // ── Rendering ─────────────────────────────────────────────────────────────
-
-    test('renders object name in mock component', async () => {
-        require('react-router-dom').useParams.mockReturnValue({objectName: 'root/cfg/cfg1'});
-        const MockObjectDetail = () => {
-            const {useParams} = require('react-router-dom');
-            const {objectName} = useParams();
-            return (
-                <div>
-                    <span>{decodeURIComponent(objectName)}</span>
-                    <span>No information available for object</span>
-                </div>
-            );
-        };
-        render(
-            <MemoryRouter initialEntries={['/object/root%2Fcfg%2Fcfg1']}>
-                <Routes><Route path="/object/:objectName" element={<MockObjectDetail/>}/></Routes>
-            </MemoryRouter>
-        );
-        await waitFor(() => expect(screen.getByText(/root\/cfg\/cfg1/)).toBeInTheDocument());
-        await waitFor(() => expect(screen.getByText(/No information available for object/i)).toBeInTheDocument());
-    }, 10000);
-
-    test('renders nodes and monitor state for svc kind', async () => {
+    test('renders svc with nodes and monitor', async () => {
         renderSvc();
-        const objectNames = await screen.findAllByText(/root\/svc\/svc1/i);
-        expect(objectNames.length).toBeGreaterThan(0);
-        await waitFor(() => expect(screen.getByText('node1')).toBeInTheDocument(), {timeout: 10000});
-        await waitFor(() => expect(screen.getByText('node2')).toBeInTheDocument(), {timeout: 10000});
-        await waitFor(() => expect(screen.getByText(/running/i)).toBeInTheDocument(), {timeout: 10000});
-        await waitFor(() => expect(screen.getByText(/placed@node1/i)).toBeInTheDocument(), {timeout: 10000});
+        await waitForNode('node1');
+        await waitForNode('node2');
+        expect(screen.getByText(/running/i)).toBeInTheDocument();
+        expect(screen.getByText(/placed@node1/i)).toBeInTheDocument();
         expect(screen.queryByText(/Resources \(\d+\)/i)).not.toBeInTheDocument();
-    }, 15000);
-
-    test('shows loading state then resolves', async () => {
-        renderComponent('root/cfg/cfg1');
-        // Loading may appear briefly for cfg kind with empty state - just verify body has content
-        await waitFor(() => expect(document.body.textContent).toBeTruthy(), {timeout: 5000});
     });
 
     test('shows no data message when object data is empty', async () => {
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {}, objectInstanceStatus: {}, instanceMonitor: {},
-            instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
-        renderComponent('root/cfg/cfg1');
-        await waitFor(() => {
-            const noInfo = screen.queryByText(/No information available for object\./i);
-            if (noInfo) {
-                expect(noInfo).toBeInTheDocument();
-                expect(screen.queryByTestId('open-config-dialog')).toBeInTheDocument();
-            } else {
-                expect(document.body.textContent).toBeTruthy();
-            }
-        }, {timeout: 5000});
-    });
-
-    test('does not render node cards or batch actions for cfg kind', async () => {
-        renderComponent('root/cfg/cfg1');
-        await screen.findByText(/root\/cfg\/cfg1/i, {selector: 'span[font-weight="bold"]'});
-        await waitFor(() => {
-            expect(document.querySelectorAll('[class*="MuiCard"], [role="region"][class*="node"]')).toHaveLength(0);
-            expect(screen.queryByRole('button', {name: /Actions on Selected Nodes/i})).not.toBeInTheDocument();
-        }, {timeout: 10000});
-    }, 15000);
-
-    test('does not render batch actions for sec and usr kinds', async () => {
-        for (const [path, objectName] of [['root/sec/sec1', 'root/sec/sec1'], ['root/usr/usr1', 'root/usr/usr1']]) {
-            jest.clearAllMocks();
-            useEventStore.mockImplementation(s => s({
-                objectStatus: {[objectName]: {avail: 'up', frozen: null}},
-                objectInstanceStatus: {[objectName]: {node1: {avail: 'up', resources: {}}}},
-                instanceMonitor: {}, instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-            }));
-            renderComponent(objectName);
-            await waitFor(() => expect(screen.getByText(new RegExp(objectName.replace(/\//g, '\\/'), 'i'))).toBeInTheDocument(), {timeout: 5000});
-            await waitFor(() => expect(screen.queryByRole('button', {name: /Actions on Selected Nodes/i})).not.toBeInTheDocument(), {timeout: 5000});
-        }
-    });
-
-    test('displays warn status color for object', async () => {
-        const warnState = buildState();
-        warnState.objectStatus['root/svc/svc1'].avail = 'warn';
-        useEventStore.mockImplementation(s => s(warnState));
-        renderSvc();
-        await waitFor(() => expect(screen.getByTitle('warn')).toBeInTheDocument());
-    });
-
-    // ── Config fetch ───────────────────────────────────────────────────────────
-
-    test('fetches config on mount and opens config dialog', async () => {
-        renderComponent('root/cfg/cfg1');
-        const configButton = await screen.findByTestId('open-config-dialog');
-        fireEvent.click(configButton);
-        await waitFor(() => expect(screen.getByTestId('config-dialog')).toBeInTheDocument(), {timeout: 10000});
-        expect(global.fetch).toHaveBeenCalledWith(
-            expect.stringContaining('/api/node/name/node1/instance/path/root/cfg/cfg1/config/file'),
-            expect.any(Object)
-        );
-    }, 15000);
-
-    test('fetches config from first node for svc kind', async () => {
-        renderSvc();
-        const configButton = await screen.findByTestId('open-config-dialog');
-        fireEvent.click(configButton);
-        await waitFor(() => expect(screen.getByTestId('config-dialog')).toBeInTheDocument(), {timeout: 5000});
-        await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
-            expect.stringContaining('/api/node/name/node1/instance/path/root/svc/svc1/config/file'),
-            expect.any(Object)
-        ), {timeout: 5000});
-    }, 10000);
-
+        const emptyState = {
+            objectStatus: {},
+            objectInstanceStatus: {
+                'root/cfg/cfg1': {}
+            },
+            instanceMonitor: {},
+            instanceConfig: {},
+            configUpdates: [],
+            clearConfigUpdate: jest.fn(),
+            removeObject: jest.fn(),
+            setObjectStatuses: jest.fn(),
+            setInstanceStatuses: jest.fn(),
+        };
+        useEventStore.mockImplementation(s => s(emptyState));
+        useEventStore.getState.mockReturnValue(emptyState);
 
-    test('handles fetchConfig HTTP error response', async () => {
         global.fetch.mockImplementation((url) => {
-            if (url.includes('/config/file')) {
-                return Promise.resolve({
-                    ok: false,
-                    status: 500,
-                    statusText: 'Internal Server Error',
-                    text: () => Promise.resolve('Internal Server Error')
-                });
-            }
-            return Promise.resolve({
+            if (url.includes('/data/keys')) return Promise.resolve({
                 ok: true,
-                text: () => Promise.resolve(''),
                 json: () => Promise.resolve({items: []})
             });
+            return Promise.resolve({ok: true, json: () => Promise.resolve({}), text: () => ''});
         });
-        renderSvc();
-        await waitForObjectName();
+        renderComponent('root/cfg/cfg1');
         await waitFor(() => {
-            const errorText = screen.queryByText(/Failed to fetch config: HTTP error! status: 500/i);
-            if (errorText) expect(errorText).toBeInTheDocument();
-            else expect(screen.getByText(/root\/svc\/svc1/i)).toBeInTheDocument();
-        }, {timeout: 5000});
+            expect(screen.getByText(/No keys available/i)).toBeInTheDocument();
+        });
     });
 
-    test('handles fetchConfig with no auth token', async () => {
-        mockLocalStorage.getItem.mockReturnValue(null);
-        renderSvc();
-        await waitForObjectName();
+    test('cfg kind hides node cards and batch actions', async () => {
+        renderComponent('root/cfg/cfg1');
+        await screen.findByText(/root\/cfg\/cfg1/i);
         await waitFor(() => {
-            const errorText = screen.queryByText(/Auth token not found/i);
-            if (errorText) expect(errorText).toBeInTheDocument();
-            else expect(screen.getByText(/root\/svc\/svc1/i)).toBeInTheDocument();
-        }, {timeout: 5000});
+            expect(document.querySelectorAll('[class*="MuiCard"], [role="region"][class*="node"]')).toHaveLength(0);
+            expect(screen.queryByRole('button', {name: /Actions on Selected Nodes/i})).not.toBeInTheDocument();
+        });
     });
 
-    test('loads initial config when node has encap resources', async () => {
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {'root/svc/svc1': {avail: 'up', frozen: null}},
-            objectInstanceStatus: {
-                'root/svc/svc1': {
-                    node1: {
-                        avail: 'up',
-                        frozen_at: null,
-                        resources: {},
-                        encap: {container1: {resources: {res1: {type: 'container.docker', status: 'up'}}}}
-                    },
-                    node2: {avail: 'up', frozen_at: null, resources: {}},
-                },
-            },
-            instanceMonitor: {}, instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
-        renderSvc();
-        await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
-            expect.stringContaining('/api/node/name/node1/instance/path/root/svc/svc1/config/file'),
-            expect.any(Object)
-        ));
+    test.each([['root/sec/sec1'], ['root/usr/usr1']])('batch actions hidden for %s', async (objectName) => {
+        const testState = {
+            objectStatus: {[objectName]: {avail: 'up', frozen: null}},
+            objectInstanceStatus: {[objectName]: {node1: {avail: 'up', resources: {}}}},
+            instanceMonitor: {}, instanceConfig: {}, configUpdates: [],
+            clearConfigUpdate: jest.fn(),
+            removeObject: jest.fn(),
+            setObjectStatuses: jest.fn(),
+            setInstanceStatuses: jest.fn(),
+        };
+        useEventStore.mockImplementation(s => s(testState));
+        useEventStore.getState.mockReturnValue(testState);
+
+        renderComponent(objectName);
+        await screen.findByText(new RegExp(objectName.replace(/\//g, '\\/'), 'i'));
+        expect(screen.queryByRole('button', {name: /Actions on Selected Nodes/i})).not.toBeInTheDocument();
     });
 
-    test('handles fetchConfig with no nodes available', async () => {
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {'root/svc/svc1': {avail: 'up', frozen: null}},
-            objectInstanceStatus: {'root/svc/svc1': {}},
-            instanceMonitor: {}, instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
+    test('warn status color', async () => {
+        const state = buildState();
+        state.objectStatus['root/svc/svc1'].avail = 'warn';
+        useEventStore.mockImplementation(s => s(state));
+        useEventStore.getState.mockReturnValue(state);
         renderSvc();
-        await waitFor(() => expect(screen.getAllByText(/root\/svc\/svc1/i).length).toBeGreaterThan(0));
+        await waitFor(() => expect(screen.getByTitle('warn')).toBeInTheDocument());
     });
 
-    // ── Keys section ───────────────────────────────────────────────────────────
+    test('config dialog opens when button clicked', async () => {
+        renderComponent('root/cfg/cfg1');
+        fireEvent.click(await screen.findByTestId('open-config-dialog'));
+        await waitFor(() => expect(screen.getByTestId('config-dialog')).toBeInTheDocument());
+    });
 
-    test('renders keys section for cfg kind', async () => {
+    test('renders keys section for cfg', async () => {
         renderComponent('root/cfg/cfg1');
-        await waitFor(() => expect(screen.getByText(/Keys/i)).toBeInTheDocument(), {timeout: 5000});
-        await waitFor(() => expect(screen.getByText('key1')).toBeInTheDocument(), {timeout: 5000});
-        await waitFor(() => expect(screen.getByText('key2')).toBeInTheDocument(), {timeout: 5000});
-    }, 10000);
+        expect(await screen.findByText(/Keys/i)).toBeInTheDocument();
+        expect(await screen.findByText('key1')).toBeInTheDocument();
+        expect(screen.getByText('key2')).toBeInTheDocument();
+    });
 
-    test('displays no keys message when keys array is empty', async () => {
+    test('displays no keys message when empty', async () => {
         global.fetch.mockImplementation((url) => {
             if (url.includes('/data/keys')) return Promise.resolve({
                 ok: true,
@@ -745,39 +586,32 @@ describe('ObjectDetail Component', () => {
             return Promise.resolve({ok: true, text: () => Promise.resolve(''), json: () => Promise.resolve({})});
         });
         renderComponent('root/cfg/cfg1');
-        await waitFor(() => expect(screen.getByText(/No keys available/i)).toBeInTheDocument(), {timeout: 5000});
+        expect(await screen.findByText(/No keys available/i)).toBeInTheDocument();
     });
 
-    // ── Node interactions ──────────────────────────────────────────────────────
-
-    test('handles node selection toggle (checkbox)', async () => {
-        renderSvc();
-        await waitForNode('node1');
-        const node1Checkbox = screen.getByLabelText(/select node node1/i);
-        expect(node1Checkbox.checked).toBe(false);
-        await user.click(node1Checkbox);
-        expect(node1Checkbox.checked).toBe(true);
-        await user.click(node1Checkbox);
-        expect(node1Checkbox.checked).toBe(false);
+    test('node selection toggle', async () => {
+        await renderReadySvc();
+        const checkbox = screen.getByLabelText(/select node node1/i);
+        expect(checkbox.checked).toBe(false);
+        await user.click(checkbox);
+        expect(checkbox.checked).toBe(true);
+        await user.click(checkbox);
+        expect(checkbox.checked).toBe(false);
     });
 
     test('disables batch actions button when no nodes are selected', async () => {
-        renderSvc();
-        await waitForNode('node1');
+        await renderReadySvc();
         expect(screen.getByRole('button', {name: /Actions on selected nodes/i}).disabled).toBe(true);
     });
 
-    test('handles view instance navigation on node click', async () => {
-        renderSvc();
-        await waitForNode('node1');
-        const nodeText = screen.getByText('node1');
-        const card = nodeText.closest('div[role="region"]') || nodeText.closest('div');
-        fireEvent.click(card || nodeText);
-        await waitFor(() => expect(mockNavigate).toHaveBeenCalledWith('/nodes/node1/objects/root%2Fsvc%2Fsvc1'), {timeout: 5000});
+    test('view instance navigation on node click', async () => {
+        await renderReadySvc();
+        fireEvent.click(screen.getByText('node1'));
+        await waitFor(() => expect(mockNavigate).toHaveBeenCalledWith('/nodes/node1/objects/root%2Fsvc%2Fsvc1'));
     });
 
-    test('handles getNodeState with frozen node', async () => {
-        useEventStore.mockImplementation(s => s({
+    test('frozen node state display', async () => {
+        const frozenState = {
             objectStatus: {'root/svc/svc1': {avail: 'up', frozen: null}},
             objectInstanceStatus: {
                 'root/svc/svc1': {
@@ -789,247 +623,169 @@ describe('ObjectDetail Component', () => {
                 }
             },
             instanceMonitor: {'node1:root/svc/svc1': {state: 'running', global_expect: 'placed@node1', resources: {}}},
-            instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
-        renderSvc();
-        await waitFor(() => expect(screen.getByText('node1')).toBeInTheDocument(), {timeout: 10000});
-    });
-
-    test('handles getObjectStatus with global_expect on second node', async () => {
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {'root/svc/svc1': {avail: 'up', frozen: null}},
-            objectInstanceStatus: {
-                'root/svc/svc1': {
-                    node1: {avail: 'up', resources: {}},
-                    node2: {avail: 'down', resources: {}}
-                }
-            },
-            instanceMonitor: {
-                'node1:root/svc/svc1': {state: 'idle', global_expect: 'none'},
-                'node2:root/svc/svc1': {state: 'running', global_expect: 'placed@node2'},
-            },
-            instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
+            instanceConfig: {}, configUpdates: [],
+            clearConfigUpdate: jest.fn(),
+            removeObject: jest.fn(),
+            setObjectStatuses: jest.fn(),
+            setInstanceStatuses: jest.fn(),
+        };
+        useEventStore.mockImplementation(s => s(frozenState));
+        useEventStore.getState.mockReturnValue(frozenState);
         renderSvc();
-        await waitFor(() => expect(screen.queryAllByText(/node/).length).toBeGreaterThan(0), {timeout: 10000});
+        await waitForNode('node1');
     });
 
     test('getObjectStatus handles missing global_expect (none)', async () => {
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {}, objectInstanceStatus: {},
+        const state = {
+            objectStatus: {},
+            objectInstanceStatus: {},
             instanceMonitor: {'node1:root/cfg/cfg1': {state: 'running', global_expect: 'none'}},
-            instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
+            instanceConfig: {}, configUpdates: [],
+            clearConfigUpdate: jest.fn(),
+            removeObject: jest.fn(),
+            setObjectStatuses: jest.fn(),
+            setInstanceStatuses: jest.fn(),
+        };
+        useEventStore.mockImplementation(s => s(state));
+        useEventStore.getState.mockReturnValue(state);
         renderComponent('root/cfg/cfg1');
-        await waitFor(() => expect(screen.queryByText(/placed@node1/i)).not.toBeInTheDocument(), {timeout: 10000});
-    }, 15000);
-
-    // ── Batch node actions ─────────────────────────────────────────────────────
-
-    test('handles batch node actions: select nodes and execute start', async () => {
-        renderSvc();
-        await waitFor(() => expect(screen.getByText('node1')).toBeInTheDocument(), {timeout: 15000});
-        await waitFor(() => expect(screen.getByText('node2')).toBeInTheDocument(), {timeout: 15000});
+        await waitFor(() => expect(screen.queryByText(/placed@node1/i)).not.toBeInTheDocument());
+    });
 
+    test('batch node actions: select nodes and execute start', async () => {
+        await renderReadySvc();
         await user.click(screen.getByLabelText(/select node node1/i));
         await user.click(screen.getByLabelText(/select node node2/i));
-
         const batchBtn = screen.getByRole('button', {name: /Actions on selected nodes/i});
         expect(batchBtn).not.toBeDisabled();
         await user.click(batchBtn);
-
-        await waitFor(() => expect(screen.queryAllByRole('menu').length).toBeGreaterThan(0), {timeout: 10000});
-        const menus = await screen.findAllByRole('menu');
-        const startAction = within(menus[0]).getAllByRole('menuitem').find(i => i.textContent.match(/Start/i));
-        await user.click(startAction);
-
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument(), {timeout: 10000});
-        const dialog = screen.getAllByRole('dialog')[0];
-        const checkbox = within(dialog).queryByRole('checkbox', {name: /confirm/i});
-        if (checkbox) await user.click(checkbox);
-        await user.click(within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept|add/i}));
-
-        await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
-            expect.stringContaining('/api/node/name/node1/instance/path/root/svc/svc1/action/start'),
-            expect.objectContaining({
-                method: 'POST',
-                headers: expect.objectContaining({Authorization: 'Bearer mock-token'})
-            })
-        ), {timeout: 20000});
-    }, 35000);
+        await waitFor(() => expect(screen.queryAllByRole('menu').length).toBeGreaterThan(0));
+        const menu = screen.getAllByRole('menu')[0];
+        await user.click(within(menu).getByRole('menuitem', {name: /start/i}));
+        const dialog = await screen.findByRole('dialog');
+        const confirmCheckbox = within(dialog).queryByRole('checkbox', {name: /confirm/i});
+        if (confirmCheckbox) await user.click(confirmCheckbox);
+        await user.click(within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept/i}));
+        await waitFor(() => {
+            expect(global.fetch).toHaveBeenCalledWith(
+                expect.stringMatching(/\/api\/node\/name\/node1\/instance\/path\/root(%2F|\/)svc(%2F|\/)svc1\/action\/start/),
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: expect.objectContaining({Authorization: 'Bearer mock-token'})
+                })
+            );
+        });
+    });
 
     test('batch actions menu closes after item click', async () => {
-        renderSvc();
-        await waitForNode('node1');
+        await renderReadySvc();
         await user.click(screen.getByLabelText(/select node node1/i));
         await user.click(screen.getByRole('button', {name: /Actions on selected nodes/i}));
-        await waitFor(() => expect(screen.queryAllByRole('menu').length).toBeGreaterThan(0), {timeout: 5000});
-        const menus = screen.getAllByRole('menu');
-        await user.click(within(menus[0]).getAllByRole('menuitem')[0]);
+        await waitFor(() => expect(screen.queryAllByRole('menu').length).toBeGreaterThan(0));
+        await user.click(within(screen.getAllByRole('menu')[0]).getAllByRole('menuitem')[0]);
         await waitFor(() => {
             const dialogs = screen.queryAllByRole('dialog');
             const menusAfter = screen.queryAllByRole('menu');
             expect(dialogs.length > 0 || menusAfter.length === 0).toBe(true);
-        }, {timeout: 5000});
+        });
     });
 
-    // ── Individual node actions ────────────────────────────────────────────────
-
-    test('handles individual node stop action', async () => {
-        renderSvc();
-        await waitFor(() => expect(screen.getByText('node1')).toBeInTheDocument(), {timeout: 10000});
-
+    test('individual node stop action', async () => {
+        await renderReadySvc();
         await user.click(screen.getByRole('button', {name: /Node node1 actions/i}));
-        await waitFor(() => expect(screen.queryAllByRole('menu').length).toBeGreaterThan(0), {timeout: 10000});
-
-        const menus = await screen.findAllByRole('menu');
-        await user.click(within(menus[0]).getAllByRole('menuitem').find(i => i.textContent.match(/Stop/i)));
-
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument(), {timeout: 10000});
-        const dialog = screen.getAllByRole('dialog')[0];
-        const checkbox = within(dialog).queryByRole('checkbox', {name: /confirm/i});
-        if (checkbox) await user.click(checkbox);
-        await user.click(within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept|add/i}));
-
-        await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
-            expect.stringContaining('/api/node/name/node1/instance/path/root/svc/svc1/action/stop'),
-            expect.objectContaining({
-                method: 'POST',
-                headers: expect.objectContaining({Authorization: 'Bearer mock-token'})
-            })
-        ), {timeout: 20000});
-    }, 35000);
-
-    test('handles post action with no token (node action)', async () => {
-        mockLocalStorage.getItem.mockReturnValue(null);
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getAllByRole('button', {name: /Node node1 actions/i})[0]);
-        const menus = await screen.findAllByRole('menu');
-        await user.click(within(menus[0]).getByRole('menuitem', {name: /Start/i}));
+        await waitFor(() => expect(screen.queryAllByRole('menu').length).toBeGreaterThan(0));
+        const menu = screen.getAllByRole('menu')[0];
+        await user.click(within(menu).getByRole('menuitem', {name: /stop/i}));
         const dialog = await screen.findByRole('dialog');
-        await user.click(within(dialog).getByRole('button', {name: /confirm/i}));
-        await waitFor(() => {
-            const alerts = screen.getAllByRole('alert');
-            expect(alerts.find(a => a.textContent.includes('Auth token not found'))).toBeInTheDocument();
-        });
-    }, 15000);
-
-    // ── Object-level actions ───────────────────────────────────────────────────
-
-    test('postObjectAction: handles no token', async () => {
-        mockLocalStorage.getItem.mockReturnValue(null);
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /object actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-        await user.click(screen.getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
+        const confirmCheckbox = within(dialog).queryByRole('checkbox', {name: /confirm/i});
+        if (confirmCheckbox) await user.click(confirmCheckbox);
+        await user.click(within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept/i}));
         await waitFor(() => {
-            const alerts = screen.queryAllByRole('alert');
-            expect(alerts.length).toBeGreaterThan(0);
-            expect(alerts.find(a => a.textContent.includes('Auth token not found'))).toBeInTheDocument();
-        });
-    });
-
-    test('postObjectAction: handles non-ok HTTP response', async () => {
-        global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/action/')) {
-                return Promise.resolve({ok: false, status: 403, text: () => Promise.resolve('Forbidden')});
-            }
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
+            expect(global.fetch).toHaveBeenCalledWith(
+                expect.stringMatching(/\/api\/node\/name\/node1\/instance\/path\/root(%2F|\/)svc(%2F|\/)svc1\/action\/stop/),
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: expect.objectContaining({Authorization: 'Bearer mock-token'})
+                })
+            );
         });
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /object actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-        await user.click(screen.getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
-        await waitFor(() => {
-            expect(screen.getAllByRole('alert').find(a => a.textContent.includes('HTTP error! status: 403'))).toBeInTheDocument();
-        }, {timeout: 5000});
     });
 
-    test('postObjectAction: handles fetch exception', async () => {
-        global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/action/')) return Promise.reject(new Error('Network error'));
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
+    describe.each([
+        {
+            label: 'object',
+            openMenu: async () => {
+                await userEvent.click(screen.getByRole('button', {name: /object actions/i}));
+            },
+        },
+        {
+            label: 'node',
+            openMenu: async () => {
+                await userEvent.click(screen.getByRole('button', {name: /Node node1 actions/i}));
+            },
+        },
+    ])('$label actions', ({openMenu}) => {
+        test('fetch exception', async () => {
+            mockNetworkFailure('/action/');
+            await renderReadySvc();
+            await openMenu();
+            await userEvent.click(screen.getByRole('menuitem', {name: /start/i}));
+            const dialog = await screen.findByRole('dialog');
+            await userEvent.click(within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept/i}));
+            await waitFor(() => {
+                expect(screen.getAllByRole('alert').some(a => a.textContent.includes('Network error'))).toBe(true);
+            });
         });
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /object actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-        await user.click(screen.getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
-        await waitFor(() => {
-            expect(screen.getAllByRole('alert').find(a => a.textContent.includes('Network error'))).toBeInTheDocument();
-        }, {timeout: 5000});
-    });
 
-    test('postNodeAction: handles non-ok HTTP response', async () => {
-        global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/action/')) {
-                return Promise.resolve({ok: false, status: 500, text: () => Promise.resolve('Server error')});
-            }
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
+        test.each([[403, 'Forbidden'], [500, 'Server error']])('HTTP %i', async (status, msg) => {
+            mockActionFailure(status, msg);
+            await renderReadySvc();
+            await openMenu();
+            await userEvent.click(screen.getByRole('menuitem', {name: /start/i}));
+            const dialog = await screen.findByRole('dialog');
+            await userEvent.click(within(dialog).getByRole('button', {name: /confirm|submit|ok|execute|apply|proceed|accept/i}));
+            await waitFor(() => {
+                expect(screen.getAllByRole('alert').some(a => a.textContent.includes(`HTTP error! status: ${status}`))).toBe(true);
+            });
         });
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /node node1 actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('menu')).getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
-        await waitFor(() => {
-            expect(screen.getAllByRole('alert').find(a => a.textContent.includes('HTTP error! status: 500'))).toBeInTheDocument();
-        }, {timeout: 5000});
-    });
 
-    test('postNodeAction: handles fetch exception', async () => {
-        global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/action/')) return Promise.reject(new Error('Network error'));
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
+        test('missing auth token', async () => {
+            mockLocalStorage.getItem.mockReturnValue(null);
+            await renderReadySvc();
+            await openMenu();
+            await userEvent.click(screen.getByRole('menuitem', {name: /start/i}));
+            const dialog = await screen.findByRole('dialog');
+            await userEvent.click(within(dialog).getByRole('button', {name: /confirm/i}));
+            await waitFor(() => {
+                expect(screen.getAllByRole('alert').some(a => a.textContent.includes('Auth token not found'))).toBe(true);
+            });
         });
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /node node1 actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('menu')).getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
-        await waitFor(() => {
-            expect(screen.getAllByRole('alert').find(a => a.textContent.includes('Network error'))).toBeInTheDocument();
-        }, {timeout: 5000});
     });
 
-    // ── Dialog interactions ────────────────────────────────────────────────────
-
     test('dialog cancel closes without action', async () => {
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /object actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument(), {timeout: 5000});
-        await user.click(within(screen.getAllByRole('menu')[0]).getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument(), {timeout: 5000});
-        const cancelButton = within(screen.getByRole('dialog')).queryByRole('button', {name: /cancel/i});
+        await renderReadySvc();
+        await userEvent.click(screen.getByRole('button', {name: /object actions/i}));
+        await screen.findByRole('menu');
+        await userEvent.click(screen.getByRole('menuitem', {name: /start/i}));
+        const dialog = await screen.findByRole('dialog');
+        const cancelButton = within(dialog).queryByRole('button', {name: /cancel/i});
         if (cancelButton) {
-            await user.click(cancelButton);
-            await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument(), {timeout: 5000});
+            await userEvent.click(cancelButton);
+            await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
         }
     });
 
-    test('all object action dialogs (freeze/stop/unprovision/purge) open and cancel', async () => {
-        useEventStore.mockImplementation(s => s(buildState()));
+    test('all object action dialogs open and cancel', async () => {
+        const state = buildState();
+        useEventStore.mockImplementation(s => s(state));
+        useEventStore.getState.mockReturnValue(state);
         renderSvc();
         for (const action of ['freeze', 'stop', 'unprovision', 'purge']) {
             await user.click(screen.getByRole('button', {name: /object actions/i}));
-            await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
+            await screen.findByRole('menu');
             await user.click(screen.getByRole('menuitem', {name: new RegExp(action, 'i')}));
-            await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-            const cancelBtn = within(screen.getByRole('dialog')).queryByRole('button', {name: /cancel/i});
+            const dialog = await screen.findByRole('dialog');
+            const cancelBtn = within(dialog).queryByRole('button', {name: /cancel/i});
             if (cancelBtn) {
                 await user.click(cancelBtn);
                 await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
@@ -1043,21 +799,19 @@ describe('ObjectDetail Component', () => {
         const manageBtn = screen.getAllByRole('button').find(b => b.textContent?.includes('Manage'));
         if (!manageBtn) return;
         await user.click(manageBtn);
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
+        const dialog = await screen.findByRole('dialog');
+        await user.click(within(dialog).getByRole('button', {name: /confirm/i}));
         await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
     });
 
-    // ── Logs drawer ────────────────────────────────────────────────────────────
-
     test('logs drawer resize with mouse events adds/removes listeners', async () => {
         const addSpy = jest.spyOn(document, 'addEventListener');
         const removeSpy = jest.spyOn(document, 'removeEventListener');
         renderSvc();
         await waitForNode('node1');
-        await openLogsDrawer(user);
+        const logsBtn = screen.getAllByRole('button', {name: /logs/i})[0];
+        await user.click(logsBtn);
         await waitFor(() => expect(screen.getByLabelText('Resize drawer')).toBeInTheDocument());
-
         const handle = screen.getByLabelText('Resize drawer');
         fireEvent.mouseDown(handle, {clientX: 100});
         expect(addSpy).toHaveBeenCalledWith('mousemove', expect.any(Function));
@@ -1067,30 +821,27 @@ describe('ObjectDetail Component', () => {
         expect(removeSpy).toHaveBeenCalledWith('mousemove', expect.any(Function));
         expect(removeSpy).toHaveBeenCalledWith('mouseup', expect.any(Function));
         expect(document.body.style.cursor).toBe('default');
-
         addSpy.mockRestore();
         removeSpy.mockRestore();
     });
 
-    test('logs drawer resize with touch events adds/removes listeners', async () => {
+    test('logs drawer resize with touch events', async () => {
         const addSpy = jest.spyOn(document, 'addEventListener');
         const removeSpy = jest.spyOn(document, 'removeEventListener');
         renderSvc();
         await waitForNode('node1');
-        await openLogsDrawer(user);
+        const logsBtn = screen.getAllByRole('button', {name: /logs/i})[0];
+        await user.click(logsBtn);
         await waitFor(() => expect(screen.getByLabelText('Resize drawer')).toBeInTheDocument());
-
         const handle = screen.getByLabelText('Resize drawer');
         fireEvent.touchStart(handle, {touches: [{clientX: 100}]});
-        const touchMoveCall = addSpy.mock.calls.find(c => c[0] === 'touchmove' && c[2]?.passive === false);
-        expect(touchMoveCall).toBeDefined();
+        expect(addSpy.mock.calls.find(c => c[0] === 'touchmove' && c[2]?.passive === false)).toBeDefined();
         expect(addSpy).toHaveBeenCalledWith('touchend', expect.any(Function));
         fireEvent.touchMove(document, {touches: [{clientX: 150}]});
         fireEvent.touchEnd(document);
         expect(removeSpy).toHaveBeenCalledWith('touchmove', expect.any(Function));
         expect(removeSpy).toHaveBeenCalledWith('touchend', expect.any(Function));
         expect(document.body.style.cursor).toBe('default');
-
         addSpy.mockRestore();
         removeSpy.mockRestore();
     });
@@ -1099,8 +850,9 @@ describe('ObjectDetail Component', () => {
         Object.defineProperty(window, 'innerWidth', {writable: true, configurable: true, value: 1000});
         renderSvc();
         await waitForNode('node1');
-        await openLogsDrawer(user);
-        await waitFor(() => expect(screen.getByLabelText('Resize drawer')).toBeInTheDocument(), {timeout: 5000});
+        const logsBtn = screen.getAllByRole('button', {name: /logs/i})[0];
+        await user.click(logsBtn);
+        await waitFor(() => expect(screen.getByLabelText('Resize drawer')).toBeInTheDocument());
         const handle = screen.getByLabelText('Resize drawer');
         fireEvent.mouseDown(handle, {clientX: 100});
         fireEvent.mouseMove(document, {clientX: 50});
@@ -1111,234 +863,40 @@ describe('ObjectDetail Component', () => {
         Object.defineProperty(window, 'innerWidth', {writable: true, configurable: true, value: 1024});
     });
 
-    // ── Config updates subscription ────────────────────────────────────────────
-
-    test('config updates subscription: update without node skips fetchConfig', async () => {
-        let configCb;
-        let fetchCount = 0;
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            if (sel.toString().includes('configUpdates')) configCb = cb;
-            return jest.fn();
-        });
-        global.fetch = jest.fn((url) => {
-            if (url.includes('/config/file')) fetchCount++;
-            return Promise.resolve({
-                ok: true,
-                text: () => Promise.resolve('[DEFAULT]'),
-                json: () => Promise.resolve({items: []})
-            });
-        });
-        renderSvc();
-        await waitForNode('node1');
-        const before = fetchCount;
-        if (configCb) {
-            await act(async () => {
-                await configCb([{name: 'svc1', fullName: 'root/svc/svc1'}]);
-            });
-        }
-        expect(fetchCount).toBe(before);
-    });
-
-    test('config updates subscription: non-matching name does not call clearConfigUpdate', async () => {
-        const clearConfigUpdate = jest.fn();
-        useEventStore.mockImplementation(s => s(buildState({clearConfigUpdate})));
-        let configCb;
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            if (sel.toString().includes('configUpdates')) configCb = cb;
-            return jest.fn();
-        });
-        renderSvc();
-        await waitForNode('node1');
-        if (configCb) {
-            await act(async () => {
-                await configCb([{name: 'other', fullName: 'root/svc/other', node: 'n1'}]);
-            });
-        }
-        expect(clearConfigUpdate).not.toHaveBeenCalled();
-    });
-
-    test('config updates subscription: unmounted component causes early return', async () => {
-        let configCb;
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            if (sel.toString().includes('configUpdates')) configCb = cb;
-            return jest.fn();
-        });
-        const {unmount} = renderSvc();
-        await waitForNode('node1');
-        unmount();
-        if (configCb) {
-            await act(async () => {
-                await configCb([{name: 'svc1', fullName: 'root/svc/svc1', node: 'n1'}]).catch(() => {
-                });
-            });
-        }
-    });
-
-    test('config updates subscription: isProcessingConfigUpdate deduplicates concurrent calls', async () => {
-        let configCb;
-        let fetchCount = 0;
-        let resolveFirst;
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            if (sel.toString().includes('configUpdates')) configCb = cb;
-            return jest.fn();
-        });
-        global.fetch = jest.fn((url) => {
-            if (url.includes('/config/file')) {
-                fetchCount++;
-                if (fetchCount === 1) return new Promise(r => {
-                    resolveFirst = r;
-                });
-                return Promise.resolve({ok: true, text: () => Promise.resolve('[DEFAULT]')});
-            }
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
-        });
-        renderSvc();
-        await waitForNode('node1');
-        await waitFor(() => expect(fetchCount).toBe(1), {timeout: 3000});
-        if (configCb) {
-            act(() => {
-                configCb([{name: 'svc1', fullName: 'root/svc/svc1', node: 'node2'}]);
-            });
-            act(() => {
-                configCb([{name: 'svc1', fullName: 'root/svc/svc1', node: 'node2'}]);
-            });
-        }
-        if (resolveFirst) resolveFirst({ok: true, text: () => Promise.resolve('[DEFAULT]')});
-        await act(async () => {
-            await new Promise(r => setTimeout(r, 200));
-        });
-    });
-
-    test('config updates subscription: fetch error triggers snackbar error', async () => {
-        const clearConfigUpdate = jest.fn();
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {}, instanceMonitor: {}, instanceConfig: {},
-            objectInstanceStatus: {'root/svc/svc1': {node1: {avail: 'up', resources: {}}}},
-            configUpdates: [], clearConfigUpdate,
-        }));
-        let configUpdatesCb;
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            if (sel.toString().includes('configUpdates')) configUpdatesCb = cb;
-            return jest.fn();
-        });
-        let fetchCallCount = 0;
-        global.fetch.mockImplementation((url) => {
-            fetchCallCount++;
-            if (url.includes('/config/file') && fetchCallCount > 1) return Promise.reject(new Error('Update fetch failed'));
-            if (url.includes('/config/file')) return Promise.resolve({
-                ok: true,
-                text: () => Promise.resolve('[DEFAULT]\nid=123')
-            });
-            return Promise.resolve({
-                ok: true,
-                text: () => Promise.resolve(''),
-                json: () => Promise.resolve({items: []})
-            });
-        });
-        renderSvc();
-        await waitForNode('node1');
-        await waitFor(() => expect(fetchCallCount).toBeGreaterThan(0), {timeout: 5000});
-        if (configUpdatesCb) {
-            await act(async () => {
-                await configUpdatesCb([{
-                    name: 'svc1',
-                    fullName: 'root/svc/svc1',
-                    node: 'node2',
-                    type: 'InstanceConfigUpdated'
-                }]);
-            });
-            await waitFor(() => {
-                const alerts = screen.queryAllByRole('alert');
-                const errAlert = alerts.find(a =>
-                    a.textContent.includes('Failed to load updated configuration') || a.getAttribute('data-severity') === 'error'
-                );
-                if (errAlert) expect(errAlert).toBeInTheDocument();
-                expect(clearConfigUpdate).toHaveBeenCalled();
-            }, {timeout: 10000});
-        }
-    });
-
-    test('configUpdates subscription: selector captures state.configUpdates correctly', async () => {
-        const captured = [];
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            captured.push(sel);
-            return jest.fn();
-        });
-        renderSvc();
-        await waitForNode('node1');
-        const fake = {configUpdates: [{name: 'x', node: 'n1'}], instanceConfig: {}};
-        const sel = captured.find(s => {
-            try {
-                return Array.isArray(s(fake));
-            } catch {
-                return false;
-            }
-        });
-        expect(sel).toBeDefined();
-        expect(sel(fake)).toEqual([{name: 'x', node: 'n1'}]);
-    });
-
-    test('handles config updates subscription triggered by store', async () => {
-        const mockSubscribe = jest.fn();
-        useEventStore.subscribe = jest.fn((selector, callback) => {
-            callback([{name: 'cfg1', fullName: 'root/cfg/cfg1', type: 'InstanceConfigUpdated', node: 'node1'}]);
-            return mockSubscribe;
-        });
-        renderComponent('root/cfg/cfg1');
-        await waitFor(() => expect(screen.getByText(/Configuration updated/i)).toBeInTheDocument(), {timeout: 10000});
-        const {unmount} = renderComponent('root/cfg/cfg1');
-        unmount();
-        expect(mockSubscribe).toHaveBeenCalled();
-    }, 20000);
-
-    // ── Instance config subscription ───────────────────────────────────────────
-
     test('instanceConfig subscription triggers snackbar', async () => {
-        useEventStore.mockImplementation(s => s({
+        const state = {
             objectStatus: {}, instanceMonitor: {},
             objectInstanceStatus: {'root/svc/svc1': {node1: {avail: 'up', resources: {}}}},
             instanceConfig: {'root/svc/svc1': {node1: {resources: {res1: {is_monitored: true}}}}},
             configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
+            removeObject: jest.fn(),
+            setObjectStatuses: jest.fn(),
+            setInstanceStatuses: jest.fn(),
+        };
+        useEventStore.mockImplementation(s => s(state));
+        useEventStore.getState.mockReturnValue(state);
         let instanceConfigCallback;
         useEventStore.subscribe = jest.fn((selector, callback) => {
             if (selector.toString().includes('instanceConfig')) instanceConfigCallback = callback;
             return jest.fn();
         });
         renderSvc();
-        if (instanceConfigCallback) {
-            act(() => {
-                instanceConfigCallback({'root/svc/svc1': {node1: {resources: {res1: {is_monitored: false}}}}});
-            });
-        }
-        await waitFor(() => {
-            const alerts = screen.queryAllByRole('alert');
-            expect(alerts.find(a => a.textContent?.includes('Instance configuration updated'))).toBeInTheDocument();
-        });
-    });
-
-    // ── Subscription error handling ────────────────────────────────────────────
-
-    test('configUpdates subscription error triggers logger.warn', async () => {
-        const warnSpy = jest.spyOn(logger, 'warn').mockImplementation();
-        useEventStore.subscribe = jest.fn(() => {
-            throw new Error('Subscription failed');
+        await waitForNode('node1');
+        act(() => {
+            instanceConfigCallback({'root/svc/svc1': {node1: {resources: {res1: {is_monitored: false}}}}});
         });
-        renderSvc();
-        await waitForObjectName();
         await waitFor(() => {
-            expect(warnSpy).toHaveBeenCalledWith('[ObjectDetail] Failed to subscribe to configUpdates:', expect.any(Error));
+            expect(screen.queryAllByRole('alert').find(a => a.textContent?.includes('Instance configuration updated'))).toBeInTheDocument();
         });
-        warnSpy.mockRestore();
     });
 
     test('instanceConfig subscription error triggers logger.warn', async () => {
         const warnSpy = jest.spyOn(logger, 'warn').mockImplementation();
         useEventStore.subscribe = jest.fn(() => {
-            throw new Error('InstanceConfig subscription failed');
+            throw new Error('Subscription failed');
         });
         renderSvc();
-        await waitForObjectName();
+        await screen.findAllByText(/root\/svc\/svc1/i);
         await waitFor(() => {
             expect(warnSpy).toHaveBeenCalledWith('[ObjectDetail] Failed to subscribe to instanceConfig:', expect.any(Error));
         });
@@ -1352,36 +910,28 @@ describe('ObjectDetail Component', () => {
         await waitForNode('node1');
         await waitFor(() => {
             expect(warnSpy).toHaveBeenCalledWith('[ObjectDetail] Subscription is not a function:', 'not-a-function');
-        }, {timeout: 5000});
+        });
         warnSpy.mockRestore();
-    }, 10000);
-
-    // ── Snackbar ───────────────────────────────────────────────────────────────
+    });
 
     test('closes snackbar via close button', async () => {
-        global.fetch.mockResolvedValue({ok: true, status: 200, text: () => Promise.resolve('Success')});
-        renderSvc();
-        await waitForNode('node1');
-        await user.click(screen.getByRole('button', {name: /object actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-        await user.click(screen.getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /confirm/i}));
-        await waitFor(() => expect(screen.queryAllByRole('alert').length).toBeGreaterThan(0), {timeout: 5000});
+        await renderReadySvc();
+        await executeObjectAction('start');
         const closeButtons = screen.getAllByTestId('alert-close-button');
         if (closeButtons.length > 0) await user.click(closeButtons[0]);
     });
 
-    // ── Console dialog ─────────────────────────────────────────────────────────
-
     test('console dialog not shown by default (no console action in INSTANCE_ACTIONS)', async () => {
         renderSvc();
         await waitForNode('node1');
-        await waitFor(() => expect(screen.queryByText(/Open Console/i)).not.toBeInTheDocument(), {timeout: 5000});
+        await waitFor(() => expect(screen.queryByText(/Open Console/i)).not.toBeInTheDocument());
     });
 
     test('handleConsoleConfirm: cancel closes dialog', async () => {
-        await withConsole(async () => {
+        const {INSTANCE_ACTIONS} = require('../../constants/actions');
+        const orig = [...INSTANCE_ACTIONS];
+        INSTANCE_ACTIONS.push({name: 'console', icon: 'ConsoleIcon'});
+        try {
             renderSvc();
             const dialog = await openConsoleDialogFn();
             if (!dialog) return;
@@ -1390,13 +940,19 @@ describe('ObjectDetail Component', () => {
                 await user.click(cancelBtn);
                 await waitFor(() => {
                     expect(screen.queryAllByRole('dialog').filter(d => d.textContent.includes('terminal console')).length).toBe(0);
-                }, {timeout: 3000});
+                });
             }
-        });
+        } finally {
+            INSTANCE_ACTIONS.length = 0;
+            orig.forEach(a => INSTANCE_ACTIONS.push(a));
+        }
     });
 
     test('handleConsoleConfirm: without rid → no console fetch', async () => {
-        await withConsole(async () => {
+        const {INSTANCE_ACTIONS} = require('../../constants/actions');
+        const orig = [...INSTANCE_ACTIONS];
+        INSTANCE_ACTIONS.push({name: 'console', icon: 'ConsoleIcon'});
+        try {
             renderSvc();
             const dialog = await openConsoleDialogFn();
             if (!dialog) return;
@@ -1407,11 +963,17 @@ describe('ObjectDetail Component', () => {
                 await new Promise(r => setTimeout(r, 200));
                 expect(global.fetch.mock.calls.filter(([u, o]) => o?.method === 'POST' && u.includes('/console')).length).toBe(fetchsBefore);
             }
-        });
+        } finally {
+            INSTANCE_ACTIONS.length = 0;
+            orig.forEach(a => INSTANCE_ACTIONS.push(a));
+        }
     });
 
     test('handleConsoleConfirm: seats input clamps to minimum of 1', async () => {
-        await withConsole(async () => {
+        const {INSTANCE_ACTIONS} = require('../../constants/actions');
+        const orig = [...INSTANCE_ACTIONS];
+        INSTANCE_ACTIONS.push({name: 'console', icon: 'ConsoleIcon'});
+        try {
             renderSvc();
             const dialog = await openConsoleDialogFn();
             if (!dialog) return;
@@ -1424,7 +986,10 @@ describe('ObjectDetail Component', () => {
                 fireEvent.change(seatsInput, {target: {value: 'abc'}});
                 expect(seatsInput.value).toBe('1');
             }
-        });
+        } finally {
+            INSTANCE_ACTIONS.length = 0;
+            orig.forEach(a => INSTANCE_ACTIONS.push(a));
+        }
     });
 
     test('consoleUrlDialog: open in new tab calls window.open', async () => {
@@ -1437,11 +1002,10 @@ describe('ObjectDetail Component', () => {
             const openDialog = await screen.findByRole('dialog');
             await user.click(within(openDialog).getByRole('button', {name: /Open Console/i}));
             await waitFor(() => {
-                const urlDialog = screen.getByRole('dialog');
-                const tabBtn = within(urlDialog).getByRole('button', {name: /Open in New Tab/i});
+                const tabBtn = within(screen.getByRole('dialog')).getByRole('button', {name: /Open in New Tab/i});
                 fireEvent.click(tabBtn);
                 expect(openSpy).toHaveBeenCalled();
-            }, {timeout: 8000});
+            });
         }
         openSpy.mockRestore();
     });
@@ -1455,43 +1019,25 @@ describe('ObjectDetail Component', () => {
             const openDialog = await screen.findByRole('dialog');
             await user.click(within(openDialog).getByRole('button', {name: /Open Console/i}));
             await waitFor(() => {
-                const urlDialog = screen.getByRole('dialog');
-                fireEvent.click(within(urlDialog).getByRole('button', {name: /Close/i}));
+                fireEvent.click(within(screen.getByRole('dialog')).getByRole('button', {name: /Close/i}));
                 expect(screen.queryByText(/Console URL/i)).not.toBeInTheDocument();
-            }, {timeout: 8000});
-        }
-    });
-
-    test('postConsoleAction: handles non-ok HTTP response', async () => {
-        global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/console')) {
-                return Promise.resolve({ok: false, status: 500, text: () => Promise.resolve('Server error')});
-            }
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
-        });
-        renderSvc();
-        await waitForNode('node1');
-        const resourceButtons = screen.queryAllByRole('button', {name: /resource .* actions/i});
-        if (resourceButtons.length > 0) {
-            await user.click(resourceButtons[0]);
-            await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
-            const consoleItem = screen.queryByRole('menuitem', {name: /console/i});
-            if (consoleItem) {
-                await user.click(consoleItem);
-                const dialog = await screen.findByRole('dialog');
-                await user.click(within(dialog).getByRole('button', {name: /open console/i}));
-                await waitFor(() => {
-                    expect(screen.getAllByRole('alert').some(a => a.textContent.includes('HTTP error! status: 500'))).toBe(true);
-                }, {timeout: 5000});
-            }
+            });
         }
     });
 
-    test('postConsoleAction: handles missing Location header', async () => {
+    test.each([
+        ['non-ok HTTP response', (url, options) => options?.method === 'POST' && url.includes('/console'), 'HTTP error! status: 500', {
+            ok: false,
+            status: 500,
+            text: () => Promise.resolve('Server error')
+        }],
+        ['missing Location header', (url, options) => options?.method === 'POST' && url.includes('/console'), 'Console URL not found', {
+            ok: true,
+            headers: {get: () => null}
+        }],
+    ])('postConsoleAction: handles %s', async (label, matchFn, expectedMsg, failResponse) => {
         global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/console')) {
-                return Promise.resolve({ok: true, headers: {get: () => null}});
-            }
+            if (matchFn(url, options)) return Promise.resolve(failResponse);
             return Promise.resolve({ok: true, text: () => Promise.resolve('')});
         });
         renderSvc();
@@ -1506,17 +1052,14 @@ describe('ObjectDetail Component', () => {
                 const dialog = await screen.findByRole('dialog');
                 await user.click(within(dialog).getByRole('button', {name: /open console/i}));
                 await waitFor(() => {
-                    expect(screen.getAllByRole('alert').some(a => a.textContent.includes('Console URL not found'))).toBe(true);
-                }, {timeout: 5000});
+                    expect(screen.getAllByRole('alert').some(a => a.textContent.includes(expectedMsg))).toBe(true);
+                });
             }
         }
     });
 
     test('postConsoleAction: handles fetch exception', async () => {
-        global.fetch.mockImplementation((url, options) => {
-            if (options?.method === 'POST' && url.includes('/console')) return Promise.reject(new Error('Network failure'));
-            return Promise.resolve({ok: true, text: () => Promise.resolve('')});
-        });
+        mockNetworkFailure('/console');
         renderSvc();
         await waitForNode('node1');
         const resourceButtons = screen.queryAllByRole('button', {name: /resource .* actions/i});
@@ -1530,48 +1073,25 @@ describe('ObjectDetail Component', () => {
                 await user.click(within(dialog).getByRole('button', {name: /open console/i}));
                 await waitFor(() => {
                     expect(screen.getAllByRole('alert').some(a => a.textContent.includes('Network failure'))).toBe(true);
-                }, {timeout: 5000});
+                });
             }
         }
     });
 
-    // ── Misc ───────────────────────────────────────────────────────────────────
-
     test('handleIndividualNodeActionClick does not warn in normal flow', async () => {
         const warnSpy = jest.spyOn(logger, 'warn').mockImplementation();
-        renderSvc();
-        await waitForNode('node1');
+        await renderReadySvc();
         await user.click(screen.getByRole('button', {name: /Node node1 actions/i}));
-        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument(), {timeout: 3000});
+        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
         await user.click(within(screen.getByRole('menu')).getByRole('menuitem', {name: /start/i}));
-        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument(), {timeout: 3000});
-        await user.click(within(screen.getByRole('dialog')).getByRole('button', {name: /cancel/i}));
+        const dialog = await screen.findByRole('dialog');
+        await user.click(within(dialog).getByRole('button', {name: /cancel/i}));
         expect(warnSpy).not.toHaveBeenCalled();
         warnSpy.mockRestore();
     });
 
-    test('subscription without node does not trigger fetchConfig', () => {
-        const unsubscribeMock = jest.fn();
-        useEventStore.subscribe = jest.fn((sel, cb) => {
-            cb([{name: 'svc1', fullName: 'root/svc/svc1', type: 'InstanceConfigUpdated'}]);
-            return unsubscribeMock;
-        });
-        useEventStore.mockImplementation(sel => sel({
-            objectStatus: {}, objectInstanceStatus: {}, instanceMonitor: {},
-            instanceConfig: {}, configUpdates: [], clearConfigUpdate: jest.fn(),
-        }));
-        renderSvc();
-        expect(typeof unsubscribeMock).toBe('function');
-    });
-
-    test('useEffect for configUpdates handles no matching update', async () => {
-        const clearConfigUpdate = jest.fn();
-        useEventStore.mockImplementation(s => s({
-            objectStatus: {}, objectInstanceStatus: {}, instanceMonitor: {}, instanceConfig: {},
-            configUpdates: [{name: 'other', type: 'InstanceConfigUpdated', node: 'node1'}],
-            clearConfigUpdate,
-        }));
+    test('removes object on mount via store.removeObject', () => {
         renderComponent('root/cfg/cfg1');
-        await waitFor(() => expect(clearConfigUpdate).not.toHaveBeenCalled(), {timeout: 10000});
-    }, 15000);
+        expect(fullMockState.removeObject).toHaveBeenCalledWith('root/cfg/cfg1');
+    });
 });
diff --git a/src/components/tests/Objects.test.jsx b/src/components/tests/Objects.test.jsx
index 8e666be5..8294dcdc 100644
--- a/src/components/tests/Objects.test.jsx
+++ b/src/components/tests/Objects.test.jsx
@@ -12,7 +12,6 @@ jest.mock('react-router-dom', () => ({
     useNavigate: jest.fn(),
     useLocation: jest.fn(),
 }));
-
 jest.mock('../../hooks/useEventStore');
 jest.mock('../../hooks/useFetchDaemonStatus');
 jest.mock('../../eventSourceManager');
@@ -21,2215 +20,530 @@ jest.mock('@mui/material/Collapse', () => ({in: inProp, children}) =>
     inProp ? children : null
 );
 
-const AVAILABLE_ACTIONS = [
-    'start',
-    'stop',
-    'restart',
-    'freeze',
-    'unfreeze',
-    'delete',
-    'provision',
-    'unprovision',
-    'purge',
-    'switch',
-    'giveback',
-    'abort',
-];
-
 expect.extend(toHaveNoViolations);
 
-const selectFilterOption = async (labelText, optionText) => {
-    const filter = screen.getByLabelText(labelText);
+// ---------- helpers ----------
+const mockNavigate = jest.fn();
+const mockRemoveObject = jest.fn();
+let originalConsoleError;
+
+const defaultState = {
+    objectStatus: {
+        'test-ns/svc/test1': {avail: 'up', frozen: 'unfrozen'},
+        'test-ns/svc/test2': {avail: 'down', frozen: 'frozen'},
+        'root/svc/test3': {avail: 'warn', frozen: 'unfrozen'},
+        'test-ns/svc/test4': {avail: 'n/a', frozen: 'unfrozen'},
+        'test-ns/svc/unprovisioned': {avail: 'n/a', frozen: 'unfrozen', provisioned: 'false'},
+    },
+    objectInstanceStatus: {
+        'test-ns/svc/test1': {
+            node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'},
+            node2: {avail: 'down', frozen_at: '2025-05-16T10:00:00Z'},
+        },
+        'test-ns/svc/test2': {
+            node1: {avail: 'down', frozen_at: '2025-05-16T10:00:00Z'},
+        },
+        'root/svc/test3': {node2: {avail: 'warn', frozen_at: '0001-01-01T00:00:00Z'}},
+        'test-ns/svc/test4': {},
+        'test-ns/svc/unprovisioned': {
+            node1: {avail: 'n/a', frozen_at: '0001-01-01T00:00:00Z', provisioned: 'false'},
+        },
+    },
+    instanceMonitor: {
+        'node1:test-ns/svc/test1': {state: 'running', global_expect: 'frozen'},
+        'node2:test-ns/svc/test1': {state: 'idle', global_expect: 'none'},
+        'node1:test-ns/svc/test2': {state: 'failed', global_expect: 'none'},
+        'node2:root/svc/test3': {state: 'idle', global_expect: 'started'},
+    },
+    removeObject: mockRemoveObject,
+};
 
-    fireEvent.mouseDown(filter);
+const setup = (customState = {}, locationSearch = '', mediaQuery = true, {daemon} = {}) => {
+    const state = {...defaultState, ...customState};
+    useEventStore.mockImplementation((sel) => sel(state));
+    useFetchDaemonStatus.mockReturnValue({daemon: daemon || {cluster: {object: {}}}});
+    startEventReception.mockClear();
+    closeEventSource.mockClear();
+    global.fetch = jest.fn(() => Promise.resolve({ok: true, json: () => Promise.resolve({})}));
+    require('react-router-dom').useLocation.mockReturnValue({search: locationSearch, pathname: '/objects'});
+    require('react-router-dom').useNavigate.mockReturnValue(mockNavigate);
+    require('@mui/material/useMediaQuery').mockReturnValue(mediaQuery);
+
+    const utils = render(
+        <MemoryRouter>
+            <Objects/>
+        </MemoryRouter>
+    );
+    return {...utils, state};
+};
 
-    await waitFor(() => {
-        expect(screen.getByRole('listbox')).toBeInTheDocument();
-    });
+const waitForLoad = () =>
+    waitFor(() => expect(screen.getByLabelText('Global State')).toBeInTheDocument());
 
+const selectFilter = async (label, optionText) => {
+    const filter = screen.getByLabelText(label);
+    fireEvent.mouseDown(filter);
+    await waitFor(() => expect(screen.getByRole('listbox')).toBeInTheDocument());
     const listbox = screen.getByRole('listbox');
-
     const options = within(listbox).getAllByRole('option');
-    const option = options.find(opt =>
-        opt.textContent.toLowerCase().includes(optionText.toLowerCase())
-    );
-
-    if (!option) {
-        throw new Error(`Option with text "${optionText}" not found`);
-    }
-
-    const checkbox = within(option).getByRole('checkbox');
-    fireEvent.click(checkbox);
-
-    const backdrop = document.querySelector('.MuiBackdrop-root, .MuiModal-backdrop');
-    if (backdrop) {
-        fireEvent.click(backdrop);
-    } else {
-        fireEvent.keyDown(listbox, {key: 'Escape', code: 'Escape'});
-    }
+    const option = options.find((o) => o.textContent.toLowerCase().includes(optionText.toLowerCase()));
+    if (!option) throw new Error(`Option "${optionText}" not found`);
+    fireEvent.click(within(option).getByRole('checkbox'));
+    fireEvent.keyDown(listbox, {key: 'Escape', code: 'Escape'});
+    await waitFor(() => expect(screen.queryByRole('listbox')).not.toBeInTheDocument());
+    await waitFor(() => expect(screen.getByRole('table')).toBeInTheDocument(), {timeout: 1000});
 };
 
-const waitForFilterApplied = async () => {
-    await waitFor(() => {
-        expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-    });
-
-    await waitFor(() => {
-        expect(screen.getByRole('table')).toBeInTheDocument();
-    }, {timeout: 1000});
+const selectRow = (name) => {
+    const row = screen.getByRole('row', {name: new RegExp(name, 'i')});
+    const cb = within(row).getByRole('checkbox');
+    fireEvent.click(cb);
+    return cb;
 };
 
-describe('Objects Component', () => {
-    const mockNavigate = jest.fn();
-    const mockStartEventReception = jest.fn();
-    const mockCloseEventSource = jest.fn();
-    const mockRemoveObject = jest.fn();
-    const allNodes = ['node1', 'node2'];
-
-    let originalConsoleError;
-
-    beforeEach(() => {
-        originalConsoleError = console.error;
-        console.error = jest.fn((message, ...args) => {
-            if (typeof message === 'string' &&
-                (message.includes('A props object containing a "key" prop is being spread into JSX') ||
-                    message.includes('<li> cannot appear as a descendant of <li>'))) {
-                return;
-            }
-            originalConsoleError.call(console, message, ...args);
-        });
-
-        jest.clearAllMocks();
-
-        require('react-router-dom').useLocation.mockReturnValue({
-            search: '',
-            pathname: '/objects',
-        });
-        require('react-router-dom').useNavigate.mockReturnValue(mockNavigate);
-
-        require('@mui/material/useMediaQuery').mockReturnValue(true);
-
-        const mockState = {
-            objectStatus: {
-                'test-ns/svc/test1': {avail: 'up', frozen: 'unfrozen'},
-                'test-ns/svc/test2': {avail: 'down', frozen: 'frozen'},
-                'root/svc/test3': {avail: 'warn', frozen: 'unfrozen'},
-                'test-ns/svc/test4': {avail: 'n/a', frozen: 'unfrozen'},
-                'test-ns/svc/unprovisioned': {avail: 'n/a', frozen: 'unfrozen', provisioned: 'false'},
-            },
-            objectInstanceStatus: {
-                'test-ns/svc/test1': {
-                    node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'},
-                    node2: {avail: 'down', frozen_at: '2025-05-16T10:00:00Z'},
-                },
-                'test-ns/svc/test2': {
-                    node1: {avail: 'down', frozen_at: '2025-05-16T10:00:00Z'},
-                },
-                'root/svc/test3': {
-                    node2: {avail: 'warn', frozen_at: '0001-01-01T00:00:00Z'},
-                },
-                'test-ns/svc/test4': {},
-                'test-ns/svc/unprovisioned': {
-                    node1: {avail: 'n/a', frozen_at: '0001-01-01T00:00:00Z', provisioned: 'false'},
-                },
-            },
-            instanceMonitor: {
-                'node1:test-ns/svc/test1': {state: 'running', global_expect: 'frozen'},
-                'node2:test-ns/svc/test1': {state: 'idle', global_expect: 'none'},
-                'node1:test-ns/svc/test2': {state: 'failed', global_expect: 'none'},
-                'node2:root/svc/test3': {state: 'idle', global_expect: 'started'},
-            },
-            removeObject: mockRemoveObject,
-        };
-
-        useEventStore.mockImplementation((selector) => selector(mockState));
-
-        useFetchDaemonStatus.mockReturnValue({
-            daemon: {cluster: {object: {}}},
-        });
-
-        startEventReception.mockImplementation(mockStartEventReception);
-        closeEventSource.mockImplementation(mockCloseEventSource);
-
-        jest.spyOn(Storage.prototype, 'getItem').mockReturnValue('mock-token');
-
-        global.fetch = jest.fn(() =>
-            Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve({}),
-            })
-        );
-    });
-
-    afterEach(() => {
-        console.error = originalConsoleError;
-        jest.restoreAllMocks();
-        require('@mui/material/useMediaQuery').mockReturnValue(true);
-    });
-
-    const setupComponent = () => {
-        return render(
-            <MemoryRouter>
-                <Objects/>
-            </MemoryRouter>
-        );
-    };
-
-    const waitForComponentToLoad = async () => {
-        await waitFor(() => {
-            expect(screen.getByLabelText('Global State')).toBeInTheDocument();
-        });
-    };
+const openActionsMenu = () =>
+    fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
 
-    const verifyStatusColumn = (row, expectedIcons, expectedCaption = null) => {
-        const cells = within(row).getAllByRole('cell');
-        const statusCell = cells[1];
-
-        expectedIcons.forEach((icon) => {
-            const label = icon === 'warn' ? 'Object has warning' : `Object is ${icon}`;
-            expect(within(statusCell).getByLabelText(label)).toBeInTheDocument();
-        });
-
-        if (expectedCaption) {
-            expect(within(statusCell).getByText(expectedCaption)).toBeInTheDocument();
-        }
-    };
+const clickMenuItem = async (text) => {
+    const menu = await screen.findByRole('menu');
+    fireEvent.click(within(menu).getByText(new RegExp(`^${text}$`, 'i')));
+};
 
-    const verifyNodeColumn = (row, node, expectedIcons) => {
-        const nodeIndex = allNodes.indexOf(node);
-        const nodeCell = within(row).getAllByRole('cell')[nodeIndex + 3];
+const confirmDialog = async (buttonName = /Confirm|Stop|Delete/i) => {
+    await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
+    fireEvent.click(screen.getByRole('button', {name: buttonName}));
+};
 
-        if (expectedIcons.length === 0) {
-            expect(within(nodeCell).queryByLabelText(/Node .+ is .+/)).toBeNull();
-            expect(within(nodeCell).queryByLabelText(/Node .+ has warning/)).toBeNull();
-            expect(within(nodeCell).queryByLabelText(/Node .+ is frozen/)).toBeNull();
-            expect(within(nodeCell).queryByLabelText(/Node .+ is not provisioned/)).toBeNull();
+beforeEach(() => {
+    originalConsoleError = console.error;
+    console.error = jest.fn((msg, ...args) => {
+        if (
+            typeof msg === 'string' &&
+            (msg.includes('A props object containing a "key" prop is being spread into JSX') ||
+                msg.includes('<li> cannot appear as a descendant of <li>'))
+        )
             return;
-        }
-
-        expectedIcons.forEach((icon) => {
-            const label = icon === 'warn' ? `Node ${node} has warning` : `Node ${node} is ${icon}`;
-            expect(within(nodeCell).getByLabelText(label)).toBeInTheDocument();
-        });
-    };
-
-    const selectObject = async (objectName) => {
-        const row = screen.getByRole('row', {name: new RegExp(objectName, 'i')});
-        const checkbox = within(row).getByRole('checkbox');
-        fireEvent.click(checkbox);
-        return checkbox;
-    };
-
-    test('renders correctly with initial state', async () => {
-        setupComponent();
+        originalConsoleError.call(console, msg, ...args);
+    });
+    jest.clearAllMocks();
+    jest.spyOn(Storage.prototype, 'getItem').mockReturnValue('mock-token');
+    mockRemoveObject.mockClear();
+});
 
-        await waitForComponentToLoad();
+afterEach(() => {
+    console.error = originalConsoleError;
+    jest.restoreAllMocks();
+});
 
-        expect(screen.getByLabelText('Global State')).toBeInTheDocument();
-        expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
-        expect(screen.getByLabelText('Kind')).toBeInTheDocument();
-        expect(screen.getByLabelText('Name')).toBeInTheDocument();
+// ---------- tests ----------
+describe('Objects Component', () => {
+    test('initial render and data fetch', async () => {
+        const {unmount} = setup();
+        await waitForLoad();
         expect(screen.getByText('Status')).toBeInTheDocument();
         expect(screen.getByText('Object')).toBeInTheDocument();
         expect(screen.getByRole('columnheader', {name: /node1/i})).toBeInTheDocument();
-        expect(screen.getByRole('columnheader', {name: /node2/i})).toBeInTheDocument();
+        expect(startEventReception).toHaveBeenCalledWith('mock-token', expect.any(Array));
+        unmount();
+        expect(closeEventSource).toHaveBeenCalled();
+    });
+
+    test('displays objects with correct status and node data', async () => {
+        setup();
+        await waitForLoad();
+        ['test-ns/svc/test1', 'test-ns/svc/test2', 'root/svc/test3'].forEach((name) =>
+            expect(screen.getByRole('row', {name: new RegExp(name)})).toBeInTheDocument()
+        );
+        const row1 = screen.getByRole('row', {name: /test1/});
+        expect(within(row1).getByLabelText('Object is up')).toBeInTheDocument();
+        expect(within(row1).getByText('frozen')).toBeInTheDocument();
+        expect(within(row1).getByLabelText('Node node2 is down')).toBeInTheDocument();
+        expect(within(row1).getByLabelText('Node node2 is frozen')).toBeInTheDocument();
+    });
+
+    test('selection and select all', async () => {
+        setup();
+        await waitForLoad();
+        const cb = selectRow('test-ns/svc/test1');
+        expect(cb).toBeChecked();
+        const selectAll = screen.getAllByRole('checkbox')[0];
+        fireEvent.click(selectAll);
+        screen.getAllByRole('checkbox').slice(1).forEach((c) => expect(c).toBeChecked());
+        fireEvent.click(selectAll);
+        screen.getAllByRole('checkbox').slice(1).forEach((c) => expect(c).not.toBeChecked());
+    });
+
+    test('actions menu opens and lists actions', async () => {
+        setup();
+        await waitForLoad();
+        await selectRow('test-ns/svc/test1');
+        openActionsMenu();
+        const menu = await screen.findByRole('menu');
+        ['Restart', 'Stop', 'Freeze', 'Delete'].forEach((a) =>
+            expect(within(menu).getByText(a)).toBeInTheDocument()
+        );
     });
 
-    test('fetches data on mount and cleans up on unmount', async () => {
-        const {unmount} = setupComponent();
-
-        await waitForComponentToLoad();
-
-        expect(startEventReception).toHaveBeenCalledWith(
-            "mock-token",
-            [
-                "ObjectStatusUpdated",
-                "InstanceStatusUpdated",
-                "ObjectDeleted",
-                "InstanceMonitorUpdated"
-            ]
+    describe('filtering', () => {
+        const filterTests = [
+            {
+                label: 'Namespace',
+                option: 'test-ns',
+                visible: ['test-ns/svc/test1', 'test-ns/svc/test2'],
+                hidden: ['root/svc/test3']
+            },
+            {label: 'Global State', option: 'Up', visible: ['test-ns/svc/test1'], hidden: ['test-ns/svc/test2']},
+            {label: 'Kind', option: 'svc', visible: ['test-ns/svc/test1'], hidden: []},
+            {
+                label: 'Name',
+                option: 'test1',
+                visible: ['test-ns/svc/test1'],
+                hidden: ['test-ns/svc/test2', 'root/svc/test3'],
+                isSearch: true
+            },
+        ];
+
+        test.each(filterTests)(
+            '$label filter',
+            async ({label, option, visible, hidden, isSearch}) => {
+                setup();
+                await waitForLoad();
+                if (isSearch) {
+                    fireEvent.change(screen.getByLabelText('Name'), {target: {value: option}});
+                } else {
+                    await selectFilter(label, option);
+                }
+                await waitFor(() => {
+                    visible.forEach((n) => expect(screen.getByRole('row', {name: new RegExp(n)})).toBeInTheDocument());
+                    hidden.forEach((n) => expect(screen.queryByRole('row', {name: new RegExp(n)})).not.toBeInTheDocument());
+                });
+            }
         );
-
-        unmount();
-
-        expect(closeEventSource).toHaveBeenCalledTimes(1);
     });
 
-    test('displays objects table with correct data', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
+    test('multiple filters combined', async () => {
+        setup();
+        await waitForLoad();
+        await selectFilter('Namespace', 'test-ns');
+        await selectFilter('Global State', 'Up');
         await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
+            expect(screen.getByRole('row', {name: /test1/})).toBeInTheDocument();
+            expect(screen.queryByRole('row', {name: /test2/})).not.toBeInTheDocument();
         });
-
-        expect(screen.getByRole('row', {name: /test-ns\/svc\/test2/i})).toBeInTheDocument();
-        expect(screen.getByRole('row', {name: /root\/svc\/test3/i})).toBeInTheDocument();
-
-        const rows = screen.getAllByRole('row').slice(1);
-        const rowTexts = rows.map((row) => row.textContent);
-
-        const test1Row = rows[rowTexts.findIndex((text) => text.includes('test-ns/svc/test1'))];
-        const test2Row = rows[rowTexts.findIndex((text) => text.includes('test-ns/svc/test2'))];
-        const test3Row = rows[rowTexts.findIndex((text) => text.includes('root/svc/test3'))];
-
-        verifyStatusColumn(test1Row, ['up'], 'frozen');
-        verifyStatusColumn(test2Row, ['down', 'frozen']);
-        verifyStatusColumn(test3Row, ['warn'], 'started');
-
-        verifyNodeColumn(test1Row, 'node1', ['up']);
-        verifyNodeColumn(test1Row, 'node2', ['down', 'frozen']);
-        verifyNodeColumn(test2Row, 'node1', ['down', 'frozen']);
-        verifyNodeColumn(test2Row, 'node2', []);
-        verifyNodeColumn(test3Row, 'node1', []);
-        verifyNodeColumn(test3Row, 'node2', ['warn']);
     });
 
-    test('handles object selection', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const checkbox = await selectObject('test-ns/svc/test1');
-
-        expect(checkbox).toBeChecked();
+    test('chips remove filters', async () => {
+        setup();
+        await waitForLoad();
+        await selectFilter('Namespace', 'test-ns');
+        const chip = screen.getByText('test-ns').closest('.MuiChip-root');
+        fireEvent.click(within(chip).getByTestId('CloseIcon'));
+        await waitFor(() => expect(screen.getByRole('row', {name: /root\/svc\/test3/})).toBeInTheDocument());
+    });
+
+    test('empty message when nothing matches', async () => {
+        setup();
+        await waitForLoad();
+        fireEvent.change(screen.getByLabelText('Name'), {target: {value: 'nonexistent'}});
+        await waitFor(() => expect(screen.getByText(/No objects found/)).toBeInTheDocument());
+    });
+
+    describe('actions execution', () => {
+        test('restart succeeds', async () => {
+            setup();
+            await waitForLoad();
+            await selectRow('test-ns/svc/test1');
+            openActionsMenu();
+            await clickMenuItem('Restart');
+            await confirmDialog();
+            await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
+                expect.stringContaining('/action/restart'), expect.any(Object)
+            ));
+            await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/succeeded/i));
+        });
+
+        test('unfreeze succeeds on frozen object', async () => {
+            setup();
+            await waitForLoad();
+            await selectRow('test-ns/svc/test2');
+            openActionsMenu();
+            await clickMenuItem('Unfreeze');
+            await confirmDialog();
+            await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
+                expect.stringContaining('/action/unfreeze'), expect.any(Object)
+            ));
+        });
+
+        test('delete succeeds with confirmations', async () => {
+            setup();
+            await waitForLoad();
+            await selectRow('test-ns/svc/test1');
+            openActionsMenu();
+            await clickMenuItem('Delete');
+            await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
+            fireEvent.click(screen.getByLabelText(/Confirm configuration loss/i));
+            fireEvent.click(screen.getByLabelText(/Confirm clusterwide orchestration/i));
+            fireEvent.click(screen.getByRole('button', {name: /Delete/i}));
+            await waitFor(() => expect(global.fetch).toHaveBeenCalledWith(
+                expect.stringContaining('/action/delete'), expect.any(Object)
+            ));
+            expect(mockRemoveObject).toHaveBeenCalledWith('test-ns/svc/test1');
+        });
+
+        test('failed action shows error alert', async () => {
+            setup();
+            global.fetch = jest.fn(() => Promise.resolve({ok: false, status: 500}));
+            await waitForLoad();
+            await selectRow('test-ns/svc/test1');
+            openActionsMenu();
+            await clickMenuItem('Restart');
+            await confirmDialog();
+            await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/failed/i));
+        });
+
+        test('partial success shows warning', async () => {
+            setup();
+            await waitForLoad();
+            await selectRow('test-ns/svc/test1');
+            await selectRow('test-ns/svc/test2');
+            global.fetch = jest.fn()
+                .mockResolvedValueOnce({ok: true})
+                .mockResolvedValueOnce({ok: false, status: 500});
+            openActionsMenu();
+            await clickMenuItem('Restart');
+            await confirmDialog();
+            await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/partially succeeded: 1 ok, 1 errors/i));
+        });
+
+        test('network error', async () => {
+            setup();
+            await waitForLoad();
+            await selectRow('test-ns/svc/test1');
+            global.fetch = jest.fn().mockRejectedValue(new Error('Network error'));
+            openActionsMenu();
+            await clickMenuItem('Restart');
+            await confirmDialog();
+            await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/failed on all 1 object\(s\)/i));
+        });
+
+        test('token missing prevents action', async () => {
+            Storage.prototype.getItem.mockReturnValue(null);
+            setup();
+            await waitForLoad();
+            await selectRow('test-ns/svc/test1');
+            openActionsMenu();
+            await clickMenuItem('Restart');
+            await confirmDialog();
+            await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('Authentication token not found'));
+        });
+    });
+
+    test('row click navigates', async () => {
+        setup();
+        await waitForLoad();
+        fireEvent.click(screen.getByRole('row', {name: /test-ns\/svc\/test1/}));
+        expect(mockNavigate).toHaveBeenCalledWith('/objects/test-ns%2Fsvc%2Ftest1');
     });
 
-    test('handles select all objects', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const selectAllCheckbox = screen.getAllByRole('checkbox')[0];
-        fireEvent.click(selectAllCheckbox);
-
-        const allCheckboxes = screen.getAllByRole('checkbox').slice(1);
-        allCheckboxes.forEach((checkbox) => {
-            expect(checkbox).toBeChecked();
-        });
+    test('no navigation if no instance status', async () => {
+        setup({objectInstanceStatus: {}});
+        await waitForLoad();
+        fireEvent.click(screen.getByRole('row', {name: /test-ns\/svc\/test1/}));
+        expect(mockNavigate).not.toHaveBeenCalled();
     });
 
-    test('handles deselect all when all are selected', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const selectAllCheckbox = screen.getAllByRole('checkbox')[0];
-        fireEvent.click(selectAllCheckbox);
-
-        await waitFor(() => {
-            const allCheckboxes = screen.getAllByRole('checkbox').slice(1);
-            allCheckboxes.forEach((checkbox) => {
-                expect(checkbox).toBeChecked();
-            });
-        });
-
-        fireEvent.click(selectAllCheckbox);
-
-        await waitFor(() => {
-            const allCheckboxes = screen.getAllByRole('checkbox').slice(1);
-            allCheckboxes.forEach((checkbox) => {
-                expect(checkbox).not.toBeChecked();
-            });
-        });
+    test('row context menu shows correct actions', async () => {
+        setup();
+        await waitForLoad();
+        const row = screen.getByRole('row', {name: /test1/});
+        fireEvent.click(within(row).getByRole('button', {name: /more actions/i}));
+        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
+        expect(screen.getByText('Freeze')).toBeInTheDocument();
+        expect(screen.queryByText('Unfreeze')).not.toBeInTheDocument();
     });
 
-    test('opens actions menu', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-
-        const menu = await screen.findByRole('menu');
-        expect(menu).toBeInTheDocument();
-
-        AVAILABLE_ACTIONS.forEach((action) => {
-            expect(
-                within(menu).getByText(action.charAt(0).toUpperCase() + action.slice(1))
-            ).toBeInTheDocument();
-        });
+    test('row context menu for frozen object', async () => {
+        setup();
+        await waitForLoad();
+        const row = screen.getByRole('row', {name: /test2/});
+        fireEvent.click(within(row).getByRole('button', {name: /more actions/i}));
+        await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
+        expect(screen.queryByText('Freeze')).not.toBeInTheDocument();
+        expect(screen.getByText('Unfreeze')).toBeInTheDocument();
     });
 
-    test('filters objects by namespace', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Namespace', 'test-ns');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByRole('row', {name: /test-ns\/svc\/test2/i})).toBeInTheDocument();
-        expect(screen.queryByRole('row', {name: /root\/svc\/test3/i})).not.toBeInTheDocument();
+    test('global actions disabled when none selected', async () => {
+        setup();
+        await waitForLoad();
+        expect(screen.getByRole('button', {name: /actions on selected objects/i})).toBeDisabled();
     });
 
-    test('filters objects by search query', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const searchInput = screen.getByLabelText('Name');
-        fireEvent.change(searchInput, {target: {value: 'test1'}});
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
+    test('toggles filters visibility', async () => {
+        setup();
+        await waitForLoad();
+        const btn = screen.getByRole('button', {name: /filters/i});
+        expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
+        fireEvent.click(btn);
+        await waitFor(() => expect(btn).toHaveAttribute('aria-label', 'Show filters'));
+        expect(screen.queryByLabelText('Namespace')).not.toBeInTheDocument();
+        fireEvent.click(btn);
+        await waitFor(() => expect(screen.getByLabelText('Namespace')).toBeInTheDocument());
+    });
+
+    describe('sorting', () => {
+        const clickHeader = (text) => fireEvent.click(screen.getByText(text));
+        test.each(['Status', 'Object', 'node1'])('%s sorting works', async (col) => {
+            setup();
+            await waitForLoad();
+            if (col === 'node1') {
+                fireEvent.click(screen.getByRole('columnheader', {name: /node1/i}));
+            } else {
+                clickHeader(col);
+            }
+            await waitFor(() => expect(screen.getAllByRole('row').length).toBeGreaterThan(1));
         });
 
-        expect(screen.queryByRole('row', {name: /test-ns\/svc\/test2/i})).not.toBeInTheDocument();
-        expect(screen.queryByRole('row', {name: /root\/svc\/test3/i})).not.toBeInTheDocument();
+        test('sort direction toggles', async () => {
+            setup();
+            await waitForLoad();
+            clickHeader('Object');
+            clickHeader('Object');
+            await waitFor(() => expect(screen.getAllByRole('row').length).toBeGreaterThan(1));
+        });
     });
 
-    test('handles object click navigation', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        fireEvent.click(screen.getByRole('row', {name: /test-ns\/svc\/test1/i}));
-
-        expect(mockNavigate).toHaveBeenCalledWith('/objects/test-ns%2Fsvc%2Ftest1');
+    test('infinite scroll loads more', async () => {
+        const many = {};
+        const manyInst = {};
+        for (let i = 0; i < 50; i++) {
+            const name = `test-ns/svc/obj${i}`;
+            many[name] = {avail: 'up', frozen: 'unfrozen'};
+            manyInst[name] = {node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'}};
+        }
+        setup({objectStatus: many, objectInstanceStatus: manyInst});
+        await waitForLoad();
+        expect(screen.getAllByRole('row').slice(1)).toHaveLength(30);
+        const container = document.querySelector('.MuiTableContainer-root');
+        Object.defineProperty(container, 'scrollHeight', {value: 1000, configurable: true});
+        Object.defineProperty(container, 'clientHeight', {value: 500, configurable: true});
+        Object.defineProperty(container, 'scrollTop', {value: 500, configurable: true});
+        fireEvent.scroll(container);
+        await waitFor(() => expect(screen.getAllByRole('row').slice(1).length).toBeGreaterThan(30));
+    });
+
+    test('scroll does nothing when no more items', async () => {
+        setup({objectStatus: {'a/b': {avail: 'up'}}, objectInstanceStatus: {}});
+        await waitForLoad();
+        const container = document.querySelector('.MuiTableContainer-root');
+        fireEvent.scroll(container);
+        expect(screen.queryByRole('progressbar')).not.toBeInTheDocument();
     });
 
-    test('executes action and shows snackbar', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText(/Restart/i));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
+    test('URL sync debounced', async () => {
+        jest.useFakeTimers();
+        setup();
+        await waitForLoad();
+        fireEvent.change(screen.getByLabelText('Name'), {target: {value: 'sync'}});
+        jest.advanceTimersByTime(300);
+        expect(mockNavigate).toHaveBeenCalledWith('/objects?name=sync', {replace: true});
+        jest.useRealTimers();
+    });
 
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test1/action/restart'),
-                expect.any(Object)
-            );
+    test('URL filters update state on location change', async () => {
+        const {rerender} = setup();
+        await waitForLoad();
+        require('react-router-dom').useLocation.mockReturnValue({
+            search: '?namespace=test-ns&kind=svc&name=test1',
+            pathname: '/objects',
         });
-
+        rerender(
+            <MemoryRouter>
+                <Objects/>
+            </MemoryRouter>
+        );
         await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/succeeded/i);
+            expect(screen.getByText('test-ns')).toBeInTheDocument();
+            expect(screen.getByText('svc')).toBeInTheDocument();
+            expect(screen.getByLabelText('Name')).toHaveValue('test1');
         });
     });
 
-    test('handles failed action execution', async () => {
-        const originalConsoleErrorInTest = console.error;
-
-        console.error = jest.fn((message, ...args) => {
-            if (typeof message === 'string' &&
-                (message.includes('Failed to execute') ||
-                    message.includes('HTTP error!'))) {
-                return;
-            }
-            originalConsoleErrorInTest.call(console, message, ...args);
-        });
-
-        try {
-            global.fetch.mockImplementation(() =>
-                Promise.resolve({
-                    ok: false,
-                    status: 500,
-                })
-            );
-
-            setupComponent();
-            await waitForComponentToLoad();
-
-            await selectObject('test-ns/svc/test1');
-
-            fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-            fireEvent.click(screen.getByText(/Restart/i));
-
-            await waitFor(() => {
-                expect(screen.getByRole('dialog')).toBeInTheDocument();
-            });
-
-            fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-            await waitFor(() => {
-                expect(screen.getByRole('alert')).toHaveTextContent(/failed/i);
-            });
-        } finally {
-            console.error = originalConsoleErrorInTest;
+    test('snackbar closes on alert close', async () => {
+        setup();
+        await waitForLoad();
+        await selectRow('test-ns/svc/test1');
+        openActionsMenu();
+        await clickMenuItem('Restart');
+        await confirmDialog();
+        await waitFor(() => expect(screen.getByRole('alert')).toBeInTheDocument());
+        const closeBtn = screen.getByRole('alert').querySelector('button[aria-label="Close"]');
+        if (closeBtn) {
+            fireEvent.click(closeBtn);
+            await waitFor(() => expect(screen.queryByRole('alert')).not.toBeInTheDocument());
         }
     });
 
-    test('executes delete action and removes object', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-
-        const menu = screen.getByRole('menu');
-        const deleteOption = within(menu).getByText(/^Delete$/i);
-        fireEvent.click(deleteOption);
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        expect(screen.getByText(/Confirm Delete/i)).toBeInTheDocument();
-
-        const configLossCheckbox = screen.getByLabelText(/Confirm configuration loss/i);
-        const clusterwideCheckbox = screen.getByLabelText(/Confirm clusterwide orchestration/i);
-
-        fireEvent.click(configLossCheckbox);
-        fireEvent.click(clusterwideCheckbox);
-
-        fireEvent.click(screen.getByRole('button', {name: /Delete/i}));
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test1/action/delete'),
-                expect.any(Object)
-            );
-        });
-
-        expect(mockRemoveObject).toHaveBeenCalledWith('test-ns/svc/test1');
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/succeeded/i);
-        });
+    test('cancel action dialog', async () => {
+        setup();
+        await waitForLoad();
+        await selectRow('test-ns/svc/test1');
+        openActionsMenu();
+        await clickMenuItem('Restart');
+        await waitFor(() => expect(screen.getByRole('dialog')).toBeInTheDocument());
+        fireEvent.click(screen.getByRole('button', {name: /cancel/i}));
+        await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument());
+        expect(global.fetch).not.toHaveBeenCalled();
     });
 
-    test('executes purge action with confirmation', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText(/Purge/i));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('checkbox', {name: /Confirm data loss/i}));
-        fireEvent.click(screen.getByRole('checkbox', {name: /Confirm configuration loss/i}));
-        fireEvent.click(screen.getByRole('checkbox', {name: /Confirm service interruption/i}));
-
-        const confirmButton = screen.getByRole('button', {name: /Confirm/i});
-        expect(confirmButton).not.toBeDisabled();
-
-        fireEvent.click(confirmButton);
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test1/action/purge'),
-                expect.any(Object)
-            );
-        });
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/succeeded/i);
-        });
+    test('narrow screen hides node columns', async () => {
+        setup({}, '', false);
+        await waitForLoad();
+        expect(screen.queryByRole('columnheader', {name: /node1/})).not.toBeInTheDocument();
     });
 
-    test('executes stop action with confirmation', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText(/Stop/i));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByLabelText(/I understand that this may interrupt services/i));
-
-        const confirmButton = screen.getByRole('button', {name: /Stop/i});
-        expect(confirmButton).not.toBeDisabled();
-
-        fireEvent.click(confirmButton);
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test1/action/stop'),
-                expect.any(Object)
-            );
-        });
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/succeeded/i);
-        });
+    test('daemon fallback when store empty', async () => {
+        setup(
+            {objectStatus: {}, objectInstanceStatus: {}},
+            '',
+            true,
+            {daemon: {cluster: {object: {'daemon/svc/obj1': {avail: 'up', frozen: 'unfrozen'}}}}}
+        );
+        await waitFor(() =>
+            expect(screen.getByRole('row', {name: /daemon\/svc\/obj1/})).toBeInTheDocument()
+        );
     });
 
-    test('executes unprovision action with confirmation', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-
-        const menu = await screen.findByRole('menu');
-        fireEvent.click(within(menu).getByText(/Unprovision/i));
+    test('unprovisioned object and node', async () => {
+        setup();
+        await waitForLoad();
+        expect(screen.getByLabelText('Object is not provisioned')).toBeInTheDocument();
+        expect(screen.getByLabelText('Node node1 is not provisioned')).toBeInTheDocument();
+    });
 
-        await waitFor(() => {
-            expect(screen.getByRole('dialog', {name: /Confirm Unprovision/i})).toBeInTheDocument();
+    test('cluster object parsed as ccfg', async () => {
+        setup({
+            objectStatus: {cluster: {avail: 'up', frozen: 'unfrozen'}},
+            objectInstanceStatus: {cluster: {node1: {avail: 'up'}}},
         });
-
-        fireEvent.click(screen.getByLabelText(/I understand data will be lost/i));
-        fireEvent.click(screen.getByLabelText(/I understand this action will be orchestrated clusterwide/i));
-        fireEvent.click(screen.getByLabelText(/I understand the selected services may be temporarily interrupted during failover, or durably interrupted if no failover is configured/i));
-
-        const confirmButton = screen.getByRole('button', {name: /Confirm/i});
-        expect(confirmButton).not.toBeDisabled();
-
-        fireEvent.click(confirmButton);
-
-        await waitFor(() => {
+        await waitForLoad();
+        await selectRow('cluster');
+        openActionsMenu();
+        await clickMenuItem('Restart');
+        await confirmDialog();
+        await waitFor(() =>
             expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test1/action/unprovision'),
+                expect.stringContaining('/root/ccfg/cluster/action/restart'),
                 expect.any(Object)
-            );
-        });
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/succeeded/i);
-        });
-    });
-
-    test('toggles filters visibility', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const toggleButton = await screen.findByRole('button', {name: /filters/i});
-        expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
-
-        fireEvent.click(toggleButton);
-
-        await waitFor(() => {
-            expect(toggleButton).toHaveAttribute('aria-label', 'Show filters');
-        });
-        expect(screen.queryByLabelText('Namespace')).not.toBeInTheDocument();
-
-        fireEvent.click(toggleButton);
-
-        await waitFor(() => {
-            expect(toggleButton).toHaveAttribute('aria-label', 'Hide filters');
-        });
-        expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
+            )
+        );
     });
 
-    test('filters objects by global state', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Global State', 'Up');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-        });
-
-        expect(screen.queryByRole('row', {name: /test-ns\/svc\/test2/i})).not.toBeInTheDocument();
-        expect(screen.queryByRole('row', {name: /root\/svc\/test3/i})).not.toBeInTheDocument();
-    });
-
-    test('filters objects by kind', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Kind', 'svc');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByRole('row', {name: /test-ns\/svc\/test2/i})).toBeInTheDocument();
-        expect(screen.getByRole('row', {name: /root\/svc\/test3/i})).toBeInTheDocument();
-    });
-
-    test('displays no objects when objectStatus is empty', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {},
-                objectInstanceStatus: {},
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-
-        await waitFor(() => {
-            expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
-        });
-
-        expect(screen.getAllByRole('row')).toHaveLength(1);
-    });
-
-    test('accessibility check', async () => {
-        const {container} = setupComponent();
-
-        await waitForComponentToLoad();
-
-        const results = await axe(container, {
-            rules: {
-                'aria-prohibited-attr': {enabled: false},
-                'label': {enabled: false}
-            }
+    test('accessibility', async () => {
+        const {container} = setup();
+        await waitForLoad();
+        const results = await axe(container, {
+            rules: {'aria-prohibited-attr': {enabled: false}, label: {enabled: false}},
         });
         expect(results).toHaveNoViolations();
     });
-
-    test('handles objects without instance status', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/test4': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {},
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test4/i})).toBeInTheDocument();
-        });
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/test4/i});
-        expect(row).toBeInTheDocument();
-    });
-
-    test('handles objects with string provisioned status', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/unprovisioned': {avail: 'n/a', frozen: 'unfrozen', provisioned: 'false'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/unprovisioned': {
-                        node1: {avail: 'n/a', frozen_at: '0001-01-01T00:00:00Z', provisioned: 'false'},
-                    },
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/unprovisioned/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByLabelText('Object is not provisioned')).toBeInTheDocument();
-    });
-
-    test('handles objects with boolean provisioned status', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/unprovisioned-bool': {avail: 'n/a', frozen: 'unfrozen', provisioned: false},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/unprovisioned-bool': {
-                        node1: {avail: 'n/a', frozen_at: '0001-01-01T00:00:00Z', provisioned: false},
-                    },
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/unprovisioned-bool/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByLabelText('Object is not provisioned')).toBeInTheDocument();
-    });
-
-    test('handles nodes with not provisioned status', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/node-unprovisioned': {avail: 'up', frozen: 'unfrozen', provisioned: 'true'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/node-unprovisioned': {
-                        node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z', provisioned: 'false'},
-                    },
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/node-unprovisioned/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByLabelText('Node node1 is not provisioned')).toBeInTheDocument();
-    });
-
-    test('handles nodes with non-idle state', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/non-idle': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/non-idle': {
-                        node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'},
-                    },
-                },
-                instanceMonitor: {
-                    'node1:test-ns/svc/non-idle': {state: 'running', global_expect: 'none'},
-                },
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/non-idle/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByText('running')).toBeInTheDocument();
-    });
-
-    test('disables freeze action for frozen objects', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/test1': {avail: 'up', frozen: 'unfrozen'},
-                    'test-ns/svc/test2': {avail: 'down', frozen: 'frozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/test1': {
-                        node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'},
-                    },
-                    'test-ns/svc/test2': {
-                        node1: {avail: 'down', frozen_at: '2025-05-16T10:00:00Z'},
-                    },
-                },
-                instanceMonitor: {
-                    'node1:test-ns/svc/test1': {state: 'running', global_expect: 'none'},
-                    'node1:test-ns/svc/test2': {state: 'idle', global_expect: 'none'},
-                },
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const frozenObjectRow = screen.getByRole('row', {name: /test-ns\/svc\/test2/i});
-        const menuButton = within(frozenObjectRow).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton);
-
-        await waitFor(() => {
-            const menu = screen.getByRole('menu');
-            const freezeAction = within(menu).queryByText('Freeze');
-            expect(freezeAction).not.toBeInTheDocument();
-        });
-    });
-
-    test('disables actions in global menu when not allowed', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/test1/i});
-        const checkbox = within(row).getByRole('checkbox');
-        fireEvent.click(checkbox);
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-
-        const menu = await screen.findByRole('menu');
-
-        const deleteAction = within(menu).getByText('Delete');
-        expect(deleteAction).toBeInTheDocument();
-    });
-
-    test('handles sorting by status column', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const statusHeader = screen.getByText('Status');
-        fireEvent.click(statusHeader);
-
-        await waitFor(() => {
-            expect(screen.getAllByRole('row').length).toBeGreaterThan(1);
-        });
-    });
-
-    test('handles sorting by object name', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const objectHeader = screen.getByText('Object');
-        fireEvent.click(objectHeader);
-
-        await waitFor(() => {
-            expect(screen.getAllByRole('row').length).toBeGreaterThan(1);
-        });
-    });
-
-    test('handles sorting by node status', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const nodeHeader = screen.getByRole('columnheader', {name: /node1/i});
-        fireEvent.click(nodeHeader);
-
-        await waitFor(() => {
-            expect(screen.getAllByRole('row').length).toBeGreaterThan(1);
-        });
-    });
-
-    test('handles sort direction change', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const objectHeader = screen.getByText('Object');
-
-        fireEvent.click(objectHeader);
-
-        fireEvent.click(objectHeader);
-
-        await waitFor(() => {
-            expect(screen.getAllByRole('row').length).toBeGreaterThan(1);
-        });
-    });
-
-    test('prevents navigation for objects without instance status', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/no-instance': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {},
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/no-instance/i})).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('row', {name: /test-ns\/svc\/no-instance/i}));
-
-        expect(mockNavigate).not.toHaveBeenCalled();
-    });
-
-    test('handles narrow screen layout', async () => {
-        const mockUseMediaQuery = require('@mui/material/useMediaQuery');
-        mockUseMediaQuery.mockReturnValue(false);
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        expect(screen.queryByRole('columnheader', {name: /node1/i})).not.toBeInTheDocument();
-        expect(screen.queryByRole('columnheader', {name: /node2/i})).not.toBeInTheDocument();
-    });
-
-    test('handles URL parameter synchronization with invalid globalState', async () => {
-        require('react-router-dom').useLocation.mockReturnValue({
-            search: '?globalState=invalid&namespace=test&kind=svc&name=obj1',
-            pathname: '/objects'
-        });
-
-        setupComponent();
-
-        await waitFor(() => {
-            expect(screen.getByLabelText('Global State')).toBeInTheDocument();
-            expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
-        });
-    });
-
-    test('handles event source setup without auth token', async () => {
-        jest.spyOn(Storage.prototype, 'getItem').mockReturnValue(null);
-
-        setupComponent();
-
-        await waitFor(() => {
-            expect(screen.getByLabelText('Namespace')).toBeInTheDocument();
-        });
-
-        expect(startEventReception).not.toHaveBeenCalled();
-    });
-
-    test('handles action execution with single object target', async () => {
-        setupComponent();
-
-        await waitForComponentToLoad();
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/test1/i});
-        const menuButton = within(row).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton);
-
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test1/action/restart'),
-                expect.any(Object)
-            );
-        });
-    });
-
-    test('handles scroll loading more objects', async () => {
-        const manyObjects = {};
-        const manyInstanceStatus = {};
-        for (let i = 0; i < 50; i++) {
-            const name = `test-ns/svc/obj${i}`;
-            manyObjects[name] = {avail: i % 2 === 0 ? 'up' : 'down', frozen: 'unfrozen'};
-            manyInstanceStatus[name] = {
-                node1: {avail: i % 2 === 0 ? 'up' : 'down', frozen_at: '0001-01-01T00:00:00Z'}
-            };
-        }
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: manyObjects,
-                objectInstanceStatus: manyInstanceStatus,
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const rows = screen.getAllByRole('row').slice(1);
-        expect(rows.length).toBe(30);
-
-        const tableContainer = document.querySelector('.MuiTableContainer-root');
-        Object.defineProperty(tableContainer, 'scrollHeight', {value: 1000});
-        Object.defineProperty(tableContainer, 'clientHeight', {value: 500});
-        Object.defineProperty(tableContainer, 'scrollTop', {value: 500});
-
-        fireEvent.scroll(tableContainer);
-
-        await waitFor(() => {
-            const newRows = screen.getAllByRole('row').slice(1);
-            expect(newRows.length).toBeGreaterThan(30);
-        });
-    });
-
-    test('uses daemon objects as fallback when objectStatus is empty', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {},
-                objectInstanceStatus: {},
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-        useFetchDaemonStatus.mockReturnValue({
-            daemon: {
-                cluster: {
-                    object: {
-                        'daemon/svc/obj1': {avail: 'up', frozen: 'unfrozen'},
-                        'daemon/svc/obj2': {avail: 'down', frozen: 'frozen'},
-                    }
-                }
-            },
-        });
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /daemon\/svc\/obj1/i})).toBeInTheDocument();
-            expect(screen.getByRole('row', {name: /daemon\/svc\/obj2/i})).toBeInTheDocument();
-        });
-    });
-
-    test('filters by unprovisioned global state and finds objects', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Global State', 'Unprovisioned');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/unprovisioned/i})).toBeInTheDocument();
-        });
-        expect(screen.queryByRole('row', {name: /test-ns\/svc\/test1/i})).not.toBeInTheDocument();
-    });
-
-    test('freeze action is available for non-frozen object and unfreeze for frozen', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const row1 = screen.getByRole('row', {name: /test-ns\/svc\/test1/i});
-        const menuButton1 = within(row1).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton1);
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-        let menu = screen.getByRole('menu');
-        expect(within(menu).getByText('Freeze')).toBeInTheDocument();
-        expect(within(menu).queryByText('Unfreeze')).not.toBeInTheDocument();
-
-        fireEvent.keyDown(menu, {key: 'Escape', code: 'Escape'});
-        await waitFor(() => {
-            expect(screen.queryByRole('menu')).not.toBeInTheDocument();
-        });
-
-        const row2 = screen.getByRole('row', {name: /test-ns\/svc\/test2/i});
-        const menuButton2 = within(row2).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton2);
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-        menu = screen.getByRole('menu');
-        expect(within(menu).queryByText('Freeze')).not.toBeInTheDocument();
-        expect(within(menu).getByText('Unfreeze')).toBeInTheDocument();
-    });
-
-    test('executes unfreeze action on frozen object', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test2');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Unfreeze'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/test-ns/svc/test2/action/unfreeze'),
-                expect.any(Object)
-            );
-        });
-    });
-
-    test('handles partial success during action execution', async () => {
-        global.fetch
-            .mockResolvedValueOnce({ok: true})
-            .mockResolvedValueOnce({ok: false, status: 500});
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-        await selectObject('test-ns/svc/test2');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/partially succeeded: 1 ok, 1 errors/i);
-        });
-    });
-
-    test('handles network error during action', async () => {
-        global.fetch.mockRejectedValue(new Error('Network error'));
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/failed on all 1 object\(s\)/i);
-        });
-    });
-
-    test('removes filter chip by clicking delete icon', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Namespace', 'test-ns');
-        await waitForFilterApplied();
-
-        const chip = screen.getByText('test-ns').closest('.MuiChip-root');
-        expect(chip).toBeInTheDocument();
-
-        const deleteIcon = within(chip).getByTestId('CloseIcon');
-        fireEvent.click(deleteIcon);
-
-        await waitFor(() => {
-            expect(screen.queryByText('test-ns')).not.toBeInTheDocument();
-            expect(screen.getByRole('row', {name: /root\/svc\/test3/i})).toBeInTheDocument();
-        });
-    });
-
-    test('global actions button is disabled when no objects selected', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const actionsButton = screen.getByRole('button', {name: /actions on selected objects/i});
-        expect(actionsButton).toBeDisabled();
-    });
-
-    test('row menu closes when clicking outside (backdrop)', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/test1/i});
-        const menuButton = within(row).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton);
-
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-
-        const backdrop = document.querySelector('.MuiModal-backdrop');
-        expect(backdrop).toBeInTheDocument();
-        fireEvent.click(backdrop);
-
-        await waitFor(() => {
-            expect(screen.queryByRole('menu')).not.toBeInTheDocument();
-        });
-    });
-
-    test('sorts by status with n/a values', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const statusHeader = screen.getByText('Status');
-        fireEvent.click(statusHeader);
-
-        await waitFor(() => {
-            const rows = screen.getAllByRole('row').slice(1);
-            const firstRow = rows[0];
-            expect(firstRow).toHaveTextContent(/test-ns\/svc\/test4/i);
-        });
-    });
-
-    test('sorts by node column when some objects lack node data', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const nodeHeader = screen.getByRole('columnheader', {name: /node1/i});
-        fireEvent.click(nodeHeader);
-
-        await waitFor(() => {
-            expect(screen.getAllByRole('row').length).toBeGreaterThan(1);
-        });
-    });
-
-    test('scroll does not load more when already loading', async () => {
-        const manyObjects = {};
-        const manyInstanceStatus = {};
-        for (let i = 0; i < 50; i++) {
-            const name = `test/svc/obj${i}`;
-            manyObjects[name] = {avail: 'up', frozen: 'unfrozen'};
-            manyInstanceStatus[name] = {
-                node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'}
-            };
-        }
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: manyObjects,
-                objectInstanceStatus: manyInstanceStatus,
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getAllByRole('row').slice(1)).toHaveLength(30);
-        });
-
-        const tableContainer = document.querySelector('.MuiTableContainer-root');
-        Object.defineProperty(tableContainer, 'scrollHeight', {value: 1000});
-        Object.defineProperty(tableContainer, 'clientHeight', {value: 500});
-        Object.defineProperty(tableContainer, 'scrollTop', {value: 500});
-
-        fireEvent.scroll(tableContainer);
-
-        await waitFor(() => {
-            expect(screen.getByRole('progressbar')).toBeInTheDocument();
-        });
-
-        fireEvent.scroll(tableContainer);
-
-        await new Promise(r => setTimeout(r, 50));
-        const rows = screen.getAllByRole('row').slice(1);
-        expect(rows.length).toBe(30);
-    });
-
-    test('scroll does not load more when no more objects', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {'test/svc/obj1': {avail: 'up'}},
-                objectInstanceStatus: {},
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const tableContainer = document.querySelector('.MuiTableContainer-root');
-        Object.defineProperty(tableContainer, 'scrollHeight', {value: 1000});
-        Object.defineProperty(tableContainer, 'clientHeight', {value: 500});
-        Object.defineProperty(tableContainer, 'scrollTop', {value: 500});
-
-        fireEvent.scroll(tableContainer);
-
-        expect(screen.queryByRole('progressbar')).not.toBeInTheDocument();
-        const rows = screen.getAllByRole('row').slice(1);
-        expect(rows.length).toBe(1);
-    });
-
-    test('synchronizes URL with debounce', async () => {
-        jest.useFakeTimers();
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const searchInput = screen.getByLabelText('Name');
-        fireEvent.change(searchInput, {target: {value: 'test'}});
-
-        jest.advanceTimersByTime(300);
-
-        await waitFor(() => {
-            expect(mockNavigate).toHaveBeenCalledWith(
-                '/objects?name=test',
-                {replace: true}
-            );
-        });
-
-        jest.useRealTimers();
-    });
-
-    test('updates filters from URL on location change', async () => {
-        const {rerender} = setupComponent();
-        await waitForComponentToLoad();
-
-        require('react-router-dom').useLocation.mockReturnValue({
-            search: '?namespace=test-ns&kind=svc&name=test1',
-            pathname: '/objects'
-        });
-
-        rerender(
-            <MemoryRouter>
-                <Objects/>
-            </MemoryRouter>
-        );
-
-        await waitFor(() => {
-            expect(screen.getByLabelText('Namespace')).toHaveTextContent('test-ns');
-            expect(screen.getByText('test-ns')).toBeInTheDocument();
-            expect(screen.getByText('svc')).toBeInTheDocument();
-            expect(screen.getByLabelText('Name')).toHaveValue('test1');
-        });
-    });
-
-    test('handles parseObjectName with different formats', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'simpleName': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'simpleName': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('simpleName');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/root/svc/simpleName/action/restart'),
-                expect.any(Object)
-            );
-        });
-    });
-
-    test('shows snackbar when token missing on action', async () => {
-        jest.spyOn(Storage.prototype, 'getItem').mockReturnValue(null);
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent('Authentication token not found');
-        });
-    });
-
-    test('closes snackbar after autoHideDuration', async () => {
-        jest.useFakeTimers();
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toBeInTheDocument();
-        });
-
-        jest.advanceTimersByTime(4000);
-
-        await waitFor(() => {
-            expect(screen.queryByRole('alert')).not.toBeInTheDocument();
-        });
-
-        jest.useRealTimers();
-    });
-
-    test('closes snackbar via Alert onClose callback', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toBeInTheDocument();
-        });
-
-        const alertCloseButton = screen.getByRole('alert').querySelector('button[aria-label="Close"]') ||
-            document.querySelector('.MuiAlert-action button');
-
-        if (alertCloseButton) {
-            fireEvent.click(alertCloseButton);
-            await waitFor(() => {
-                expect(screen.queryByRole('alert')).not.toBeInTheDocument();
-            });
-        }
-    });
-
-    test('closes pending action dialog via onClose (cancel button)', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectObject('test-ns/svc/test1');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        const cancelButton = screen.getByRole('button', {name: /cancel/i});
-        fireEvent.click(cancelButton);
-
-        await waitFor(() => {
-            expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
-        });
-
-        expect(global.fetch).not.toHaveBeenCalled();
-    });
-
-    test('handles parseObjectName with two-part format (kind/name)', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'svc/myservice': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'svc/myservice': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /svc\/myservice/i})).toBeInTheDocument();
-        });
-
-        await selectObject('svc/myservice');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/root/svc/myservice/action/restart'),
-                expect.any(Object)
-            );
-        });
-    });
-
-    test('skips action when objectStatus is missing for target object', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {},
-                objectInstanceStatus: {
-                    'test-ns/svc/ghost': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        useFetchDaemonStatus.mockReturnValue({
-            daemon: {
-                cluster: {
-                    object: {
-                        'test-ns/svc/ghost': {avail: 'up', frozen: 'unfrozen'},
-                    }
-                }
-            },
-        });
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/ghost/i})).toBeInTheDocument();
-        });
-
-        await selectObject('test-ns/svc/ghost');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(screen.getByRole('alert')).toHaveTextContent(/failed on all 1 object\(s\)/i);
-        });
-    });
-
-    test('skips freeze action when object is already frozen', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/already-frozen': {avail: 'up', frozen: 'frozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/already-frozen': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /already-frozen/i})).toBeInTheDocument();
-        });
-
-        const row = screen.getByRole('row', {name: /already-frozen/i});
-        const menuButton = within(row).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton);
-
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-
-        const menu = screen.getByRole('menu');
-        expect(within(menu).queryByText('Freeze')).not.toBeInTheDocument();
-        expect(within(menu).getByText('Unfreeze')).toBeInTheDocument();
-    });
-
-    test('skips unfreeze action when object is not frozen', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/not-frozen': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/not-frozen': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /not-frozen/i})).toBeInTheDocument();
-        });
-
-        const row = screen.getByRole('row', {name: /not-frozen/i});
-        const menuButton = within(row).getByRole('button', {name: /more actions/i});
-        fireEvent.click(menuButton);
-
-        await waitFor(() => {
-            expect(screen.getByRole('menu')).toBeInTheDocument();
-        });
-
-        const menu = screen.getByRole('menu');
-        expect(within(menu).getByText('Freeze')).toBeInTheDocument();
-        expect(within(menu).queryByText('Unfreeze')).not.toBeInTheDocument();
-    });
-
-    test('toggles global state filter off by clicking chip delete', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Global State', 'Up');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.queryByRole('row', {name: /test-ns\/svc\/test2/i})).not.toBeInTheDocument();
-        });
-
-        const chip = screen.getByText(/^Up$/i).closest('.MuiChip-root');
-        expect(chip).toBeInTheDocument();
-        const deleteIcon = within(chip).getByTestId('CloseIcon');
-        fireEvent.click(deleteIcon);
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test2/i})).toBeInTheDocument();
-        });
-    });
-
-    test('toggles kind filter off by clicking chip delete', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Kind', 'svc');
-        await waitForFilterApplied();
-
-        const chip = screen.getByText(/^svc$/i).closest('.MuiChip-root');
-        expect(chip).toBeInTheDocument();
-        const deleteIcon = within(chip).getByTestId('CloseIcon');
-        fireEvent.click(deleteIcon);
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-        });
-    });
-
-    test('handles Kind select onChange directly', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const kindSelect = screen.getByLabelText('Kind');
-        fireEvent.mouseDown(kindSelect);
-
-        await waitFor(() => {
-            expect(screen.getByRole('listbox')).toBeInTheDocument();
-        });
-
-        const listbox = screen.getByRole('listbox');
-        const option = within(listbox).getByText('svc');
-        fireEvent.click(option);
-
-        fireEvent.keyDown(listbox, {key: 'Escape', code: 'Escape'});
-
-        await waitFor(() => {
-            expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-        });
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-        });
-    });
-
-    test('node status shows n/a state for missing avail', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/noavail': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/noavail': {
-                        node1: {},
-                    },
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/noavail/i})).toBeInTheDocument();
-        });
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/noavail/i});
-        const cells = within(row).getAllByRole('cell');
-        const nodeCell = cells[3];
-        expect(within(nodeCell).queryByText('-')).not.toBeInTheDocument();
-        expect(within(nodeCell).queryByLabelText(/Node .+ is .+/)).not.toBeInTheDocument();
-        expect(within(nodeCell).queryByLabelText(/Node .+ has warning/)).not.toBeInTheDocument();
-    });
-
-    test('global state filter chip click toggles selection', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Global State', 'Up');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.queryByRole('row', {name: /test-ns\/svc\/test2/i})).not.toBeInTheDocument();
-        });
-
-        const chip = screen.getByText(/^Up$/i).closest('.MuiChip-root');
-        fireEvent.click(chip);
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test2/i})).toBeInTheDocument();
-        });
-    });
-
-    test('renders cluster object name with ccfg kind', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'cluster': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'cluster': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /cluster/i})).toBeInTheDocument();
-        });
-
-        await selectObject('cluster');
-        fireEvent.click(screen.getByRole('button', {name: /actions on selected objects/i}));
-        fireEvent.click(screen.getByText('Restart'));
-
-        await waitFor(() => {
-            expect(screen.getByRole('dialog')).toBeInTheDocument();
-        });
-
-        fireEvent.click(screen.getByRole('button', {name: /Confirm/i}));
-
-        await waitFor(() => {
-            expect(global.fetch).toHaveBeenCalledWith(
-                expect.stringContaining('/root/ccfg/cluster/action/restart'),
-                expect.any(Object)
-            );
-        });
-    });
-
-    test('displays GlobalExpectDisplay as empty when globalExpect is falsy', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/no-expect': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/no-expect': {
-                        node1: {avail: 'up'},
-                    },
-                },
-                instanceMonitor: {
-                    'node1:test-ns/svc/no-expect': {state: 'idle', global_expect: ''},
-                },
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/no-expect/i})).toBeInTheDocument();
-        });
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/no-expect/i});
-        expect(row).toBeInTheDocument();
-    });
-
-    test('multiple filters combined reduce results correctly', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Namespace', 'test-ns');
-        await waitForFilterApplied();
-
-        await selectFilterOption('Global State', 'Up');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-            expect(screen.queryByRole('row', {name: /test-ns\/svc\/test2/i})).not.toBeInTheDocument();
-            expect(screen.queryByRole('row', {name: /root\/svc\/test3/i})).not.toBeInTheDocument();
-        });
-    });
-
-    test('shows empty message when no objects match filters', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const searchInput = screen.getByLabelText('Name');
-        fireEvent.change(searchInput, {target: {value: 'xxxxxxxxxnonexistent'}});
-
-        await waitFor(() => {
-            expect(screen.getByText(/No objects found matching the current filters/i)).toBeInTheDocument();
-        });
-    });
-
-    test('URL contains multiple filter values joined by comma', async () => {
-        jest.useFakeTimers();
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const globalStateSelect = screen.getByLabelText('Global State');
-        fireEvent.mouseDown(globalStateSelect);
-
-        await waitFor(() => {
-            expect(screen.getByRole('listbox')).toBeInTheDocument();
-        });
-
-        const listbox = screen.getByRole('listbox');
-        const upOption = within(listbox).getAllByRole('option').find(o => o.textContent.toLowerCase().includes('up'));
-        const downOption = within(listbox).getAllByRole('option').find(o => o.textContent.toLowerCase().includes('down'));
-
-        fireEvent.click(within(upOption).getByRole('checkbox'));
-        fireEvent.click(within(downOption).getByRole('checkbox'));
-
-        fireEvent.keyDown(listbox, {key: 'Escape'});
-
-        jest.advanceTimersByTime(300);
-
-        await waitFor(() => {
-            expect(mockNavigate).toHaveBeenCalledWith(
-                expect.stringMatching(/globalState=.*up.*down|globalState=.*down.*up/),
-                {replace: true}
-            );
-        });
-
-        jest.useRealTimers();
-    });
-
-    test('NodeStatusIcons memo comparator covered by rendering down state', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {'test-ns/svc/memo-cov': {avail: 'up', frozen: 'unfrozen'}},
-                objectInstanceStatus: {
-                    'test-ns/svc/memo-cov': {
-                        node1: {avail: 'warn', frozen_at: '0001-01-01T00:00:00Z'},
-                    },
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByLabelText('Node node1 has warning')).toBeInTheDocument();
-        });
-    });
-
-    test('NodeStatusIcons renders down state correctly', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {'test-ns/svc/node-down': {avail: 'up', frozen: 'unfrozen'}},
-                objectInstanceStatus: {
-                    'test-ns/svc/node-down': {
-                        node1: {avail: 'down', frozen_at: '2025-01-01T00:00:00Z'},
-                    },
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByLabelText('Node node1 is down')).toBeInTheDocument();
-        });
-
-        const row = screen.getByRole('row', {name: /test-ns\/svc\/node-down/i});
-        const cells = within(row).getAllByRole('cell');
-        expect(cells.length).toBeGreaterThan(3);
-    });
-
-    test('NodeStateDisplay memo comparator covered by rendering non-idle state', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {'test-ns/svc/memo-state-cov': {avail: 'up', frozen: 'unfrozen'}},
-                objectInstanceStatus: {
-                    'test-ns/svc/memo-state-cov': {
-                        node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'},
-                    },
-                },
-                instanceMonitor: {
-                    'node1:test-ns/svc/memo-state-cov': {state: 'starting', global_expect: 'none'},
-                },
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByText('starting')).toBeInTheDocument();
-        });
-    });
-
-    test('NodeStateDisplay renders idle state correctly', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {'test-ns/svc/node-idle': {avail: 'up', frozen: 'unfrozen'}},
-                objectInstanceStatus: {
-                    'test-ns/svc/node-idle': {
-                        node1: {avail: 'up', frozen_at: '0001-01-01T00:00:00Z'},
-                    },
-                },
-                instanceMonitor: {
-                    'node1:test-ns/svc/node-idle': {state: 'running', global_expect: 'none'},
-                },
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/node-idle/i})).toBeInTheDocument();
-        });
-
-        expect(screen.getByText('running')).toBeInTheDocument();
-    });
-
-    test('filteredObjectNames skips objects not matching namespace filter', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const namespaceSelect = screen.getByLabelText('Namespace');
-        fireEvent.mouseDown(namespaceSelect);
-
-        await waitFor(() => {
-            expect(screen.getByRole('listbox')).toBeInTheDocument();
-        });
-
-        const listbox = screen.getByRole('listbox');
-        const rootOption = within(listbox).getAllByRole('option').find(o =>
-            o.textContent.toLowerCase().includes('root')
-        );
-        fireEvent.click(within(rootOption).getByRole('checkbox'));
-        fireEvent.keyDown(listbox, {key: 'Escape'});
-
-        await waitFor(() => {
-            expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-        });
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /root\/svc\/test3/i})).toBeInTheDocument();
-            expect(screen.queryByRole('row', {name: /test-ns\/svc\/test1/i})).not.toBeInTheDocument();
-        });
-    });
-
-    test('filteredObjectNames skips objects not matching kind filter', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/svcobj': {avail: 'up', frozen: 'unfrozen'},
-                    'test-ns/cfg/cfgobj': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/svcobj': {node1: {avail: 'up'}},
-                    'test-ns/cfg/cfgobj': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const kindSelect = screen.getByLabelText('Kind');
-        fireEvent.mouseDown(kindSelect);
-
-        await waitFor(() => {
-            expect(screen.getByRole('listbox')).toBeInTheDocument();
-        });
-
-        const listbox = screen.getByRole('listbox');
-        const cfgOption = within(listbox).getAllByRole('option').find(o =>
-            o.textContent.toLowerCase().includes('cfg')
-        );
-        fireEvent.click(within(cfgOption).getByRole('checkbox'));
-        fireEvent.keyDown(listbox, {key: 'Escape'});
-
-        await waitFor(() => {
-            expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-        });
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/cfg\/cfgobj/i})).toBeInTheDocument();
-            expect(screen.queryByRole('row', {name: /test-ns\/svc\/svcobj/i})).not.toBeInTheDocument();
-        });
-    });
-
-    test('adds global state to filter when clicking chip label (onClick)', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Global State', 'Up');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.queryByRole('row', {name: /test-ns\/svc\/test2/i})).not.toBeInTheDocument();
-        });
-
-        await selectFilterOption('Global State', 'Down');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test2/i})).toBeInTheDocument();
-        });
-    });
-
-    test('adds namespace to filter when using select (add branch)', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Namespace', 'test-ns');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.queryByRole('row', {name: /root\/svc\/test3/i})).not.toBeInTheDocument();
-        });
-
-        await selectFilterOption('Namespace', 'root');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/test1/i})).toBeInTheDocument();
-            expect(screen.getByRole('row', {name: /root\/svc\/test3/i})).toBeInTheDocument();
-        });
-    });
-
-    test('adds kind to filter when using select (add branch)', async () => {
-        useEventStore.mockImplementation((selector) =>
-            selector({
-                objectStatus: {
-                    'test-ns/svc/svcobj': {avail: 'up', frozen: 'unfrozen'},
-                    'test-ns/cfg/cfgobj': {avail: 'up', frozen: 'unfrozen'},
-                },
-                objectInstanceStatus: {
-                    'test-ns/svc/svcobj': {node1: {avail: 'up'}},
-                    'test-ns/cfg/cfgobj': {node1: {avail: 'up'}},
-                },
-                instanceMonitor: {},
-                removeObject: mockRemoveObject,
-            })
-        );
-
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Kind', 'svc');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.queryByRole('row', {name: /test-ns\/cfg\/cfgobj/i})).not.toBeInTheDocument();
-        });
-
-        await selectFilterOption('Kind', 'cfg');
-        await waitForFilterApplied();
-
-        await waitFor(() => {
-            expect(screen.getByRole('row', {name: /test-ns\/svc\/svcobj/i})).toBeInTheDocument();
-            expect(screen.getByRole('row', {name: /test-ns\/cfg\/cfgobj/i})).toBeInTheDocument();
-        });
-    });
-
-    test('GlobalState renderValue shows warn and n/a icons', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        const globalStateSelect = screen.getByLabelText('Global State');
-        fireEvent.mouseDown(globalStateSelect);
-
-        await waitFor(() => {
-            expect(screen.getByRole('listbox')).toBeInTheDocument();
-        });
-
-        const listbox = screen.getByRole('listbox');
-
-        const warnOption = within(listbox).getAllByRole('option').find(o =>
-            o.textContent.toLowerCase().includes('warn')
-        );
-        fireEvent.click(within(warnOption).getByRole('checkbox'));
-
-        const naOption = within(listbox).getAllByRole('option').find(o =>
-            o.textContent.toLowerCase().includes('n/a')
-        );
-        fireEvent.click(within(naOption).getByRole('checkbox'));
-
-        fireEvent.keyDown(listbox, {key: 'Escape'});
-
-        await waitFor(() => {
-            expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-        });
-
-        await waitFor(() => {
-            const chips = document.querySelectorAll('.MuiChip-root');
-            expect(chips.length).toBeGreaterThanOrEqual(2);
-        });
-    });
-
-    test('chip onMouseDown stopPropagation prevents select from reopening', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Global State', 'Up');
-        await waitForFilterApplied();
-
-        const chip = screen.getByText(/^Up$/i).closest('.MuiChip-root');
-        expect(chip).toBeInTheDocument();
-
-        fireEvent.mouseDown(chip);
-
-        await new Promise(r => setTimeout(r, 50));
-        expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-    });
-
-    test('namespace chip onMouseDown stopPropagation prevents select from reopening', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Namespace', 'test-ns');
-        await waitForFilterApplied();
-
-        const chip = screen.getByText('test-ns').closest('.MuiChip-root');
-        expect(chip).toBeInTheDocument();
-
-        fireEvent.mouseDown(chip);
-
-        await new Promise(r => setTimeout(r, 50));
-        expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-    });
-
-    test('kind chip onMouseDown stopPropagation prevents select from reopening', async () => {
-        setupComponent();
-        await waitForComponentToLoad();
-
-        await selectFilterOption('Kind', 'svc');
-        await waitForFilterApplied();
-
-        const chip = screen.getByText(/^svc$/i).closest('.MuiChip-root');
-        expect(chip).toBeInTheDocument();
-
-        fireEvent.mouseDown(chip);
-
-        await new Promise(r => setTimeout(r, 50));
-        expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
-    });
 });
diff --git a/src/components/tests/StatCard.test.jsx b/src/components/tests/StatCard.test.jsx
index abb427dd..7de178fd 100644
--- a/src/components/tests/StatCard.test.jsx
+++ b/src/components/tests/StatCard.test.jsx
@@ -68,8 +68,9 @@ describe('StatCard Component', () => {
     });
 
     test('does not call onClick when not provided', () => {
-        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-        render(<StatCard title="Test" value="42" />);
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {
+        });
+        render(<StatCard title="Test" value="42"/>);
         // eslint-disable-next-line testing-library/no-node-access
         const card = screen.getByText('Test').closest('div');
         fireEvent.click(card);
@@ -78,14 +79,14 @@ describe('StatCard Component', () => {
     });
 
     test('does not have pointer cursor when onClick is not provided', () => {
-        render(<StatCard title="Test" value="42" />);
+        render(<StatCard title="Test" value="42"/>);
         // eslint-disable-next-line testing-library/no-node-access
         const paper = screen.getByText('Test').closest('div');
         expect(paper).toHaveStyle('cursor: default');
     });
 
     test('has pointer cursor when onClick is provided', () => {
-        render(<StatCard title="Test" value="42" onClick={mockOnClick} />);
+        render(<StatCard title="Test" value="42" onClick={mockOnClick}/>);
         // eslint-disable-next-line testing-library/no-node-access
         const paper = screen.getByText('Test').closest('div');
         expect(paper).toHaveStyle('cursor: pointer');
@@ -112,7 +113,7 @@ describe('StatCard Component', () => {
     });
 
     test('renders without onClick and without dynamicHeight', () => {
-        render(<StatCard title="Test" value="42" />);
+        render(<StatCard title="Test" value="42"/>);
         expect(screen.getByText('Test')).toBeInTheDocument();
         expect(screen.getByText('42')).toBeInTheDocument();
     });
diff --git a/src/constants/actions.js b/src/constants/actions.js
index 5c806d2a..694007a1 100644
--- a/src/constants/actions.js
+++ b/src/constants/actions.js
@@ -28,13 +28,13 @@ export const OBJECT_ACTIONS = [
     {name: "restart", icon: <RestartAlt sx={{fontSize: 24}}/>},
     {name: "freeze", icon: <AcUnit sx={{fontSize: 24}}/>},
     {name: "unfreeze", icon: <LockOpen sx={{fontSize: 24}}/>},
-    {name: "delete", icon: <Delete sx={{fontSize: 24}}/>},
     {name: "provision", icon: <Settings sx={{fontSize: 24}}/>},
     {name: "unprovision", icon: <Block sx={{fontSize: 24}}/>},
-    {name: "purge", icon: <CleaningServices sx={{fontSize: 24}}/>},
     {name: "switch", icon: <SwapHoriz sx={{fontSize: 24}}/>},
     {name: "giveback", icon: <Undo sx={{fontSize: 24}}/>},
     {name: "abort", icon: <Cancel sx={{fontSize: 24}}/>},
+    {name: "delete", icon: <Delete sx={{fontSize: 24}}/>, color: "red"},
+    {name: "purge", icon: <CleaningServices sx={{fontSize: 24}}/>, color: "red"},
 ];
 
 export const INSTANCE_ACTIONS = [
@@ -67,13 +67,12 @@ export const NODE_ACTIONS = [
     {name: "drain", icon: <WaterDrop sx={{fontSize: 24}}/>},
     {name: "asset", icon: <Inventory sx={{fontSize: 24}}/>},
     {name: "disk", icon: <Storage sx={{fontSize: 24}}/>},
-    {name: "patch", icon: <Extension sx={{fontSize: 24}}/>},
     {name: "pkg", icon: <Archive sx={{fontSize: 24}}/>},
     {name: "capabilities", icon: <Psychology sx={{fontSize: 24}}/>},
     {name: "sysreport", icon: <Description sx={{fontSize: 24}}/>},
     {name: "provision", icon: <Settings sx={{fontSize: 24}}/>},
     {name: "unprovision", icon: <Block sx={{fontSize: 24}}/>},
-    {name: "delete", icon: <Delete sx={{fontSize: 24}}/>},
     {name: "switch", icon: <SwapHoriz sx={{fontSize: 24}}/>},
     {name: "giveback", icon: <Undo sx={{fontSize: 24}}/>},
+    {name: "delete", icon: <Delete sx={{fontSize: 24}}/>, color: "red"},
 ];
diff --git a/src/eventSourceManager.jsx b/src/eventSourceManager.jsx
index 9e969426..4905faca 100644
--- a/src/eventSourceManager.jsx
+++ b/src/eventSourceManager.jsx
@@ -18,6 +18,7 @@ export const EVENT_TYPES = {
     OBJECT_DELETED: 'ObjectDeleted',
     INSTANCE_MONITOR_UPDATED: 'InstanceMonitorUpdated',
     INSTANCE_CONFIG_UPDATED: 'InstanceConfigUpdated',
+    INSTANCE_CONFIG_DELETED: 'InstanceConfigDeleted',
 };
 
 // Event Source connection event types (these are NOT API events)
@@ -39,6 +40,7 @@ const OBJECT_SPECIFIC_FILTERS = [
     EVENT_TYPES.OBJECT_DELETED,
     EVENT_TYPES.INSTANCE_MONITOR_UPDATED,
     EVENT_TYPES.INSTANCE_CONFIG_UPDATED,
+    EVENT_TYPES.INSTANCE_CONFIG_DELETED,
 ];
 
 // Global state
@@ -51,12 +53,12 @@ let flushTimeoutId = null;
 let eventCount = 0;
 let isFlushing = false;
 let lastFlushTime = 0;
-let needsFlush = false;  // Flag to indicate new events arrived during flush
+let needsFlush = false;
 
 // Safari-specific optimizations
-const SAFARI_BATCH_SIZE = 150; // Larger batches for Safari
-const SAFARI_FLUSH_DELAY = 100; // Longer delay for Safari to reduce thrashing
-const SAFARI_MIN_FLUSH_INTERVAL = 100; // Longer minimum interval for Safari
+const SAFARI_BATCH_SIZE = 150;
+const SAFARI_FLUSH_DELAY = 100;
+const SAFARI_MIN_FLUSH_INTERVAL = 100;
 
 // Performance optimizations
 const MAX_RECONNECT_ATTEMPTS = 10;
@@ -77,6 +79,7 @@ let buffers = {
     instanceMonitor: {},
     instanceConfig: {},
     configUpdated: new Set(),
+    instanceConfigDeleted: [],
 };
 
 // Deep equality check to detect actual changes
@@ -93,7 +96,6 @@ const isEqual = (a, b) => {
         const valA = a[key];
         const valB = b[key];
 
-        // Deep comparison for nested objects
         if (typeof valA === 'object' && typeof valB === 'object') {
             if (!isEqual(valA, valB)) return false;
         } else if (valA !== valB) {
@@ -103,9 +105,7 @@ const isEqual = (a, b) => {
     return true;
 };
 
-// Optimized create query string - ONLY include valid API events
-const createQueryString = (filters = DEFAULT_FILTERS, objectName = null) => {
-    // Filter out any non-API events (like connection events)
+const createQueryString = (filters = DEFAULT_FILTERS, objectName = null, useCache = true) => {
     const validFilters = filters.filter(f => Object.values(EVENT_TYPES).includes(f));
     if (validFilters.length < filters.length) {
         logger.warn(`Invalid filters detected: ${filters.filter(f => !validFilters.includes(f)).join(', ')}. Using only valid ones.`);
@@ -115,11 +115,17 @@ const createQueryString = (filters = DEFAULT_FILTERS, objectName = null) => {
         validFilters.push(...DEFAULT_FILTERS);
     }
 
-    const queryFilters = objectName
-        ? OBJECT_SPECIFIC_FILTERS.map(filter => `${filter},path=${encodeURIComponent(objectName)}`)
-        : validFilters;
+    let queryFilters;
+    if (objectName) {
+        queryFilters = OBJECT_SPECIFIC_FILTERS.map(
+            filter => `${encodeURIComponent(filter)},path=${encodeURIComponent(objectName)}`
+        );
+    } else {
+        queryFilters = validFilters.map(filter => encodeURIComponent(filter));
+    }
 
-    return `cache=true&${queryFilters.map(filter => `filter=${encodeURIComponent(filter)}`).join('&')}`;
+    const cacheParam = useCache ? 'cache=true' : 'cache=false';
+    return `${cacheParam}&${queryFilters.map(filter => `filter=${filter}`).join('&')}`;
 };
 
 // Get current token
@@ -138,9 +144,9 @@ const getAndClearBuffers = () => {
         instanceMonitor: buffers.instanceMonitor,
         instanceConfig: buffers.instanceConfig,
         configUpdated: buffers.configUpdated,
+        instanceConfigDeleted: buffers.instanceConfigDeleted,
     };
 
-    // Reset buffers with new objects
     buffers = {
         objectStatus: {},
         instanceStatus: {},
@@ -151,18 +157,17 @@ const getAndClearBuffers = () => {
         instanceMonitor: {},
         instanceConfig: {},
         configUpdated: new Set(),
+        instanceConfigDeleted: [],
     };
 
     return buffersToFlush;
 };
 
-// Safari-optimized flush using setTimeout instead of requestAnimationFrame
 const flushBuffers = () => {
     if (!isPageActive || isFlushing) return;
 
     const now = performance.now();
     if (now - lastFlushTime < MIN_FLUSH_INTERVAL) {
-        // Too soon, reschedule
         if (!flushTimeoutId) {
             flushTimeoutId = setTimeout(flushBuffers, MIN_FLUSH_INTERVAL - (now - lastFlushTime));
         }
@@ -171,19 +176,60 @@ const flushBuffers = () => {
 
     isFlushing = true;
     lastFlushTime = now;
-    needsFlush = false;  // Reset flag before starting flush
+    needsFlush = false;
 
-    // CRITICAL: Clear timeout ID to allow new events to schedule a fresh flush
     if (flushTimeoutId) {
         clearTimeout(flushTimeoutId);
         flushTimeoutId = null;
     }
 
     try {
-        // Get and clear buffers atomically BEFORE any async operations
         const buffersToFlush = getAndClearBuffers();
+        const pendingDeletes = useEventStore.getState().pendingDeletes || {};
+
+        for (const path in buffersToFlush.instanceStatus) {
+            for (const node in buffersToFlush.instanceStatus[path]) {
+                const key = `${path}:${node}`;
+                if (pendingDeletes[key]) {
+                    delete buffersToFlush.instanceStatus[path][node];
+                }
+            }
+        }
+
+        for (const path in buffersToFlush.instanceConfig) {
+            for (const node in buffersToFlush.instanceConfig[path]) {
+                const key = `${path}:${node}`;
+                if (pendingDeletes[key]) {
+                    delete buffersToFlush.instanceConfig[path][node];
+                }
+            }
+        }
+
+        if (buffersToFlush.configUpdated && buffersToFlush.configUpdated.size > 0) {
+            const filtered = new Set();
+            for (const update of buffersToFlush.configUpdated) {
+                try {
+                    const parsed = JSON.parse(update);
+                    if (parsed.name && parsed.node) {
+                        let ignore = false;
+                        for (const key in pendingDeletes) {
+                            const [path, pendingNode] = key.split(':');
+                            if (pendingNode === parsed.node && path.includes(parsed.name)) {
+                                ignore = true;
+                                break;
+                            }
+                        }
+                        if (!ignore) filtered.add(update);
+                    } else {
+                        filtered.add(update);
+                    }
+                } catch {
+                    filtered.add(update);
+                }
+            }
+            buffersToFlush.configUpdated = filtered;
+        }
 
-        // Count what needs updating
         const hasNodeStatus = Object.keys(buffersToFlush.nodeStatus).length > 0;
         const hasObjectStatus = Object.keys(buffersToFlush.objectStatus).length > 0;
         const hasHeartbeatStatus = Object.keys(buffersToFlush.heartbeatStatus).length > 0;
@@ -193,8 +239,8 @@ const flushBuffers = () => {
         const hasInstanceMonitor = Object.keys(buffersToFlush.instanceMonitor).length > 0;
         const hasInstanceConfig = Object.keys(buffersToFlush.instanceConfig).length > 0;
         const hasConfigUpdated = buffersToFlush.configUpdated.size > 0;
+        const hasInstanceConfigDeleted = buffersToFlush.instanceConfigDeleted.length > 0;
 
-        // Perform updates - get fresh store reference for each update
         if (hasObjectStatus) {
             const store = useEventStore.getState();
             const merged = {...store.objectStatus, ...buffersToFlush.objectStatus};
@@ -219,10 +265,8 @@ const flushBuffers = () => {
                 if (!mergedInst[obj]) {
                     mergedInst[obj] = {};
                 } else {
-                    // Create shallow copy to avoid mutating existing object
                     mergedInst[obj] = {...mergedInst[obj]};
                 }
-                // Merge new data with fresh object copy
                 mergedInst[obj] = {
                     ...mergedInst[obj],
                     ...buffersToFlush.instanceStatus[obj]
@@ -254,6 +298,14 @@ const flushBuffers = () => {
             const store = useEventStore.getState();
             store.setConfigUpdated([...buffersToFlush.configUpdated]);
         }
+        if (hasInstanceConfigDeleted) {
+            const store = useEventStore.getState();
+            for (const {path, node} of buffersToFlush.instanceConfigDeleted) {
+                logger.debug(`🗑️ Flushing InstanceConfigDeleted: path=${path} node=${node}`);
+                store.removeInstanceFromObject(path, node);
+                store.removePendingDelete(path, node);
+            }
+        }
 
         if (eventCount > 0) {
             logger.debug(`✅ Flushed ${eventCount} events`);
@@ -264,11 +316,9 @@ const flushBuffers = () => {
     } finally {
         isFlushing = false;
 
-        // CRITICAL: If new events arrived during flush, schedule another flush
         if (needsFlush && isPageActive) {
             logger.debug('⚡ New events arrived during flush, scheduling immediate re-flush');
             needsFlush = false;
-            // Schedule immediately for the next cycle
             if (eventCount > 0) {
                 setTimeout(flushBuffers, 0);
             }
@@ -276,11 +326,9 @@ const flushBuffers = () => {
     }
 };
 
-// Safari-optimized scheduling
 const scheduleFlush = () => {
     if (!isPageActive) return;
 
-    // If we're currently flushing, just mark that we need another flush
     if (isFlushing) {
         needsFlush = true;
         eventCount++;
@@ -290,7 +338,6 @@ const scheduleFlush = () => {
 
     eventCount++;
 
-    // For large batches, flush immediately
     if (eventCount >= BATCH_SIZE) {
         if (flushTimeoutId) {
             clearTimeout(flushTimeoutId);
@@ -304,7 +351,6 @@ const scheduleFlush = () => {
         return;
     }
 
-    // For first event, flush quickly but not immediately on Safari
     if (eventCount === 1) {
         if (!flushTimeoutId) {
             flushTimeoutId = setTimeout(() => {
@@ -315,7 +361,6 @@ const scheduleFlush = () => {
         return;
     }
 
-    // Otherwise use debouncing
     if (!flushTimeoutId) {
         flushTimeoutId = setTimeout(() => {
             flushTimeoutId = null;
@@ -326,7 +371,6 @@ const scheduleFlush = () => {
     }
 };
 
-// Navigation service
 const navigationService = {
     redirectToAuth: () => {
         window.dispatchEvent(new CustomEvent('om3:auth-redirect', {
@@ -335,7 +379,6 @@ const navigationService = {
     }
 };
 
-// Clear all buffers
 const clearBuffers = () => {
     buffers = {
         objectStatus: {},
@@ -347,6 +390,7 @@ const clearBuffers = () => {
         instanceMonitor: {},
         instanceConfig: {},
         configUpdated: new Set(),
+        instanceConfigDeleted: [],
     };
     if (flushTimeoutId) {
         clearTimeout(flushTimeoutId);
@@ -357,7 +401,10 @@ const clearBuffers = () => {
     needsFlush = false;
 };
 
-// Optimized event handler with reduced overhead
+export const clearEventBuffers = () => {
+    clearBuffers();
+};
+
 const addEventListener = (eventSource, eventType, handler) => {
     eventSource.addEventListener(eventType, (event) => {
         if (!isPageActive) return;
@@ -370,7 +417,6 @@ const addEventListener = (eventSource, eventType, handler) => {
     });
 };
 
-// Optimized buffer update - ALWAYS add to buffer, comparison happens at flush time
 const updateBuffer = (bufferName, key, value) => {
     if (bufferName === 'configUpdated') {
         buffers.configUpdated.add(value);
@@ -379,8 +425,14 @@ const updateBuffer = (bufferName, key, value) => {
         return;
     }
 
+    if (bufferName === 'instanceConfigDeleted') {
+        buffers.instanceConfigDeleted.push(value);
+        logger.debug(`📝 Buffer[instanceConfigDeleted]:`, value);
+        scheduleFlush();
+        return;
+    }
+
     if (bufferName === 'objectStatus') {
-        // CRITICAL: Merge with existing buffer data instead of replacing!
         const existing = buffers.objectStatus[key];
         buffers.objectStatus[key] = existing ? {...existing, ...value} : value;
         logger.debug(`📝 Buffer[objectStatus]: ${key}`, {
@@ -412,7 +464,6 @@ const updateBuffer = (bufferName, key, value) => {
         buffers.instanceMonitor[key] = existing ? {...existing, ...value} : value;
         logger.debug(`📝 Buffer[instanceMonitor]: ${key}`, value);
     } else {
-        // Generic: nodeStatus, nodeMonitor, nodeStats, heartbeatStatus
         const existing = buffers[bufferName][key];
         buffers[bufferName][key] = existing ? {...existing, ...value} : value;
         logger.debug(`📝 Buffer[${bufferName}]: ${key}`, value);
@@ -483,7 +534,7 @@ export const createEventSource = (url, token, filters = DEFAULT_FILTERS) => {
                         updateBuffer('nodeStatus', data.node, data.node_status);
                     }
                     break;
-                case EVENT_TYPES.OBJECT_STATUS_UPDATED:
+                case EVENT_TYPES.OBJECT_STATUS_UPDATED: {
                     const name = data.path || data.labels?.path;
                     if (name && data.object_status) {
                         logger.debug('📩 OBJECT_STATUS_UPDATED event:', {
@@ -500,13 +551,15 @@ export const createEventSource = (url, token, filters = DEFAULT_FILTERS) => {
                         });
                     }
                     break;
-                case EVENT_TYPES.DAEMON_HEARTBEAT_UPDATED:
+                }
+                case EVENT_TYPES.DAEMON_HEARTBEAT_UPDATED: {
                     const nodeName = data.node || data.labels?.node;
                     if (nodeName && data.heartbeat !== undefined) {
                         updateBuffer('heartbeatStatus', nodeName, data.heartbeat);
                     }
                     break;
-                case EVENT_TYPES.OBJECT_DELETED:
+                }
+                case EVENT_TYPES.OBJECT_DELETED: {
                     const objectName = data.path || data.labels?.path;
                     if (objectName) {
                         logger.debug('📩 Received ObjectDeleted event:', JSON.stringify({path: objectName}));
@@ -519,7 +572,8 @@ export const createEventSource = (url, token, filters = DEFAULT_FILTERS) => {
                         logger.warn('⚠️ ObjectDeleted event missing objectName:', data);
                     }
                     break;
-                case EVENT_TYPES.INSTANCE_STATUS_UPDATED:
+                }
+                case EVENT_TYPES.INSTANCE_STATUS_UPDATED: {
                     const instName = data.path || data.labels?.path;
                     if (instName && data.node && data.instance_status) {
                         logger.debug('📩 INSTANCE_STATUS_UPDATED event:', {
@@ -538,6 +592,7 @@ export const createEventSource = (url, token, filters = DEFAULT_FILTERS) => {
                         });
                     }
                     break;
+                }
                 case EVENT_TYPES.NODE_MONITOR_UPDATED:
                     if (data.node && data.node_monitor) {
                         updateBuffer('nodeMonitor', data.node, data.node_monitor);
@@ -554,7 +609,7 @@ export const createEventSource = (url, token, filters = DEFAULT_FILTERS) => {
                         updateBuffer('instanceMonitor', key, data.instance_monitor);
                     }
                     break;
-                case EVENT_TYPES.INSTANCE_CONFIG_UPDATED:
+                case EVENT_TYPES.INSTANCE_CONFIG_UPDATED: {
                     const configName = data.path || data.labels?.path;
                     if (configName && data.node) {
                         if (data.instance_config) {
@@ -565,6 +620,18 @@ export const createEventSource = (url, token, filters = DEFAULT_FILTERS) => {
                         logger.warn('⚠️ InstanceConfigUpdated event missing name or node:', data);
                     }
                     break;
+                }
+                case EVENT_TYPES.INSTANCE_CONFIG_DELETED: {
+                    const deletedPath = data.path || data.labels?.path;
+                    const deletedNode = data.node || data.labels?.node;
+                    if (deletedPath && deletedNode) {
+                        logger.debug('📩 InstanceConfigDeleted event:', {path: deletedPath, node: deletedNode});
+                        updateBuffer('instanceConfigDeleted', null, {path: deletedPath, node: deletedNode});
+                    } else {
+                        logger.warn('⚠️ InstanceConfigDeleted event missing path or node:', data);
+                    }
+                    break;
+                }
             }
             useEventLogStore.getState().addEventLog(eventType, data);
         });
@@ -798,7 +865,6 @@ export const updateEventSourceToken = (newToken) => {
     }
 };
 
-// Update Logger EventSource token
 export const updateLoggerEventSourceToken = (newToken) => {
     if (!newToken) return;
 
@@ -860,24 +926,24 @@ export const closeLoggerEventSource = () => {
     }
 };
 
-export const configureEventSource = (token, objectName = null, filters = DEFAULT_FILTERS) => {
+export const configureEventSource = (token, objectName = null, filters = DEFAULT_FILTERS, useCache = true) => {
     if (!token) {
         logger.error('❌ No token provided for SSE!');
         return;
     }
 
-    const queryString = createQueryString(filters, objectName);
+    const queryString = createQueryString(filters, objectName, useCache);
     const url = `${URL_NODE_EVENT}?${queryString}`;
     closeEventSource();
     currentEventSource = createEventSource(url, token, filters);
 };
 
-export const startEventReception = (token, filters = DEFAULT_FILTERS) => {
+export const startEventReception = (token, filters = DEFAULT_FILTERS, objectName = null, useCache = true) => {
     if (!token) {
         logger.error('❌ No token provided for SSE!');
         return;
     }
-    configureEventSource(token, null, filters);
+    configureEventSource(token, objectName, filters, useCache);
 };
 
 export const configureLoggerEventSource = (token, objectName = null, filters = DEFAULT_FILTERS) => {
diff --git a/src/hooks/useEventStore.js b/src/hooks/useEventStore.js
index c5cfec8e..ca085e2b 100644
--- a/src/hooks/useEventStore.js
+++ b/src/hooks/useEventStore.js
@@ -16,12 +16,9 @@ const parseObjectPath = (objName) => {
 const shallowEqual = (obj1, obj2) => {
     if (obj1 === obj2) return true;
     if (!obj1 || !obj2) return false;
-
     const keys1 = Object.keys(obj1);
     const keys2 = Object.keys(obj2);
-
     if (keys1.length !== keys2.length) return false;
-
     for (let i = 0; i < keys1.length; i++) {
         const key = keys1[i];
         if (obj1[key] !== obj2[key]) return false;
@@ -41,6 +38,16 @@ const useEventStore = create(
             instanceMonitor: {},
             instanceConfig: {},
             configUpdates: [],
+            pendingDeletes: {},
+
+            removePendingDelete: (objectPath, node) => {
+                const key = `${objectPath}:${node}`;
+                set((state) => {
+                    const newPending = {...state.pendingDeletes};
+                    delete newPending[key];
+                    return {pendingDeletes: newPending};
+                });
+            },
 
             removeObject: (objectName) =>
                 set((state) => {
@@ -49,15 +56,12 @@ const useEventStore = create(
                         !state.instanceConfig[objectName]) {
                         return state;
                     }
-
                     const newObjectStatus = {...state.objectStatus};
                     const newObjectInstanceStatus = {...state.objectInstanceStatus};
                     const newInstanceConfig = {...state.instanceConfig};
-
                     delete newObjectStatus[objectName];
                     delete newObjectInstanceStatus[objectName];
                     delete newInstanceConfig[objectName];
-
                     return {
                         objectStatus: newObjectStatus,
                         objectInstanceStatus: newObjectInstanceStatus,
@@ -65,6 +69,37 @@ const useEventStore = create(
                     };
                 }),
 
+            removeInstanceFromObject: (objectPath, node) =>
+                set((state) => {
+                    logger.debug(`🗑️ removeInstanceFromObject: path=${objectPath} node=${node}`);
+                    const newObjectInstanceStatus = {...state.objectInstanceStatus};
+                    const newInstanceConfig = {...state.instanceConfig};
+                    const newInstanceMonitor = {...state.instanceMonitor};
+                    let hasChanges = false;
+
+                    if (newObjectInstanceStatus[objectPath] && newObjectInstanceStatus[objectPath][node]) {
+                        newObjectInstanceStatus[objectPath] = {...newObjectInstanceStatus[objectPath]};
+                        delete newObjectInstanceStatus[objectPath][node];
+                        hasChanges = true;
+                    }
+                    if (newInstanceConfig[objectPath] && newInstanceConfig[objectPath][node]) {
+                        newInstanceConfig[objectPath] = {...newInstanceConfig[objectPath]};
+                        delete newInstanceConfig[objectPath][node];
+                        hasChanges = true;
+                    }
+                    const monitorKey = `${node}:${objectPath}`;
+                    if (newInstanceMonitor[monitorKey]) {
+                        delete newInstanceMonitor[monitorKey];
+                        hasChanges = true;
+                    }
+                    if (!hasChanges) return state;
+                    return {
+                        objectInstanceStatus: newObjectInstanceStatus,
+                        instanceConfig: newInstanceConfig,
+                        instanceMonitor: newInstanceMonitor,
+                    };
+                }),
+
             setObjectStatuses: (objectStatus) =>
                 set((state) => {
                     const isEqual = shallowEqual(state.objectStatus, objectStatus);
@@ -80,35 +115,41 @@ const useEventStore = create(
                     return {objectStatus};
                 }),
 
-            setInstanceStatuses: (instanceStatuses) =>
+            setInstanceStatuses: (instanceStatuses, replace = false) =>
                 set((state) => {
                     let hasChanges = false;
                     const newObjectInstanceStatus = {...state.objectInstanceStatus};
-
                     for (const path in instanceStatuses) {
                         if (!instanceStatuses.hasOwnProperty(path)) continue;
-
+                        const incomingNodes = instanceStatuses[path];
+                        if (replace) {
+                            const rebuilt = {};
+                            for (const node in incomingNodes) {
+                                if (!incomingNodes.hasOwnProperty(node)) continue;
+                                const newStatus = incomingNodes[node];
+                                rebuilt[node] = {node, path, ...newStatus};
+                            }
+                            if (!shallowEqual(newObjectInstanceStatus[path], rebuilt)) {
+                                newObjectInstanceStatus[path] = rebuilt;
+                                hasChanges = true;
+                            }
+                            continue;
+                        }
                         if (!newObjectInstanceStatus[path]) {
                             newObjectInstanceStatus[path] = {};
                             hasChanges = true;
                         } else {
                             newObjectInstanceStatus[path] = {...newObjectInstanceStatus[path]};
                         }
-
-                        for (const node in instanceStatuses[path]) {
-                            if (!instanceStatuses[path].hasOwnProperty(node)) continue;
-
-                            const newStatus = instanceStatuses[path][node];
+                        for (const node in incomingNodes) {
+                            if (!incomingNodes.hasOwnProperty(node)) continue;
+                            const newStatus = incomingNodes[node];
                             const existingData = newObjectInstanceStatus[path][node];
-
                             if (existingData && shallowEqual(existingData, newStatus)) continue;
-
                             hasChanges = true;
-
                             if (newStatus?.encap) {
                                 const existingEncap = existingData?.encap || {};
                                 const mergedEncap = {...existingEncap};
-
                                 for (const containerId in newStatus.encap) {
                                     if (newStatus.encap.hasOwnProperty(containerId)) {
                                         const existingContainer = existingEncap[containerId] || {};
@@ -122,73 +163,35 @@ const useEventStore = create(
                                         };
                                     }
                                 }
-
-                                newObjectInstanceStatus[path][node] = {
-                                    node,
-                                    path,
-                                    ...newStatus,
-                                    encap: mergedEncap,
-                                };
+                                newObjectInstanceStatus[path][node] = {node, path, ...newStatus, encap: mergedEncap};
                             } else {
-                                newObjectInstanceStatus[path][node] = {
-                                    node,
-                                    path,
-                                    ...existingData,
-                                    ...newStatus,
-                                };
+                                newObjectInstanceStatus[path][node] = {node, path, ...existingData, ...newStatus};
                             }
                         }
                     }
-
                     if (!hasChanges) return state;
                     return {objectInstanceStatus: newObjectInstanceStatus};
                 }),
 
             setNodeStatuses: (nodeStatus) =>
-                set((state) => {
-                    if (shallowEqual(state.nodeStatus, nodeStatus)) {
-                        return state;
-                    }
-                    return {nodeStatus};
-                }),
+                set((state) => shallowEqual(state.nodeStatus, nodeStatus) ? state : {nodeStatus}),
 
             setNodeMonitors: (nodeMonitor) =>
-                set((state) => {
-                    if (shallowEqual(state.nodeMonitor, nodeMonitor)) {
-                        return state;
-                    }
-                    return {nodeMonitor};
-                }),
+                set((state) => shallowEqual(state.nodeMonitor, nodeMonitor) ? state : {nodeMonitor}),
 
             setNodeStats: (nodeStats) =>
-                set((state) => {
-                    if (shallowEqual(state.nodeStats, nodeStats)) {
-                        return state;
-                    }
-                    return {nodeStats};
-                }),
+                set((state) => shallowEqual(state.nodeStats, nodeStats) ? state : {nodeStats}),
 
             setHeartbeatStatuses: (heartbeatStatus) =>
-                set((state) => {
-                    if (shallowEqual(state.heartbeatStatus, heartbeatStatus)) {
-                        return state;
-                    }
-                    return {heartbeatStatus};
-                }),
+                set((state) => shallowEqual(state.heartbeatStatus, heartbeatStatus) ? state : {heartbeatStatus}),
 
             setInstanceMonitors: (instanceMonitor) =>
-                set((state) => {
-                    if (shallowEqual(state.instanceMonitor, instanceMonitor)) {
-                        return state;
-                    }
-                    return {instanceMonitor};
-                }),
+                set((state) => shallowEqual(state.instanceMonitor, instanceMonitor) ? state : {instanceMonitor}),
 
             setInstanceConfig: (path, node, config) =>
                 set((state) => {
-                    if (state.instanceConfig[path]?.[node] && shallowEqual(state.instanceConfig[path][node], config)) {
+                    if (state.instanceConfig[path]?.[node] && shallowEqual(state.instanceConfig[path][node], config))
                         return state;
-                    }
                     const newInstanceConfig = {...state.instanceConfig};
                     if (!newInstanceConfig[path]) newInstanceConfig[path] = {};
                     newInstanceConfig[path] = {...newInstanceConfig[path], [node]: config};
@@ -201,10 +204,8 @@ const useEventStore = create(
                     existingState.configUpdates.map((u) => `${u.fullName}:${u.node}`)
                 );
                 const newUpdates = [];
-
                 for (const update of updates) {
                     let name, fullName, node;
-
                     if (typeof update === "object" && update !== null) {
                         if (update.name && update.node) {
                             name = update.name;
@@ -218,33 +219,26 @@ const useEventStore = create(
                             const kind = name === "cluster" ? "ccfg" : "svc";
                             fullName = `${namespace}/${kind}/${name}`;
                             node = update.data?.node || "";
-                        } else {
-                            continue;
-                        }
+                        } else continue;
                     } else if (typeof update === "string") {
                         try {
                             const parsed = JSON.parse(update);
                             if (parsed && parsed.name && parsed.node) {
                                 name = parsed.name;
-                                const namespace = "root";
-                                const kind = name === "cluster" ? "ccfg" : "svc";
+                                const {namespace, kind} = parseObjectPath(name);
                                 fullName = `${namespace}/${kind}/${name}`;
                                 node = parsed.node;
-                            } else {
-                                continue;
-                            }
+                            } else continue;
                         } catch (e) {
                             logger.warn("[useEventStore] Invalid JSON in setConfigUpdated:", update);
                             continue;
                         }
                     }
-
                     if (name && node && !existingKeys.has(`${fullName}:${node}`)) {
                         newUpdates.push({name, fullName, node});
                         existingKeys.add(`${fullName}:${node}`);
                     }
                 }
-
                 if (newUpdates.length > 0) {
                     set((state) => ({
                         configUpdates: [...state.configUpdates, ...newUpdates]
diff --git a/src/tests/eventSourceManager.test.jsx b/src/tests/eventSourceManager.test.jsx
index 10e9cf5c..1bd7ea60 100644
--- a/src/tests/eventSourceManager.test.jsx
+++ b/src/tests/eventSourceManager.test.jsx
@@ -4,15 +4,11 @@ import useEventStore from '../hooks/useEventStore.js';
 import useEventLogStore from '../hooks/useEventLogStore.js';
 import {URL_NODE_EVENT} from '../config/apiPath.js';
 
-// Mock the external dependencies
 jest.mock('event-source-polyfill');
 jest.mock('../hooks/useEventStore.js');
 jest.mock('../hooks/useEventLogStore.js');
-
-// Mock timers
 jest.useFakeTimers();
 
-// Mock performance.now to control flush timing
 let mockNow = 0;
 const originalPerformance = global.performance;
 beforeAll(() => {
@@ -22,166 +18,85 @@ afterAll(() => {
     global.performance = originalPerformance;
 });
 
-// Helper function to simulate shallowEqual logic
 const mockShallowEqual = (a, b) => {
     if (a === b) return true;
     if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return false;
-
     const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-
+    if (keysA.length !== Object.keys(b).length) return false;
     return keysA.every(key => a[key] === b[key]);
 };
 
+// Helper: get handler for a given event type from a mock eventSource
+const getHandler = (eventSource, eventType) =>
+    eventSource.addEventListener.mock.calls.find(c => c[0] === eventType)[1];
+
 describe('eventSourceManager', () => {
-    let mockStore;
-    let mockLogStore;
-    let mockEventSource;
-    let mockLoggerEventSource;
-    let originalConsole;
-    let localStorageMock;
-    let originalDebug;
-    let originalLocation;
+    let mockStore, mockLogStore, mockEventSource, mockLoggerEventSource;
+    let originalConsole, localStorageMock, originalDebug, originalLocation;
 
     beforeEach(() => {
-        // Reset all mocks
         jest.clearAllMocks();
-        // Advance mockNow by a large amount each test so lastFlushTime (module-level, persists
-        // between tests) is always far enough in the past: now - lastFlushTime >= MIN_FLUSH_INTERVAL(10).
-        // Using += 1_000_000 guarantees this even if the previous test flushed at the previous mockNow.
         mockNow += 1_000_000;
 
-        // Setup complete mock store with shallowEqual simulation
         mockStore = {
-            nodeStatus: {},
-            nodeMonitor: {},
-            nodeStats: {},
-            objectStatus: {},
-            objectInstanceStatus: {},
-            heartbeatStatus: {},
-            instanceMonitor: {},
-            instanceConfig: {},
-            configUpdates: [],
-
-            // Mock setters with shallowEqual logic
-            setNodeStatuses: jest.fn((newStatus) => {
-                if (mockShallowEqual(mockStore.nodeStatus, newStatus)) {
-                    return; // Skip update
-                }
-                mockStore.nodeStatus = newStatus;
+            nodeStatus: {}, nodeMonitor: {}, nodeStats: {}, objectStatus: {},
+            objectInstanceStatus: {}, heartbeatStatus: {}, instanceMonitor: {},
+            instanceConfig: {}, configUpdates: [],
+            setNodeStatuses: jest.fn((v) => {
+                if (!mockShallowEqual(mockStore.nodeStatus, v)) mockStore.nodeStatus = v;
             }),
-
-            setNodeMonitors: jest.fn((newMonitor) => {
-                if (mockShallowEqual(mockStore.nodeMonitor, newMonitor)) {
-                    return;
-                }
-                mockStore.nodeMonitor = newMonitor;
+            setNodeMonitors: jest.fn((v) => {
+                if (!mockShallowEqual(mockStore.nodeMonitor, v)) mockStore.nodeMonitor = v;
             }),
-
-            setNodeStats: jest.fn((newStats) => {
-                if (mockShallowEqual(mockStore.nodeStats, newStats)) {
-                    return;
-                }
-                mockStore.nodeStats = newStats;
+            setNodeStats: jest.fn((v) => {
+                if (!mockShallowEqual(mockStore.nodeStats, v)) mockStore.nodeStats = v;
             }),
-
-            setObjectStatuses: jest.fn((newStatus) => {
-                if (mockShallowEqual(mockStore.objectStatus, newStatus)) {
-                    return;
-                }
-                mockStore.objectStatus = newStatus;
+            setObjectStatuses: jest.fn((v) => {
+                if (!mockShallowEqual(mockStore.objectStatus, v)) mockStore.objectStatus = v;
             }),
-
-            setInstanceStatuses: jest.fn((newStatus) => {
-                // For nested object comparison
-                const currentStr = JSON.stringify(mockStore.objectInstanceStatus);
-                const newStr = JSON.stringify(newStatus);
-                if (currentStr === newStr) {
-                    return;
-                }
-                mockStore.objectInstanceStatus = newStatus;
+            setInstanceStatuses: jest.fn((v) => {
+                if (JSON.stringify(mockStore.objectInstanceStatus) !== JSON.stringify(v)) mockStore.objectInstanceStatus = v;
             }),
-
-            setHeartbeatStatuses: jest.fn((newStatus) => {
-                if (mockShallowEqual(mockStore.heartbeatStatus, newStatus)) {
-                    return;
-                }
-                mockStore.heartbeatStatus = newStatus;
+            setHeartbeatStatuses: jest.fn((v) => {
+                if (!mockShallowEqual(mockStore.heartbeatStatus, v)) mockStore.heartbeatStatus = v;
             }),
-
-            setInstanceMonitors: jest.fn((newMonitor) => {
-                if (mockShallowEqual(mockStore.instanceMonitor, newMonitor)) {
-                    return;
-                }
-                mockStore.instanceMonitor = newMonitor;
+            setInstanceMonitors: jest.fn((v) => {
+                if (!mockShallowEqual(mockStore.instanceMonitor, v)) mockStore.instanceMonitor = v;
             }),
-
-            removeObject: jest.fn((objectName) => {
-                delete mockStore.objectStatus[objectName];
-                delete mockStore.objectInstanceStatus[objectName];
-                delete mockStore.instanceConfig[objectName];
+            removeObject: jest.fn((name) => {
+                delete mockStore.objectStatus[name];
+                delete mockStore.objectInstanceStatus[name];
+                delete mockStore.instanceConfig[name];
             }),
-
-            setConfigUpdated: jest.fn((updates) => {
-                mockStore.configUpdates = updates || [];
+            setConfigUpdated: jest.fn((v) => {
+                mockStore.configUpdates = v || [];
             }),
-
             setInstanceConfig: jest.fn((path, node, config) => {
-                if (!mockStore.instanceConfig[path]) {
-                    mockStore.instanceConfig[path] = {};
-                }
-                if (mockShallowEqual(mockStore.instanceConfig[path][node], config)) {
-                    return;
-                }
-                mockStore.instanceConfig[path][node] = config;
+                if (!mockStore.instanceConfig[path]) mockStore.instanceConfig[path] = {};
+                if (!mockShallowEqual(mockStore.instanceConfig[path][node], config))
+                    mockStore.instanceConfig[path][node] = config;
             }),
         };
-
         useEventStore.getState.mockReturnValue(mockStore);
 
-        mockLogStore = {
-            addEventLog: jest.fn(),
-        };
+        mockLogStore = {addEventLog: jest.fn()};
         useEventLogStore.getState.mockReturnValue(mockLogStore);
 
-        // Create a consistent mock EventSource
         mockEventSource = {
-            onopen: jest.fn(),
-            onerror: null,
-            addEventListener: jest.fn(),
-            close: jest.fn(),
-            readyState: 1, // OPEN state
+            onopen: jest.fn(), onerror: null, addEventListener: jest.fn(),
+            close: jest.fn(), readyState: 1,
             url: URL_NODE_EVENT + '?cache=true&filter=NodeStatusUpdated',
         };
-
         mockLoggerEventSource = {
-            onopen: jest.fn(),
-            onerror: null,
-            addEventListener: jest.fn(),
-            close: jest.fn(),
-            readyState: 1,
+            onopen: jest.fn(), onerror: null, addEventListener: jest.fn(),
+            close: jest.fn(), readyState: 1,
             url: URL_NODE_EVENT + '?cache=true&filter=ObjectStatusUpdated',
         };
+        EventSourcePolyfill.mockImplementation(() => mockEventSource);
 
-        // Mock EventSourcePolyfill to return our mock
-        EventSourcePolyfill.mockImplementation(() => {
-            return mockEventSource;
-        });
+        localStorageMock = {getItem: jest.fn(), setItem: jest.fn(), removeItem: jest.fn(), clear: jest.fn()};
+        Object.defineProperty(global, 'localStorage', {value: localStorageMock, writable: true});
 
-        // Mock localStorage properly
-        localStorageMock = {
-            getItem: jest.fn(),
-            setItem: jest.fn(),
-            removeItem: jest.fn(),
-            clear: jest.fn(),
-        };
-        Object.defineProperty(global, 'localStorage', {
-            value: localStorageMock,
-            writable: true
-        });
-
-        // Store original console methods
         originalConsole = {
             log: console.log,
             error: console.error,
@@ -189,30 +104,18 @@ describe('eventSourceManager', () => {
             info: console.info,
             debug: console.debug
         };
-
-        // Mock console methods - capture all debug calls
+        originalDebug = console.debug;
         console.log = jest.fn();
         console.error = jest.fn();
         console.warn = jest.fn();
         console.info = jest.fn();
-        originalDebug = console.debug;
         console.debug = jest.fn();
 
-        // Mock window.location in a non-destructive way
         originalLocation = window.location;
-        Object.defineProperty(window, 'location', {
-            configurable: true,
-            value: {href: ''},
-        });
+        Object.defineProperty(window, 'location', {configurable: true, value: {href: ''}});
         window.oidcUserManager = null;
-
-        // Mock dispatchEvent
         window.dispatchEvent = jest.fn();
-
-        // Mock EventSource for CLOSED
         global.EventSource = {CLOSED: 2};
-
-        // Mock requestAnimationFrame
         global.requestAnimationFrame = jest.fn((cb) => {
             setTimeout(cb, 0);
             return 1;
@@ -220,30 +123,13 @@ describe('eventSourceManager', () => {
     });
 
     afterEach(() => {
-        // Run all pending timers first so isFlushing/flushTimeoutId are properly reset
         jest.runAllTimers();
-
-        // setPageActive(false) calls clearBuffers() which resets flushTimeoutId, eventCount,
-        // isFlushing, needsFlush — prevents stale state leaking between tests
         eventSourceManager.setPageActive(false);
         eventSourceManager.setPageActive(true);
-
         jest.clearAllTimers();
-
-        // Restore console methods
-        console.log = originalConsole.log;
-        console.error = originalConsole.error;
-        console.warn = originalConsole.warn;
-        console.info = originalConsole.info;
+        Object.assign(console, originalConsole);
         console.debug = originalDebug;
-
-        // Restore window.location
-        Object.defineProperty(window, 'location', {
-            configurable: true,
-            value: originalLocation,
-        });
-
-        // Reset module state
+        Object.defineProperty(window, 'location', {configurable: true, value: originalLocation});
         eventSourceManager.closeEventSource();
         eventSourceManager.closeLoggerEventSource();
         delete window.oidcUserManager;
@@ -251,49 +137,38 @@ describe('eventSourceManager', () => {
 
     describe('EventSource lifecycle and management', () => {
         test('should create an EventSource and attach event listeners', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             expect(EventSourcePolyfill).toHaveBeenCalled();
-            expect(eventSource.addEventListener).toHaveBeenCalledTimes(9);
+            expect(es.addEventListener).toHaveBeenCalledTimes(10);
         });
 
         test('should close existing EventSource before creating a new one', () => {
-            // Create first EventSource
-            const firstEventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            expect(firstEventSource.close).not.toHaveBeenCalled();
-
-            // Create second EventSource
-            EventSourcePolyfill.mockImplementationOnce(() => ({
-                ...mockEventSource,
-            }));
+            eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            EventSourcePolyfill.mockImplementationOnce(() => ({...mockEventSource}));
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             expect(mockEventSource.close).toHaveBeenCalled();
         });
 
-        test('should not create EventSource if no token is provided', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, '');
-            expect(eventSource).toBeNull();
+        test('should not create EventSource if no token', () => {
+            expect(eventSourceManager.createEventSource(URL_NODE_EVENT, '')).toBeNull();
             expect(console.error).toHaveBeenCalledWith('❌ Missing token for EventSource!');
         });
 
-        test('should close the EventSource when closeEventSource is called', () => {
+        test('should close EventSource and not throw on missing source', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             eventSourceManager.closeEventSource();
             expect(mockEventSource.close).toHaveBeenCalled();
-        });
-
-        test('should not throw error when closing non-existent EventSource', () => {
             expect(() => eventSourceManager.closeEventSource()).not.toThrow();
         });
 
-        test('should call _cleanup if present', () => {
-            const cleanupSpy = jest.fn();
+        test('should call and handle errors in _cleanup', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const cleanupSpy = jest.fn();
             mockEventSource._cleanup = cleanupSpy;
             eventSourceManager.closeEventSource();
             expect(cleanupSpy).toHaveBeenCalled();
-        });
 
-        test('should handle error in _cleanup', () => {
+            // Error case
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             mockEventSource._cleanup = () => {
                 throw new Error('cleanup error');
@@ -302,309 +177,169 @@ describe('eventSourceManager', () => {
             expect(console.debug).toHaveBeenCalledWith('Error during eventSource cleanup', expect.any(Error));
         });
 
-        test('should return token from localStorage', () => {
+        test('should return token from localStorage or currentToken', () => {
             localStorageMock.getItem.mockReturnValue('local-storage-token');
-            const token = eventSourceManager.getCurrentToken();
-            expect(token).toBe('local-storage-token');
-        });
+            expect(eventSourceManager.getCurrentToken()).toBe('local-storage-token');
 
-        test('should return currentToken if localStorage is empty', () => {
             localStorageMock.getItem.mockReturnValue(null);
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'current-token');
-            const token = eventSourceManager.getCurrentToken();
-            expect(token).toBe('current-token');
+            expect(eventSourceManager.getCurrentToken()).toBe('current-token');
         });
 
-        test('should not update if no new token provided', () => {
+        test('should not update if no new token in updateEventSourceToken', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
             eventSourceManager.updateEventSourceToken('');
             expect(mockEventSource.close).not.toHaveBeenCalled();
         });
 
-        test('should configure EventSource with objectName and custom filters', () => {
-            const customFilters = ['NodeStatusUpdated', 'ObjectStatusUpdated'];
-            eventSourceManager.configureEventSource('fake-token', 'test-object', customFilters);
+        test('should configure EventSource with and without objectName', () => {
+            eventSourceManager.configureEventSource('fake-token', 'test-object', ['NodeStatusUpdated']);
             expect(EventSourcePolyfill).toHaveBeenCalled();
-        });
 
-        test('should handle missing token in configureEventSource', () => {
-            eventSourceManager.configureEventSource('');
-            expect(console.error).toHaveBeenCalledWith('❌ No token provided for SSE!');
-        });
-
-        test('should configure EventSource without objectName', () => {
+            jest.clearAllMocks();
             eventSourceManager.configureEventSource('fake-token');
-            expect(EventSourcePolyfill).toHaveBeenCalled();
             expect(EventSourcePolyfill.mock.calls[0][0]).toContain('cache=true');
+            expect(EventSourcePolyfill.mock.calls[0][0]).not.toContain('path=');
         });
 
-        test('should create an EventSource with valid token via startEventReception', () => {
-            eventSourceManager.startEventReception('fake-token');
-            expect(EventSourcePolyfill).toHaveBeenCalledWith(
-                expect.stringContaining(URL_NODE_EVENT),
-                expect.objectContaining({
-                    headers: expect.objectContaining({
-                        Authorization: 'Bearer fake-token',
-                    }),
-                })
-            );
-        });
-
-        test('should close previous EventSource before creating a new one via startEventReception', () => {
-            eventSourceManager.startEventReception('fake-token');
-            const secondMockEventSource = {
-                onopen: jest.fn(),
-                onerror: null,
-                addEventListener: jest.fn(),
-                close: jest.fn(),
-                readyState: 1,
-            };
-            EventSourcePolyfill.mockImplementationOnce(() => secondMockEventSource);
-            eventSourceManager.startEventReception('fake-token');
-            expect(mockEventSource.close).toHaveBeenCalled();
-            expect(EventSourcePolyfill).toHaveBeenCalledTimes(2);
-        });
-
-        test('should handle missing token in startEventReception', () => {
+        test('should handle missing token in configureEventSource and startEventReception', () => {
+            eventSourceManager.configureEventSource('');
+            expect(console.error).toHaveBeenCalledWith('❌ No token provided for SSE!');
             eventSourceManager.startEventReception('');
             expect(console.error).toHaveBeenCalledWith('❌ No token provided for SSE!');
         });
 
-        test('should start event reception with custom filters', () => {
-            const customFilters = ['NodeStatusUpdated', 'ObjectStatusUpdated'];
-            eventSourceManager.startEventReception('fake-token', customFilters);
-            expect(EventSourcePolyfill).toHaveBeenCalled();
+        test('should startEventReception with valid and custom filters', () => {
+            eventSourceManager.startEventReception('fake-token', ['NodeStatusUpdated', 'ObjectStatusUpdated']);
             expect(EventSourcePolyfill.mock.calls[0][0]).toContain('filter=NodeStatusUpdated');
             expect(EventSourcePolyfill.mock.calls[0][0]).toContain('filter=ObjectStatusUpdated');
         });
 
-        test('should handle connection open event', () => {
+        test('should handle connection open event and log it', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            if (mockEventSource.onopen) {
-                mockEventSource.onopen();
-            }
+            mockEventSource.onopen();
             expect(console.info).toHaveBeenCalledWith('✅ EventSource connection established');
-        });
-
-        test('should log connection opened with correct data', () => {
-            eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            if (mockEventSource.onopen) {
-                mockEventSource.onopen();
-            }
             expect(mockLogStore.addEventLog).toHaveBeenCalledWith('CONNECTION_OPENED', {
-                url: expect.any(String),
-                timestamp: expect.any(String)
+                url: expect.any(String), timestamp: expect.any(String)
             });
         });
 
         test('should log connection error with correct data', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const error = {status: 500, message: 'Test error'};
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror(error);
-            }
+            mockEventSource.onerror({status: 500, message: 'Test error'});
             expect(mockLogStore.addEventLog).toHaveBeenCalledWith('CONNECTION_ERROR', {
-                error: 'Test error',
-                status: 500,
-                url: expect.any(String),
-                timestamp: expect.any(String)
+                error: 'Test error', status: 500, url: expect.any(String), timestamp: expect.any(String)
             });
         });
 
         test('should ignore onerror if not current EventSource', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             eventSourceManager.closeEventSource();
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 500});
-            }
+            mockEventSource.onerror({status: 500});
             expect(console.info).not.toHaveBeenCalledWith(expect.stringContaining('Reconnecting'));
         });
 
-        test('should log reconnection attempt', () => {
+        test('should log reconnection attempt and max reconnections reached', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 500});
-            }
+            mockEventSource.onerror({status: 500});
             expect(mockLogStore.addEventLog).toHaveBeenCalledWith('RECONNECTION_ATTEMPT', expect.any(Object));
-        });
 
-        test('should log max reconnections reached', () => {
-            eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-
-            for (let i = 0; i < 11; i++) {
-                if (mockEventSource.onerror) {
-                    mockEventSource.onerror({status: 500});
-                }
+            for (let i = 0; i < 10; i++) {
+                mockEventSource.onerror({status: 500});
                 jest.advanceTimersByTime(2000);
             }
-
             expect(mockLogStore.addEventLog).toHaveBeenCalledWith('MAX_RECONNECTIONS_REACHED', expect.any(Object));
         });
 
-        test('should handle auth error when new token same as old', () => {
+        test('should handle auth error: same token, no oidcUserManager', () => {
             localStorageMock.getItem.mockReturnValue('old-token');
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 401});
-            }
+            mockEventSource.onerror({status: 401});
             expect(console.warn).toHaveBeenCalledWith('🔐 Authentication error detected');
             expect(window.dispatchEvent).toHaveBeenCalledWith(expect.any(CustomEvent));
         });
 
-        test('should handle auth error without oidcUserManager', () => {
+        test('should handle auth error: new token from storage', () => {
+            localStorageMock.getItem.mockReturnValue('new-token');
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 401});
-            }
-            expect(window.dispatchEvent).toHaveBeenCalledWith(expect.any(CustomEvent));
+            mockEventSource.onerror({status: 401});
+            expect(console.info).toHaveBeenCalledWith('🔄 New token available, updating EventSource');
         });
 
-        test('should handle silent renew failure', async () => {
-            window.oidcUserManager = {signinSilent: jest.fn().mockRejectedValue(new Error('renew fail'))};
+        test('should handle silent renew success and failure', async () => {
+            // Success
+            const mockUser = {access_token: 'silent-renewed-token', expires_at: Date.now() + 3600000};
+            window.oidcUserManager = {signinSilent: jest.fn().mockResolvedValue(mockUser)};
+            localStorageMock.getItem.mockReturnValue(null);
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
+            mockEventSource.onerror({status: 401});
+            await Promise.resolve();
+            expect(localStorageMock.setItem).toHaveBeenCalledWith('authToken', 'silent-renewed-token');
 
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 401});
-            }
-
+            // Failure
+            window.oidcUserManager = {signinSilent: jest.fn().mockRejectedValue(new Error('renew fail'))};
+            eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
+            mockEventSource.onerror({status: 401});
             await Promise.resolve();
             await Promise.resolve();
-
             expect(console.error).toHaveBeenCalledWith('❌ Silent renew failed:', expect.any(Error));
             expect(window.dispatchEvent).toHaveBeenCalledWith(expect.any(CustomEvent));
         });
 
-        test('should update with new token from storage on auth error', () => {
-            localStorageMock.getItem.mockReturnValue('new-token');
-            eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 401});
-            }
-            expect(console.info).toHaveBeenCalledWith('🔄 New token available, updating EventSource');
-        });
-
         test('should log connection closed on closeEventSource', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             eventSourceManager.closeEventSource();
             expect(mockLogStore.addEventLog).toHaveBeenCalledWith('CONNECTION_CLOSED', expect.any(Object));
         });
 
-        // Coverage for lines 726-727, 745: updateEventSourceToken with open EventSource
         test('should restart EventSource when updateEventSourceToken called with open connection', () => {
-            // Create initial EventSource — mockEventSource needs a url for updateEventSourceToken to parse
-            mockEventSource.url = `${URL_NODE_EVENT}?cache=true&filter=NodeStatusUpdated`;
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-
-            // Prepare mock for the recreated EventSource
-            const recreatedMock = {
-                onopen: jest.fn(),
-                onerror: null,
-                addEventListener: jest.fn(),
-                close: jest.fn(),
-                readyState: 1,
-                url: `${URL_NODE_EVENT}?cache=true&filter=NodeStatusUpdated`,
-            };
+            const recreatedMock = {...mockEventSource, close: jest.fn(), addEventListener: jest.fn()};
             EventSourcePolyfill.mockImplementation(() => recreatedMock);
-
-            // updateEventSourceToken closes current source and schedules recreation via setTimeout
             localStorageMock.getItem.mockReturnValue('new-token');
             eventSourceManager.updateEventSourceToken('new-token');
-
-            // Current EventSource should be closed immediately
             expect(mockEventSource.close).toHaveBeenCalled();
-
-            // Advance timers to trigger the setTimeout(..., 100) callback on line 745
             jest.advanceTimersByTime(200);
-
-            // A new EventSource should have been created (line 745 executed)
             expect(EventSourcePolyfill).toHaveBeenCalledTimes(2);
         });
 
-        test('should not restart EventSource when updateEventSourceToken called but connection is closed', () => {
+        test('should not restart EventSource when connection is already closed', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
-            mockEventSource.readyState = 2; // CLOSED
+            mockEventSource.readyState = 2;
             eventSourceManager.updateEventSourceToken('new-token');
-            // Should not create a new one since existing is closed
             expect(EventSourcePolyfill).toHaveBeenCalledTimes(1);
         });
     });
 
     describe('Event processing and buffer management', () => {
-        test('should process NodeStatusUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeStatusUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})};
-            nodeStatusHandler(mockEvent);
+        test('should process NodeStatusUpdated events and skip if unchanged', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            handler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).toHaveBeenCalledWith(expect.objectContaining({node1: {status: 'up'}}));
-        });
 
-        test('should skip NodeStatusUpdated if status unchanged', () => {
             mockStore.nodeStatus = {node1: {status: 'up'}};
-            useEventStore.getState.mockReturnValue(mockStore);
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeStatusUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})};
-            nodeStatusHandler(mockEvent);
+            handler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.runAllTimers();
-
-            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
             expect(mockStore.nodeStatus).toEqual({node1: {status: 'up'}});
         });
 
-        test('should process NodeMonitorUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeMonitorHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeMonitorUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({node: 'node2', node_monitor: {monitor: 'active'}})};
-            nodeMonitorHandler(mockEvent);
-            jest.runAllTimers();
-            expect(mockStore.setNodeMonitors).toHaveBeenCalledWith(expect.objectContaining({node2: {monitor: 'active'}}));
-        });
-
-        test('should flush nodeMonitorBuffer correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeMonitorHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeMonitorUpdated'
-            )[1];
-            nodeMonitorHandler({data: JSON.stringify({node: 'node1', node_monitor: {monitor: 'active'}})});
-            nodeMonitorHandler({data: JSON.stringify({node: 'node2', node_monitor: {monitor: 'inactive'}})});
+        test('should process NodeMonitorUpdated and flush multiple entries', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeMonitorUpdated');
+            handler({data: JSON.stringify({node: 'node1', node_monitor: {monitor: 'active'}})});
+            handler({data: JSON.stringify({node: 'node2', node_monitor: {monitor: 'inactive'}})});
             jest.runAllTimers();
             expect(mockStore.setNodeMonitors).toHaveBeenCalledWith(expect.objectContaining({
-                node1: {monitor: 'active'},
-                node2: {monitor: 'inactive'},
+                node1: {monitor: 'active'}, node2: {monitor: 'inactive'},
             }));
         });
 
-        test('should process NodeStatsUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatsHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeStatsUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({node: 'node3', node_stats: {cpu: 75, memory: 60}})};
-            nodeStatsHandler(mockEvent);
-            jest.runAllTimers();
-            expect(mockStore.setNodeStats).toHaveBeenCalledWith(expect.objectContaining({
-                node3: {
-                    cpu: 75,
-                    memory: 60
-                }
-            }));
-        });
-
-        test('should flush nodeStatsBuffer correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatsHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeStatsUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({node: 'node1', node_stats: {cpu: 50, memory: 70}})};
-            nodeStatsHandler(mockEvent);
+        test('should process NodeStatsUpdated events', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatsUpdated');
+            handler({data: JSON.stringify({node: 'node1', node_stats: {cpu: 50, memory: 70}})});
             jest.runAllTimers();
             expect(mockStore.setNodeStats).toHaveBeenCalledWith(expect.objectContaining({
                 node1: {
@@ -614,323 +349,160 @@ describe('eventSourceManager', () => {
             }));
         });
 
-        test('should process ObjectStatusUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'ObjectStatusUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({path: 'object1', object_status: {status: 'active'}})};
-            objectStatusHandler(mockEvent);
+        test('should process ObjectStatusUpdated with path, labels.path, and handle missing fields', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'ObjectStatusUpdated');
+            handler({data: JSON.stringify({path: 'object1', object_status: {status: 'active'}})});
+            handler({data: JSON.stringify({labels: {path: 'object2'}, object_status: {status: 'ok'}})});
             jest.runAllTimers();
-            expect(mockStore.setObjectStatuses).toHaveBeenCalledWith(expect.objectContaining({object1: {status: 'active'}}));
-        });
-
-        test('should handle ObjectStatusUpdated with labels path', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'ObjectStatusUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({labels: {path: 'object1'}, object_status: {status: 'active'}})};
-            objectStatusHandler(mockEvent);
-            jest.runAllTimers();
-            expect(mockStore.setObjectStatuses).toHaveBeenCalledWith(expect.objectContaining({object1: {status: 'active'}}));
-        });
+            expect(mockStore.setObjectStatuses).toHaveBeenCalledWith(expect.objectContaining({
+                object1: {status: 'active'}, object2: {status: 'ok'},
+            }));
 
-        test('should handle ObjectStatusUpdated with missing name or status', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'ObjectStatusUpdated'
-            )[1];
-            objectStatusHandler({data: JSON.stringify({object_status: {status: 'active'}})});
-            objectStatusHandler({data: JSON.stringify({path: 'object1'})});
+            jest.clearAllMocks();
+            handler({data: JSON.stringify({object_status: {status: 'active'}})});
+            handler({data: JSON.stringify({path: 'object1'})});
             jest.runAllTimers();
             expect(mockStore.setObjectStatuses).not.toHaveBeenCalled();
         });
 
-        test('should process InstanceStatusUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceStatusUpdated'
-            )[1];
-            const mockEvent = {
-                data: JSON.stringify({
-                    path: 'object2',
-                    node: 'node1',
-                    instance_status: {status: 'inactive'},
-                })
-            };
-            instanceStatusHandler(mockEvent);
+        test('should merge objectStatus updates in buffer preserving all fields', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'ObjectStatusUpdated');
+            handler({data: JSON.stringify({path: 'obj1', object_status: {avail: 'up', frozen: false}})});
+            handler({data: JSON.stringify({path: 'obj1', object_status: {avail: 'down', provisioned: true}})});
             jest.runAllTimers();
-            expect(mockStore.setInstanceStatuses).toHaveBeenCalledWith(expect.objectContaining({
-                object2: {node1: {status: 'inactive'}},
+            expect(mockStore.setObjectStatuses).toHaveBeenCalledWith(expect.objectContaining({
+                'obj1': expect.objectContaining({avail: 'down', frozen: false, provisioned: true})
             }));
         });
 
-        test('should handle InstanceStatusUpdated with labels path', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceStatusUpdated'
-            )[1];
-            const mockEvent = {
+        test('should process InstanceStatusUpdated with path, labels.path, handle missing and skip equal', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'InstanceStatusUpdated');
+            handler({data: JSON.stringify({path: 'object1', node: 'node1', instance_status: {status: 'running'}})});
+            handler({
                 data: JSON.stringify({
                     labels: {path: 'object1'},
-                    node: 'node1',
-                    instance_status: {status: 'running'},
-                })
-            };
-            instanceStatusHandler(mockEvent);
-            jest.runAllTimers();
-            expect(mockStore.setInstanceStatuses).toHaveBeenCalledWith(expect.objectContaining({
-                object1: {node1: {status: 'running'}},
-            }));
-        });
-
-        test('should flush instanceStatusBuffer with nested object updates', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceStatusUpdated'
-            )[1];
-            instanceStatusHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node1',
-                    instance_status: {status: 'running'},
-                })
-            });
-            instanceStatusHandler({
-                data: JSON.stringify({
-                    path: 'object1',
                     node: 'node2',
-                    instance_status: {status: 'stopped'},
+                    instance_status: {status: 'stopped'}
                 })
             });
             jest.runAllTimers();
             expect(mockStore.setInstanceStatuses).toHaveBeenCalledWith(expect.objectContaining({
-                object1: {
-                    node1: {status: 'running'},
-                    node2: {status: 'stopped'},
-                },
+                object1: {node1: {status: 'running'}, node2: {status: 'stopped'}}
             }));
-        });
 
-        test('should handle InstanceStatusUpdated with missing fields', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceStatusUpdated'
-            )[1];
-            instanceStatusHandler({data: JSON.stringify({node: 'node1', instance_status: {status: 'running'}})});
-            instanceStatusHandler({data: JSON.stringify({path: 'object1', instance_status: {status: 'running'}})});
-            instanceStatusHandler({data: JSON.stringify({path: 'object1', node: 'node1'})});
+            // Missing fields
+            jest.clearAllMocks();
+            handler({data: JSON.stringify({node: 'node1', instance_status: {status: 'running'}})});
+            handler({data: JSON.stringify({path: 'object1', instance_status: {status: 'running'}})});
+            handler({data: JSON.stringify({path: 'object1', node: 'node1'})});
             jest.runAllTimers();
             expect(mockStore.setInstanceStatuses).not.toHaveBeenCalled();
-        });
 
-        test('should flush heartbeatStatusBuffer correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const heartbeatHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'DaemonHeartbeatUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({node: 'node1', heartbeat: {status: 'alive'}})};
-            heartbeatHandler(mockEvent);
+            // Skip equal
+            mockStore.objectInstanceStatus = {'object1': {'node1': {status: 'running'}}};
+            handler({data: JSON.stringify({path: 'object1', node: 'node1', instance_status: {status: 'running'}})});
             jest.runAllTimers();
-
-            expect(mockStore.setHeartbeatStatuses).toHaveBeenCalledWith(expect.objectContaining({node1: {status: 'alive'}}));
-
-            const flushCalls = console.debug.mock.calls.filter(call =>
-                call[0] && call[0].includes('Flushed')
-            );
-            expect(flushCalls.length).toBeGreaterThan(0);
+            expect(mockStore.objectInstanceStatus).toEqual({'object1': {'node1': {status: 'running'}}});
         });
 
-        test('should handle DaemonHeartbeatUpdated with labels node', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const heartbeatHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'DaemonHeartbeatUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({labels: {node: 'node1'}, heartbeat: {status: 'alive'}})};
-            heartbeatHandler(mockEvent);
-            jest.runAllTimers();
+        test('should process DaemonHeartbeatUpdated with node, labels.node, and handle missing', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'DaemonHeartbeatUpdated');
+
+            handler({data: JSON.stringify({node: 'node1', heartbeat: {status: 'alive'}})});
+            eventSourceManager.forceFlush();
             expect(mockStore.setHeartbeatStatuses).toHaveBeenCalledWith(expect.objectContaining({node1: {status: 'alive'}}));
-        });
 
-        test('should handle DaemonHeartbeatUpdated with missing node or status', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const heartbeatHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'DaemonHeartbeatUpdated'
-            )[1];
-            heartbeatHandler({data: JSON.stringify({heartbeat: {status: 'alive'}})});
-            heartbeatHandler({data: JSON.stringify({node: 'node1'})});
-            jest.runAllTimers();
+            jest.clearAllMocks();
+            mockNow += 100;
+            handler({data: JSON.stringify({labels: {node: 'node2'}, heartbeat: {status: 'alive'}})});
+            eventSourceManager.forceFlush();
+            expect(mockStore.setHeartbeatStatuses).toHaveBeenCalledWith(expect.objectContaining({node2: {status: 'alive'}}));
+
+            jest.clearAllMocks();
+            mockNow += 100;
+            handler({data: JSON.stringify({heartbeat: {status: 'alive'}})});
+            handler({data: JSON.stringify({node: 'node1'})});
+            eventSourceManager.forceFlush();
             expect(mockStore.setHeartbeatStatuses).not.toHaveBeenCalled();
         });
 
-        test('should handle ObjectDeleted with missing name', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectDeletedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'ObjectDeleted'
-            )[1];
-            objectDeletedHandler({data: JSON.stringify({})});
+        test('should process ObjectDeleted with path, labels.path, and handle missing name', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'ObjectDeleted');
+            handler({data: JSON.stringify({})});
             expect(console.warn).toHaveBeenCalledWith('⚠️ ObjectDeleted event missing objectName:', {});
             expect(mockStore.removeObject).not.toHaveBeenCalled();
-        });
 
-        test('should process ObjectDeleted events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectDeletedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'ObjectDeleted'
-            )[1];
-            const mockEvent = {data: JSON.stringify({path: 'object1'})};
-            objectDeletedHandler(mockEvent);
-            jest.runAllTimers();
-            expect(console.debug).toHaveBeenCalledWith('📩 Received ObjectDeleted event:', expect.any(String));
+            handler({data: JSON.stringify({path: 'object1'})});
             expect(mockStore.removeObject).toHaveBeenCalledWith('object1');
-        });
 
-        test('should handle ObjectDeleted with labels path', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectDeletedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'ObjectDeleted'
-            )[1];
-            const mockEvent = {data: JSON.stringify({labels: {path: 'object1'}})};
-            objectDeletedHandler(mockEvent);
-            jest.runAllTimers();
-            expect(mockStore.removeObject).toHaveBeenCalledWith('object1');
+            handler({data: JSON.stringify({labels: {path: 'object2'}})});
+            expect(mockStore.removeObject).toHaveBeenCalledWith('object2');
         });
 
-        test('should process InstanceMonitorUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceMonitorHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceMonitorUpdated'
-            )[1];
-            const mockEvent = {
-                data: JSON.stringify({
-                    node: 'node1',
-                    path: 'object1',
-                    instance_monitor: {monitor: 'active'},
-                })
-            };
-            instanceMonitorHandler(mockEvent);
+        test('should process InstanceMonitorUpdated with and without missing fields, skip equal', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'InstanceMonitorUpdated');
+            handler({data: JSON.stringify({node: 'node1', path: 'object1', instance_monitor: {monitor: 'active'}})});
             jest.runAllTimers();
             expect(mockStore.setInstanceMonitors).toHaveBeenCalledWith(
                 expect.objectContaining({'node1:object1': {monitor: 'active'}})
             );
-        });
 
-        test('should handle InstanceMonitorUpdated with missing fields', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceMonitorHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceMonitorUpdated'
-            )[1];
-            instanceMonitorHandler({data: JSON.stringify({path: 'object1', instance_monitor: {monitor: 'active'}})});
-            instanceMonitorHandler({data: JSON.stringify({node: 'node1', instance_monitor: {monitor: 'active'}})});
-            instanceMonitorHandler({data: JSON.stringify({node: 'node1', path: 'object1'})});
+            jest.clearAllMocks();
+            handler({data: JSON.stringify({path: 'object1', instance_monitor: {monitor: 'active'}})});
+            handler({data: JSON.stringify({node: 'node1', instance_monitor: {monitor: 'active'}})});
+            handler({data: JSON.stringify({node: 'node1', path: 'object1'})});
             jest.runAllTimers();
             expect(mockStore.setInstanceMonitors).not.toHaveBeenCalled();
-        });
 
-        test('should process InstanceConfigUpdated events correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const configUpdatedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceConfigUpdated'
-            )[1];
-            const mockEvent = {
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node1',
-                    instance_config: {config: 'test'}
-                })
-            };
-            configUpdatedHandler(mockEvent);
+            // Skip equal
+            mockStore.instanceMonitor = {'node1:object1': {monitor: 'active'}};
+            handler({data: JSON.stringify({node: 'node1', path: 'object1', instance_monitor: {monitor: 'active'}})});
             jest.runAllTimers();
-            expect(mockStore.setInstanceConfig).toHaveBeenCalledWith('object1', 'node1', {config: 'test'});
-            expect(mockStore.setConfigUpdated).toHaveBeenCalled();
+            expect(mockStore.instanceMonitor).toEqual({'node1:object1': {monitor: 'active'}});
         });
 
-        test('should handle InstanceConfigUpdated with labels path', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const configUpdatedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceConfigUpdated'
-            )[1];
-            const mockEvent = {data: JSON.stringify({labels: {path: 'object1'}, node: 'node1'})};
-            configUpdatedHandler(mockEvent);
-            jest.runAllTimers();
+        test('should process InstanceConfigUpdated with config, labels.path, missing fields, and multiple nodes', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'InstanceConfigUpdated');
+
+            handler({data: JSON.stringify({path: 'object1', node: 'node1', instance_config: {config: 'v1'}})});
+            handler({data: JSON.stringify({path: 'object1', node: 'node2', instance_config: {config: 'v2'}})});
+            eventSourceManager.forceFlush();
+            expect(mockStore.setInstanceConfig).toHaveBeenCalledWith('object1', 'node1', {config: 'v1'});
+            expect(mockStore.setInstanceConfig).toHaveBeenCalledWith('object1', 'node2', {config: 'v2'});
+            expect(mockStore.setConfigUpdated).toHaveBeenCalled();
+
+            jest.clearAllMocks();
+            mockNow += 100;
+            handler({data: JSON.stringify({labels: {path: 'object1'}, node: 'node1'})});
+            eventSourceManager.forceFlush();
             expect(mockStore.setConfigUpdated).toHaveBeenCalledWith(expect.arrayContaining([expect.any(String)]));
-        });
 
-        test('should handle InstanceConfigUpdated with missing name or node', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const configUpdatedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceConfigUpdated'
-            )[1];
-            configUpdatedHandler({data: JSON.stringify({node: 'node1'})});
-            configUpdatedHandler({data: JSON.stringify({path: 'object1'})});
+            jest.clearAllMocks();
+            mockNow += 100;
+            handler({data: JSON.stringify({node: 'node1'})});
+            handler({data: JSON.stringify({path: 'object1'})});
+            eventSourceManager.forceFlush();
             expect(console.warn).toHaveBeenCalledWith('⚠️ InstanceConfigUpdated event missing name or node:', expect.any(Object));
             expect(mockStore.setConfigUpdated).not.toHaveBeenCalled();
         });
 
         test('should handle invalid JSON in events', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: 'invalid json'});
-            expect(console.warn).toHaveBeenCalledWith('⚠️ Invalid JSON in NodeStatusUpdated event:', 'invalid json');
-        });
-
-        test('should process multiple events and flush buffers correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'ObjectStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            objectStatusHandler({data: JSON.stringify({path: 'obj1', object_status: {status: 'active'}})});
-            jest.runAllTimers();
-            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-            expect(mockStore.setObjectStatuses).toHaveBeenCalled();
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            getHandler(es, 'NodeStatusUpdated')({data: 'invalid json {['});
+            expect(console.warn).toHaveBeenCalledWith('⚠️ Invalid JSON in NodeStatusUpdated event:', 'invalid json {[');
         });
 
         test('should handle empty buffers gracefully', () => {
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).not.toHaveBeenCalled();
-        });
-
-        test('should handle instanceConfig buffer correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const configUpdatedHandler = eventSource.addEventListener.mock.calls.find(
-                (call) => call[0] === 'InstanceConfigUpdated'
-            )[1];
-            const mockEvent = {
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node1',
-                    instance_config: {config: 'test-value'}
-                })
-            };
-            configUpdatedHandler(mockEvent);
-            jest.runAllTimers();
-            expect(mockStore.setInstanceConfig).toHaveBeenCalledWith('object1', 'node1', {config: 'test-value'});
-        });
-
-        test('should handle multiple buffers correctly', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'ObjectStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            objectStatusHandler({data: JSON.stringify({path: 'obj1', object_status: {status: 'active'}})});
-            jest.runAllTimers();
-            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-            expect(mockStore.setObjectStatuses).toHaveBeenCalled();
-        });
-
-        test('should handle empty buffers without errors', () => {
             eventSourceManager.forceFlush();
             expect(console.error).not.toHaveBeenCalled();
         });
@@ -939,544 +511,160 @@ describe('eventSourceManager', () => {
             mockStore.setNodeStatuses.mockImplementation(() => {
                 throw new Error('Test error');
             });
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.runAllTimers();
             expect(console.error).toHaveBeenCalledWith('Error during buffer flush:', expect.any(Error));
         });
 
-        test('should not flush when already flushing', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            eventSourceManager.forceFlush();
-            jest.runAllTimers();
-            expect(console.error).not.toHaveBeenCalled();
-        });
-
-        test('should handle configUpdated buffer type', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const configUpdatedHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'InstanceConfigUpdated'
-            )[1];
-            configUpdatedHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node1'
-                })
-            });
-            jest.runAllTimers();
-            expect(mockStore.setConfigUpdated).toHaveBeenCalled();
-        });
-
-        test('should skip update when instanceStatus values are equal', () => {
-            mockStore.objectInstanceStatus = {'object1': {'node1': {status: 'running'}}};
-            useEventStore.getState.mockReturnValue(mockStore);
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'InstanceStatusUpdated'
-            )[1];
-            instanceStatusHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node1',
-                    instance_status: {status: 'running'}
-                })
-            });
-            jest.runAllTimers();
-
-            expect(mockStore.setInstanceStatuses).toHaveBeenCalled();
-            expect(mockStore.objectInstanceStatus).toEqual({'object1': {'node1': {status: 'running'}}});
-        });
-
-        test('should skip update when instanceMonitor values are equal', () => {
-            mockStore.instanceMonitor = {'node1:object1': {monitor: 'active'}};
-            useEventStore.getState.mockReturnValue(mockStore);
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const instanceMonitorHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'InstanceMonitorUpdated'
-            )[1];
-            instanceMonitorHandler({
-                data: JSON.stringify({
-                    node: 'node1',
-                    path: 'object1',
-                    instance_monitor: {monitor: 'active'}
-                })
-            });
-            jest.runAllTimers();
-
-            expect(mockStore.setInstanceMonitors).toHaveBeenCalled();
-            expect(mockStore.instanceMonitor).toEqual({'node1:object1': {monitor: 'active'}});
-        });
-
-        test('should clear existing timeout when eventCount reaches BATCH_SIZE', () => {
-            const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            for (let i = 0; i < 100; i++) {
-                nodeStatusHandler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
-            }
-            expect(clearTimeoutSpy).toHaveBeenCalled();
-            clearTimeoutSpy.mockRestore();
-        });
-
-        test('should handle invalid JSON in event data', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            const invalidEvent = {data: 'invalid json {['};
-            nodeStatusHandler(invalidEvent);
-            expect(console.warn).toHaveBeenCalledWith('⚠️ Invalid JSON in NodeStatusUpdated event:', 'invalid json {[');
-        });
-
-        test('should clear all buffers and reset state', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+        test('should clear all buffers and reset state via setPageActive', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             eventSourceManager.setPageActive(false);
             eventSourceManager.setPageActive(true);
             eventSourceManager.forceFlush();
             expect(mockStore.setNodeStatuses).not.toHaveBeenCalled();
         });
 
-        test('should handle multiple instance config updates', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const configUpdatedHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'InstanceConfigUpdated'
-            )[1];
-            configUpdatedHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node1',
-                    instance_config: {config: 'v1'}
-                })
-            });
-            configUpdatedHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    node: 'node2',
-                    instance_config: {config: 'v2'}
-                })
-            });
-            jest.runAllTimers();
-            expect(mockStore.setInstanceConfig).toHaveBeenCalledTimes(2);
-            expect(mockStore.setInstanceConfig).toHaveBeenCalledWith('object1', 'node1', {config: 'v1'});
-            expect(mockStore.setInstanceConfig).toHaveBeenCalledWith('object1', 'node2', {config: 'v2'});
-        });
-
         test('should not flush when page not active', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             eventSourceManager.setPageActive(false);
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).not.toHaveBeenCalled();
         });
 
-        test('should reschedule flush if too soon', () => {
-            const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            eventSourceManager.forceFlush();
-            jest.advanceTimersByTime(0);
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            expect(setTimeoutSpy).toHaveBeenCalled();
-            setTimeoutSpy.mockRestore();
-        });
-
-        test('should flush immediately on reconnect if buffered', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            mockEventSource.onopen();
-            jest.runAllTimers();
-            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-        });
-
-        test('should handle Safari batch updates', async () => {
-            const originalUserAgent = navigator.userAgent;
-            Object.defineProperty(navigator, 'userAgent', {
-                value: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15',
-                writable: true
-            });
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            await Promise.resolve();
-            jest.runAllTimers();
-            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-            Object.defineProperty(navigator, 'userAgent', {value: originalUserAgent});
-        });
-
-        test('should use Safari constants', () => {
-            const originalUserAgent = navigator.userAgent;
-            Object.defineProperty(navigator, 'userAgent', {
-                value: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15',
-                writable: true
-            });
-            eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = mockEventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-            for (let i = 0; i < 150; i++) {
-                nodeStatusHandler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
-            }
-            jest.runAllTimers();
-            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-            Object.defineProperty(navigator, 'userAgent', {value: originalUserAgent});
-        });
-
-        test('should flush large batches immediately in Safari', () => {
-            const originalUserAgent = navigator.userAgent;
-            Object.defineProperty(navigator, 'userAgent', {
-                value: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15',
-                writable: true
-            });
-
-            jest.isolateModules(async () => {
-                const eventSourceManager = require('../eventSourceManager');
-                const mockSafariEventSource = {
-                    onopen: jest.fn(),
-                    onerror: null,
-                    addEventListener: jest.fn(),
-                    close: jest.fn(),
-                    readyState: 1,
-                };
-                EventSourcePolyfill.mockImplementation(() => mockSafariEventSource);
-
-                const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-                eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-                const nodeStatusHandler = mockSafariEventSource.addEventListener.mock.calls.find(
-                    call => call[0] === 'NodeStatusUpdated'
-                )[1];
-
-                for (let i = 0; i < 150; i++) {
-                    nodeStatusHandler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
-                }
-
-                expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 0);
-                setTimeoutSpy.mockRestore();
-            });
-
-            Object.defineProperty(navigator, 'userAgent', {value: originalUserAgent});
+        test('should clear existing timeout when eventCount reaches BATCH_SIZE', () => {
+            const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            for (let i = 0; i < 100; i++)
+                handler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
+            expect(clearTimeoutSpy).toHaveBeenCalled();
+            clearTimeoutSpy.mockRestore();
         });
 
-        test('should reschedule flush when MIN_FLUSH_INTERVAL not elapsed and no existing timeout', () => {
+        test('should reschedule flush when MIN_FLUSH_INTERVAL not elapsed', () => {
             const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // First flush at current mockNow to set lastFlushTime = mockNow
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            handler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.clearAllTimers();
             const flushTime = mockNow;
-            eventSourceManager.forceFlush(); // lastFlushTime = flushTime
-
-            // Move only 2ms forward (< MIN_FLUSH_INTERVAL=10) so next flush is "too soon"
+            eventSourceManager.forceFlush();
             mockNow = flushTime + 2;
-
-            nodeStatusHandler({data: JSON.stringify({node: 'node2', node_status: {status: 'down'}})});
+            handler({data: JSON.stringify({node: 'node2', node_status: {status: 'down'}})});
             jest.clearAllTimers();
             setTimeoutSpy.mockClear();
-            // forceFlush -> flushBuffers: elapsed=2 < 10 -> must reschedule via setTimeout
             eventSourceManager.forceFlush();
-
             expect(setTimeoutSpy).toHaveBeenCalled();
-
-            // Advance time so interval passes and flush completes
             mockNow = flushTime + 100000;
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-
             setTimeoutSpy.mockRestore();
         });
 
         test('should clear pending flushTimeoutId when flushBuffers starts', () => {
             const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Send an event — schedules a debounce timeout (flushTimeoutId is set)
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-
-            // Now call forceFlush directly — it first clears flushTimeoutId (lines 285-288 path),
-            // then calls flushBuffers which also checks/clears flushTimeoutId
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             clearTimeoutSpy.mockClear();
             eventSourceManager.forceFlush();
-
-            // clearTimeout should have been called to cancel the pending debounce timer
             expect(clearTimeoutSpy).toHaveBeenCalled();
             expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-
             clearTimeoutSpy.mockRestore();
         });
 
         test('should set needsFlush when event arrives during active flush', () => {
-            let handlerRef;
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            handlerRef = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Replace setNodeStatuses to capture calls and send a new event while isFlushing=true
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
             let callCount = 0;
             mockStore.setNodeStatuses = jest.fn(() => {
-                callCount++;
-                if (callCount === 1) {
-                    // isFlushing=true here — scheduleFlush hits the needsFlush branch
-                    // and logs the debug message, sets needsFlush=true, eventCount++, returns early
-                    handlerRef({data: JSON.stringify({node: 'node99', node_status: {status: 'up'}})});
-                }
+                if (++callCount === 1)
+                    handler({data: JSON.stringify({node: 'node99', node_status: {status: 'up'}})});
             });
-
-            handlerRef({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+            handler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.clearAllTimers();
             eventSourceManager.forceFlush();
-
-            // The debug log proves the isFlushing branch was entered
-            // The log is a single template string with no second argument
-            expect(console.debug).toHaveBeenCalledWith(
-                expect.stringContaining('Event arrived during flush')
-            );
+            expect(console.debug).toHaveBeenCalledWith(expect.stringContaining('Event arrived during flush'));
         });
 
         test('should debounce multiple rapid events into a single flush', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Send 3 events rapidly — all land in the buffer before any timer fires
-            nodeStatusHandler({data: JSON.stringify({node: 'n1', node_status: {status: 'up'}})});
-            nodeStatusHandler({data: JSON.stringify({node: 'n2', node_status: {status: 'down'}})});
-            nodeStatusHandler({data: JSON.stringify({node: 'n3', node_status: {status: 'up'}})});
-
-            // Only one flush should occur when timer fires
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            handler({data: JSON.stringify({node: 'n1', node_status: {status: 'up'}})});
+            handler({data: JSON.stringify({node: 'n2', node_status: {status: 'down'}})});
+            handler({data: JSON.stringify({node: 'n3', node_status: {status: 'up'}})});
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).toHaveBeenCalledTimes(1);
             expect(mockStore.setNodeStatuses).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    n1: {status: 'up'},
-                    n2: {status: 'down'},
-                    n3: {status: 'up'},
-                })
+                expect.objectContaining({n1: {status: 'up'}, n2: {status: 'down'}, n3: {status: 'up'}})
             );
         });
 
-        test('should skip flush in debounce callback when eventCount already drained', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Send event — schedules debounce timeout, eventCount=1
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-
-            // forceFlush drains the buffer synchronously: eventCount becomes 0
+        test('should skip debounce callback when eventCount already drained', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            handler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             eventSourceManager.forceFlush();
             mockStore.setNodeStatuses.mockClear();
-
-            // Now fire the debounce timeout — eventCount=0 so flushBuffers is NOT called
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).not.toHaveBeenCalled();
         });
 
-        test('should merge nested objectStatus updates preserving all fields', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'ObjectStatusUpdated'
-            )[1];
-
-            // Two updates to the same path — updateBuffer merges with spread operator
-            objectStatusHandler({
-                data: JSON.stringify({
-                    path: 'svc/test',
-                    object_status: {avail: 'up', frozen: false, instances: {n1: 'running'}}
-                })
-            });
-            objectStatusHandler({
-                data: JSON.stringify({
-                    path: 'svc/test',
-                    object_status: {avail: 'down', provisioned: true}
-                })
-            });
-
-            jest.runAllTimers();
-
-            // Merged result must contain fields from both events
-            expect(mockStore.setObjectStatuses).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    'svc/test': expect.objectContaining({
-                        avail: 'down',
-                        frozen: false,
-                        provisioned: true,
-                    })
-                })
-            );
-        });
-
-        test('should use requestAnimationFrame for non-Safari batch size flush', () => {
+        test('should use requestAnimationFrame for non-Safari BATCH_SIZE flush', () => {
             const rafSpy = jest.spyOn(global, 'requestAnimationFrame');
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // BATCH_SIZE for non-Safari = 50; the 50th event hits eventCount >= BATCH_SIZE
-            // which calls requestAnimationFrame(flushBuffers) instead of a debounced setTimeout
-            for (let i = 0; i < 50; i++) {
-                nodeStatusHandler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
-            }
-
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            for (let i = 0; i < 50; i++)
+                handler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
             expect(rafSpy).toHaveBeenCalled();
-
             rafSpy.mockRestore();
             jest.runAllTimers();
         });
 
-        test('should schedule re-flush when new events arrive during flush', () => {
-            let flushCallCount = 0;
-            const originalSetNodeStatuses = mockStore.setNodeStatuses;
-            mockStore.setNodeStatuses = jest.fn(() => {
-                flushCallCount++;
-                // During flush, simulate a new event arriving by directly incrementing eventCount
-                // This is tested indirectly via the needsFlush flag behavior
-            });
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Send initial event
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-            // Send a second event to trigger needsFlush scenario
-            nodeStatusHandler({data: JSON.stringify({node: 'node2', node_status: {status: 'down'}})});
-
+        test('should flush immediately on reconnect if buffered', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+            mockEventSource.onopen();
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).toHaveBeenCalled();
-            mockStore.setNodeStatuses = originalSetNodeStatuses;
         });
 
-        test('should deeply compare nested objects in isEqual', () => {
-            // The isEqual function is exercised internally during buffer merging
-            // Test by updating the same key twice with nested objects
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'ObjectStatusUpdated'
-            )[1];
-
-            // First event with nested object
-            objectStatusHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    object_status: {
-                        availability: 'up',
-                        instances: {node1: {status: 'running'}, node2: {status: 'idle'}}
-                    }
-                })
-            });
-
-            // Second event that partially updates the same object (merging behavior)
-            objectStatusHandler({
-                data: JSON.stringify({
-                    path: 'object1',
-                    object_status: {
-                        availability: 'down',
-                        instances: {node1: {status: 'stopped'}, node2: {status: 'idle'}}
-                    }
-                })
+        test('should handle Safari batch updates', () => {
+            const originalUA = navigator.userAgent;
+            Object.defineProperty(navigator, 'userAgent', {
+                value: 'Mozilla/5.0 AppleWebKit/605.1.15 Version/14.0 Safari/605.1.15', writable: true
             });
-
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            const handler = getHandler(es, 'NodeStatusUpdated');
+            for (let i = 0; i < 150; i++)
+                handler({data: JSON.stringify({node: `node${i}`, node_status: {status: 'up'}})});
             jest.runAllTimers();
-            expect(mockStore.setObjectStatuses).toHaveBeenCalled();
-        });
-
-        test('should merge object status updates in buffer before flush', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const objectStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'ObjectStatusUpdated'
-            )[1];
-
-            objectStatusHandler({data: JSON.stringify({path: 'obj1', object_status: {field1: 'a', field2: 'b'}})});
-            objectStatusHandler({data: JSON.stringify({path: 'obj1', object_status: {field2: 'c', field3: 'd'}})});
-
-            jest.runAllTimers();
-            // The merged result should contain all fields
-            expect(mockStore.setObjectStatuses).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    obj1: expect.objectContaining({field1: 'a', field2: 'c', field3: 'd'})
-                })
-            );
+            expect(mockStore.setNodeStatuses).toHaveBeenCalled();
+            Object.defineProperty(navigator, 'userAgent', {value: originalUA});
         });
 
-        test('should handle isEqual comparison with null and non-null values', () => {
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Initially store has null/empty status
+        test('should handle isEqual comparison with null values', () => {
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
             mockStore.nodeStatus = {node1: null};
-
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.runAllTimers();
             expect(mockStore.setNodeStatuses).toHaveBeenCalled();
         });
     });
 
     describe('Error handling and reconnection', () => {
-        test('should handle errors and try to reconnect', () => {
+        test('should handle errors and try to reconnect with exponential backoff', () => {
+            const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 500});
-            }
+            mockEventSource.onerror({status: 500});
             expect(console.error).toHaveBeenCalled();
             expect(console.info).toHaveBeenCalledWith(expect.stringContaining('Reconnecting in'));
-        });
-
-        test('should handle 401 error with silent token renewal', async () => {
-            const mockUser = {
-                access_token: 'silent-renewed-token',
-                expires_at: Date.now() + 3600000
-            };
-            window.oidcUserManager = {signinSilent: jest.fn().mockResolvedValue(mockUser)};
-            localStorageMock.getItem.mockReturnValue(null);
-            eventSourceManager.createEventSource(URL_NODE_EVENT, 'old-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 401});
-            }
-            await Promise.resolve();
-            expect(window.oidcUserManager.signinSilent).toHaveBeenCalled();
-            expect(localStorageMock.setItem).toHaveBeenCalledWith('authToken', 'silent-renewed-token');
+            const delay = setTimeoutSpy.mock.calls[0][1];
+            expect(delay).toBeGreaterThanOrEqual(1000);
+            expect(delay).toBeLessThanOrEqual(30000);
+            setTimeoutSpy.mockRestore();
         });
 
         test('should not redirect if page not active on max attempts', () => {
@@ -1491,7 +679,7 @@ describe('eventSourceManager', () => {
                     onerror: jest.fn(),
                     addEventListener: jest.fn(),
                     close: jest.fn(),
-                    readyState: 1,
+                    readyState: 1
                 };
                 EventSourcePolyfill.mockImplementation(() => currentMock);
             }
@@ -1499,63 +687,31 @@ describe('eventSourceManager', () => {
             expect(window.dispatchEvent).not.toHaveBeenCalled();
         });
 
-        test('should schedule reconnection with exponential backoff', () => {
-            const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-            eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 500});
-            }
-            expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), expect.any(Number));
-            const delay = setTimeoutSpy.mock.calls[0][1];
-            expect(delay).toBeGreaterThanOrEqual(1000);
-            expect(delay).toBeLessThanOrEqual(30000);
-            setTimeoutSpy.mockRestore();
-        });
-
         test('should not reconnect when no current token', () => {
             localStorageMock.getItem.mockReturnValue(null);
             eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            if (mockEventSource.onerror) {
-                mockEventSource.onerror({status: 500});
-            }
+            mockEventSource.onerror({status: 500});
             jest.advanceTimersByTime(2000);
             expect(EventSourcePolyfill).toHaveBeenCalledTimes(1);
         });
     });
 
     describe('Utility functions and helpers', () => {
-        test('should create query string with default filters', () => {
+        test('should handle valid, invalid, and empty filters in createQueryString', () => {
             eventSourceManager.configureEventSource('fake-token');
-            expect(EventSourcePolyfill).toHaveBeenCalledWith(expect.stringContaining('cache=true'), expect.any(Object));
-        });
+            expect(EventSourcePolyfill.mock.calls[0][0]).toContain('cache=true');
 
-        test('should handle invalid filters in createQueryString', () => {
+            jest.clearAllMocks();
             eventSourceManager.configureEventSource('fake-token', null, ['InvalidFilter', 'NodeStatusUpdated']);
             expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid filters detected'));
             expect(EventSourcePolyfill.mock.calls[0][0]).toContain('filter=NodeStatusUpdated');
-        });
-
-        test('should handle invalid filters and fallback to defaults', () => {
-            eventSourceManager.configureEventSource('fake-token', null, ['InvalidFilter1', 'InvalidFilter2']);
-            expect(console.warn).toHaveBeenCalledWith(
-                'Invalid filters detected: InvalidFilter1, InvalidFilter2. Using only valid ones.'
-            );
-            expect(EventSourcePolyfill).toHaveBeenCalled();
-        });
 
-        test('should handle empty filters array', () => {
+            jest.clearAllMocks();
             eventSourceManager.configureEventSource('fake-token', null, []);
             expect(console.warn).toHaveBeenCalledWith('No valid API event filters provided, using default filters');
             expect(EventSourcePolyfill).toHaveBeenCalled();
         });
 
-        test('should create query string without objectName', () => {
-            eventSourceManager.configureEventSource('fake-token');
-            const url = EventSourcePolyfill.mock.calls[0][0];
-            expect(url).toContain('cache=true');
-            expect(url).not.toContain('path=');
-        });
-
         test('should dispatch auth redirect event', () => {
             eventSourceManager.navigationService.redirectToAuth();
             expect(window.dispatchEvent).toHaveBeenCalledWith(expect.any(CustomEvent));
@@ -1565,31 +721,17 @@ describe('eventSourceManager', () => {
         });
 
         test('should export prepareForNavigation as alias for forceFlush', () => {
-            expect(eventSourceManager.prepareForNavigation).toBeDefined();
             expect(typeof eventSourceManager.prepareForNavigation).toBe('function');
-
-            const eventSource = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
-            const nodeStatusHandler = eventSource.addEventListener.mock.calls.find(
-                call => call[0] === 'NodeStatusUpdated'
-            )[1];
-
-            // Send event to populate buffer (eventCount > 0)
-            nodeStatusHandler({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
-
-            // Cancel the debounce timer so only prepareForNavigation triggers the flush
+            const es = eventSourceManager.createEventSource(URL_NODE_EVENT, 'fake-token');
+            getHandler(es, 'NodeStatusUpdated')({data: JSON.stringify({node: 'node1', node_status: {status: 'up'}})});
             jest.clearAllTimers();
-
             eventSourceManager.prepareForNavigation();
-
             expect(mockStore.setNodeStatuses).toHaveBeenCalled();
         });
 
         test('should configure EventSource with objectName - adds path to filter URL', () => {
             eventSourceManager.configureEventSource('fake-token', 'my-service/svc1');
-            const url = EventSourcePolyfill.mock.calls[0][0];
-            // objectName is encoded in the filter param as "EventType,path=objectName"
-            // after encodeURIComponent: %2Cpath%3D
-            expect(url).toContain('path%3D');
+            expect(EventSourcePolyfill.mock.calls[0][0]).toContain('path');
         });
     });
 
@@ -1598,56 +740,64 @@ describe('eventSourceManager', () => {
             EventSourcePolyfill.mockImplementation(() => mockLoggerEventSource);
         });
 
-        test('should create logger EventSource and attach listeners based on filters', () => {
-            const filters = ['ObjectStatusUpdated', 'InstanceStatusUpdated'];
-            const loggerSource = eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', filters);
-            expect(EventSourcePolyfill).toHaveBeenCalledTimes(1);
-            expect(loggerSource.addEventListener).toHaveBeenCalledTimes(2);
-            expect(loggerSource.addEventListener.mock.calls[0][0]).toBe('ObjectStatusUpdated');
-            expect(loggerSource.addEventListener.mock.calls[1][0]).toBe('InstanceStatusUpdated');
+        test('should create logger EventSource and attach listeners for valid filters only', () => {
+            const ls = eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token',
+                ['ObjectStatusUpdated', 'InstanceStatusUpdated', 'Invalid']);
+            expect(ls.addEventListener).toHaveBeenCalledTimes(2);
+            expect(ls.addEventListener.mock.calls[0][0]).toBe('ObjectStatusUpdated');
         });
 
-        test('should close existing logger EventSource before creating new', () => {
+        test('should close existing logger before creating new, and not throw if none', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
-            expect(mockLoggerEventSource.close).not.toHaveBeenCalled();
             EventSourcePolyfill.mockImplementationOnce(() => ({...mockLoggerEventSource}));
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
             expect(mockLoggerEventSource.close).toHaveBeenCalled();
+            expect(() => eventSourceManager.closeLoggerEventSource()).not.toThrow();
         });
 
         test('should not create logger if no token', () => {
-            const source = eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, '', []);
-            expect(source).toBeNull();
+            expect(eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, '', [])).toBeNull();
             expect(console.error).toHaveBeenCalledWith('❌ Missing token for Logger EventSource!');
         });
 
-        test('should handle open event but not log it', () => {
+        test('should handle open and error events without logging them', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
             mockLoggerEventSource.onopen();
             expect(console.info).toHaveBeenCalledWith('✅ Logger EventSource connection established');
             expect(mockLogStore.addEventLog).not.toHaveBeenCalledWith('CONNECTION_OPENED', expect.any(Object));
-        });
 
-        test('should handle error but not log connection error', () => {
-            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
-            const error = {message: 'test error', status: 500};
-            mockLoggerEventSource.onerror(error);
+            mockLoggerEventSource.onerror({message: 'test error', status: 500});
             expect(console.error).toHaveBeenCalled();
             expect(mockLogStore.addEventLog).not.toHaveBeenCalledWith('CONNECTION_ERROR', expect.any(Object));
         });
 
-        test('should handle 401 error in logger with silent renew', async () => {
+        test('should handle 401 in logger: new token, silent renew success and failure', async () => {
+            // New token from storage
+            localStorageMock.getItem.mockReturnValue('new-token');
+            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
+            mockLoggerEventSource.onerror({status: 401});
+            expect(console.info).toHaveBeenCalledWith('🔄 New token available, updating Logger EventSource');
+
+            // Silent renew success
             const mockUser = {access_token: 'new-logger-token', expires_at: Date.now() + 3600000};
             window.oidcUserManager = {signinSilent: jest.fn().mockResolvedValue(mockUser)};
             localStorageMock.getItem.mockReturnValue(null);
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
             mockLoggerEventSource.onerror({status: 401});
             await Promise.resolve();
-            expect(window.oidcUserManager.signinSilent).toHaveBeenCalled();
             expect(localStorageMock.setItem).toHaveBeenCalledWith('authToken', 'new-logger-token');
+
+            // Silent renew failure
+            window.oidcUserManager = {signinSilent: jest.fn().mockRejectedValue(new Error('logger renew fail'))};
+            localStorageMock.getItem.mockReturnValue(null);
+            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
+            mockLoggerEventSource.onerror({status: 401});
+            await Promise.resolve();
+            await Promise.resolve();
+            expect(console.error).toHaveBeenCalledWith('❌ Silent renew failed for logger:', expect.any(Error));
         });
 
-        test('should handle max reconnections in logger without logging', () => {
+        test('should handle max reconnections in logger without connection logging', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
             for (let i = 0; i < 15; i++) {
                 mockLoggerEventSource.onerror({status: 500});
@@ -1658,28 +808,33 @@ describe('eventSourceManager', () => {
             expect(window.dispatchEvent).toHaveBeenCalledWith(expect.any(CustomEvent));
         });
 
-        test('should process events and log them', () => {
+        test('should process events and log them, handle invalid JSON', () => {
+            eventSourceManager.setPageActive(true);
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', ['ObjectStatusUpdated']);
             const handler = mockLoggerEventSource.addEventListener.mock.calls[0][1];
             handler({data: JSON.stringify({path: 'test'})});
             expect(mockLogStore.addEventLog).toHaveBeenCalledWith('ObjectStatusUpdated', expect.any(Object));
+
+            handler({data: 'not valid json'});
+            expect(mockLogStore.addEventLog).toHaveBeenCalledWith('ObjectStatusUpdated_PARSE_ERROR',
+                expect.objectContaining({error: expect.any(String), rawData: 'not valid json'})
+            );
         });
 
-        test('should ignore invalid filters', () => {
-            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', ['Invalid', 'ObjectStatusUpdated']);
-            expect(mockLoggerEventSource.addEventListener).toHaveBeenCalledTimes(1);
-            expect(mockLoggerEventSource.addEventListener.mock.calls[0][0]).toBe('ObjectStatusUpdated');
+        test('should ignore events when page not active', () => {
+            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', ['ObjectStatusUpdated']);
+            eventSourceManager.setPageActive(false);
+            mockLoggerEventSource.addEventListener.mock.calls[0][1]({data: JSON.stringify({path: 'test'})});
+            expect(mockLogStore.addEventLog).not.toHaveBeenCalled();
         });
 
-        test('should call _cleanup on close', () => {
-            const cleanupSpy = jest.fn();
+        test('should call and handle errors in logger _cleanup', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
+            const cleanupSpy = jest.fn();
             mockLoggerEventSource._cleanup = cleanupSpy;
             eventSourceManager.closeLoggerEventSource();
             expect(cleanupSpy).toHaveBeenCalled();
-        });
 
-        test('should handle error in _cleanup for logger', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
             mockLoggerEventSource._cleanup = () => {
                 throw new Error('logger cleanup error');
@@ -1688,41 +843,19 @@ describe('eventSourceManager', () => {
             expect(console.debug).toHaveBeenCalledWith('Error during logger eventSource cleanup', expect.any(Error));
         });
 
-        test('should not throw if no logger source', () => {
-            expect(() => eventSourceManager.closeLoggerEventSource()).not.toThrow();
-        });
-
-        test('should not update if no new token', () => {
+        test('should not update logger if no new token', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
             eventSourceManager.updateLoggerEventSourceToken('');
             expect(mockLoggerEventSource.close).not.toHaveBeenCalled();
         });
 
-        test('should handle missing token in configureLoggerEventSource', () => {
+        test('should handle missing token in configureLoggerEventSource and startLoggerReception', () => {
             eventSourceManager.configureLoggerEventSource('');
             expect(console.error).toHaveBeenCalledWith('❌ No token provided for Logger SSE!');
-        });
-
-        test('should handle missing token in startLoggerReception', () => {
             eventSourceManager.startLoggerReception('');
             expect(console.error).toHaveBeenCalledWith('❌ No token provided for Logger SSE!');
         });
 
-        test('should ignore events when page not active', () => {
-            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', ['ObjectStatusUpdated']);
-            eventSourceManager.setPageActive(false);
-            const handler = mockLoggerEventSource.addEventListener.mock.calls[0][1];
-            handler({data: JSON.stringify({path: 'test'})});
-            expect(mockLogStore.addEventLog).not.toHaveBeenCalled();
-        });
-
-        test('should update logger with new token from storage on auth error', () => {
-            localStorageMock.getItem.mockReturnValue('new-token');
-            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
-            mockLoggerEventSource.onerror({status: 401});
-            expect(console.info).toHaveBeenCalledWith('🔄 New token available, updating Logger EventSource');
-        });
-
         test('should ignore onerror if not current logger EventSource', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', []);
             eventSourceManager.closeLoggerEventSource();
@@ -1732,73 +865,29 @@ describe('eventSourceManager', () => {
 
         test('should restart logger EventSource when updateLoggerEventSourceToken called with open connection', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', ['ObjectStatusUpdated']);
-
-            const nextLoggerMock = {
-                onopen: jest.fn(),
-                onerror: null,
-                addEventListener: jest.fn(),
-                close: jest.fn(),
-                readyState: 1,
-                url: `${URL_NODE_EVENT}?cache=true&filter=ObjectStatusUpdated`,
-            };
-            EventSourcePolyfill.mockImplementation(() => nextLoggerMock);
-
-            // getCurrentToken() is called inside the setTimeout callback —
-            // make localStorage return the new token so the callback proceeds
+            const nextMock = {...mockLoggerEventSource, close: jest.fn(), addEventListener: jest.fn()};
+            EventSourcePolyfill.mockImplementation(() => nextMock);
             localStorageMock.getItem.mockReturnValue('new-token');
-
             eventSourceManager.updateLoggerEventSourceToken('new-token');
             expect(mockLoggerEventSource.close).toHaveBeenCalled();
-
-            // Fire the setTimeout(..., 100) callback — calls createLoggerEventSource
             jest.advanceTimersByTime(200);
             expect(EventSourcePolyfill).toHaveBeenCalledTimes(2);
         });
 
         test('should not restart logger EventSource when connection is already closed', () => {
             eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
-            mockLoggerEventSource.readyState = 2; // CLOSED
+            mockLoggerEventSource.readyState = 2;
             eventSourceManager.updateLoggerEventSourceToken('new-token');
             expect(EventSourcePolyfill).toHaveBeenCalledTimes(1);
         });
-        test('should configure logger EventSource with objectName', () => {
+
+        test('should configure and start logger with objectName', () => {
             eventSourceManager.configureLoggerEventSource('fake-token', 'my-service/svc1');
-            const url = EventSourcePolyfill.mock.calls[0][0];
-            expect(url).toContain('path%3D');
-        });
+            expect(EventSourcePolyfill.mock.calls[0][0]).toContain('path');
 
-        test('should start logger reception with objectName', () => {
+            jest.clearAllMocks();
             eventSourceManager.startLoggerReception('fake-token', eventSourceManager.DEFAULT_FILTERS, 'my-service/svc1');
-            const url = EventSourcePolyfill.mock.calls[0][0];
-            expect(url).toContain('path%3D');
-        });
-
-        test('should handle invalid JSON in logger event and log parse error', () => {
-            // Ensure page is active (setPageActive(false) in other tests may have left it false)
-            eventSourceManager.setPageActive(true);
-            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'fake-token', ['ObjectStatusUpdated']);
-            const handler = mockLoggerEventSource.addEventListener.mock.calls[0][1];
-            handler({data: 'not valid json'});
-            expect(mockLogStore.addEventLog).toHaveBeenCalledWith(
-                'ObjectStatusUpdated_PARSE_ERROR',
-                expect.objectContaining({
-                    error: expect.any(String),
-                    rawData: 'not valid json'
-                })
-            );
-        });
-
-        test('should handle silent renew failure in logger', async () => {
-            window.oidcUserManager = {signinSilent: jest.fn().mockRejectedValue(new Error('logger renew fail'))};
-            localStorageMock.getItem.mockReturnValue(null);
-            eventSourceManager.createLoggerEventSource(URL_NODE_EVENT, 'old-token', []);
-            mockLoggerEventSource.onerror({status: 401});
-
-            await Promise.resolve();
-            await Promise.resolve();
-
-            expect(console.error).toHaveBeenCalledWith('❌ Silent renew failed for logger:', expect.any(Error));
-            expect(window.dispatchEvent).toHaveBeenCalledWith(expect.any(CustomEvent));
+            expect(EventSourcePolyfill.mock.calls[0][0]).toContain('path');
         });
     });
 });