Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

23.3 KB
Raw Blame
import { createEffect, createMemo, onCleanup, type Accessor } from 'solid-js';
import { useNavigate } from '@solidjs/router';
import {
  RuntimeInventorySourcesAPI,
  type RuntimeInventorySourcesResponse,
} from '@/api/runtimeInventorySources';
import { recordWorkloadHistoryActivity } from '@/api/workloadHistoryActivity';
import type { Node } from '@/types/api';
import type { Resource } from '@/types/resource';
import type { ViewMode, WorkloadGuest, WorkloadType } from '@/types/workloads';
import { useWebSocket } from '@/contexts/appRuntime';
import { useAlertsActivation } from '@/stores/alertsActivation';
import { sessionCanReadInfrastructureSettings } from '@/stores/sessionSettingsCapabilities';
import { usePersistentSignal } from '@/hooks/usePersistentSignal';
import { createNonSuspendingQuery } from '@/hooks/createNonSuspendingQuery';
import { useUnifiedResources } from '@/hooks/useUnifiedResources';
import { useWorkloads } from '@/hooks/useWorkloads';
import {
  getWorkloadsDisconnectedState,
  getWorkloadsGuestsEmptyState,
  getWorkloadsInfrastructureEmptyState,
  getWorkloadsLoadingState,
  getWorkloadsNoInventoryState,
} from '@/utils/workloadEmptyStatePresentation';
import { getCanonicalWorkloadId, getWorkloadMetadataId } from '@/utils/workloads';
import { nodeFromResource } from '@/utils/resourceStateAdapters';
import { STORAGE_KEYS } from '@/utils/localStorage';
import {
  createWorkloadSortComparator,
  filterWorkloads,
  selectVisibleWorkloadInventory,
  type FilterWorkloadsParams,
} from './workloadSelectors';
import {
  type WorkloadsGroupingMode,
  type WorkloadsMemoryDisplayBasis,
  type WorkloadsMetricDisplayMode,
  type WorkloadsMetricHoverMode,
  type WorkloadsSortKey,
} from './workloadsFilterModel';
import { type WorkloadTableMetricHistoryRange } from './workloadMetricHistoryModel';
import { useWorkloadsControlsState } from './useWorkloadsControlsState';
import { useWorkloadGuestMetadataState } from './useWorkloadGuestMetadataState';
import { useWorkloadSelectionState } from './useWorkloadSelectionState';
import { useWorkloadsDerivedState } from './useWorkloadsDerivedState';
import { useWorkloadRouteState } from './useWorkloadRouteState';
import { buildWorkloadInventorySourceIssues } from './workloadInventorySourceIssues';
import { useWorkloadTableMetricHistory } from './useWorkloadTableMetricHistory';
import {
  buildNestedWorkloadContextByGuestId,
  type NestedWorkloadContextByGuestId,
} from './nestedWorkloadContext';
import { buildGuestParentNodeMapFromNodes } from './workloadTopology';

const WORKLOADS_INFRASTRUCTURE_SOURCES_QUERY =
  'type=agent,docker-host,k8s-cluster,k8s-node,pbs,pmg,storage,physical_disk,ceph';
const WORKLOADS_INVENTORY_SOURCES_POLL_INTERVAL_MS = 15000;
const EMPTY_INVENTORY_SOURCES_RESPONSE: RuntimeInventorySourcesResponse = {
  sources: [],
};

const isProxmoxNodeResource = (resource: Resource): boolean =>
  resource.type === 'agent' &&
  (resource.platformType === 'proxmox-pve' ||
    Boolean(resource.proxmox) ||
    Boolean(resource.platformData?.proxmox));

export interface WorkloadsStateOptions {
  layoutWidth?: Accessor<number | null | undefined>;
  forcedPlatform?: string;
  forcedViewMode?: ViewMode;
  excludedWorkloadTypes?: readonly WorkloadType[];
  showNestedExcludedWorkloads?: boolean;
  forcedGroupingMode?: WorkloadsGroupingMode;
  // When the surface is mounted inside a platform-first page, the page owns
  // platform scope through `forcedPlatform`. `suppressPlatformFilter`
  // withholds the Platform filter config from the returned state, so a
  // platform the owning page already fixed never counts as an operator
  // filter. The owning page renders the one WorkloadsFilter; the surface
  // renders none.
  suppressPlatformFilter?: boolean;
  // An owning platform page may provide the canonical unified-resource
  // snapshot it already fetched. This avoids a second workload/infrastructure
  // request and keeps both surfaces on the same refresh generation.
  resourceSnapshot?: Accessor<Resource[] | undefined>;
  resourceSnapshotChange?: Accessor<{
    version: number;
    changedIds: ReadonlySet<string> | null;
  }>;
  resourceSnapshotRefetch?: () => Promise<unknown>;
  statusModeStorageScope?: string;
  // When a platform page owns the metric display mode + sparkline range
  // (so the same toggle drives both the page's hosts table and this
  // embedded workloads surface), pass the accessors + change handlers.
  // The page is responsible for persisting the values; when omitted, the
  // surface falls back to its own persistent signals.
  metricDisplayMode?: Accessor<WorkloadsMetricDisplayMode>;
  onMetricDisplayModeChange?: (value: WorkloadsMetricDisplayMode) => void;
  metricHoverMode?: Accessor<WorkloadsMetricHoverMode>;
  onMetricHoverModeChange?: (value: WorkloadsMetricHoverMode) => void;
  metricHistoryRange?: Accessor<WorkloadTableMetricHistoryRange>;
  onMetricHistoryRangeChange?: (value: WorkloadTableMetricHistoryRange) => void;
  // Proxmox can compare guest memory use with either the allocation assigned
  // to that guest or the total memory of its resolved parent node.
  memoryDisplayBasis?: Accessor<WorkloadsMemoryDisplayBasis>;
  // Platform pages can scope column preferences when a shared workload type
  // needs different defaults or labels on that platform-owned page.
  columnVisibilityStorageScope?: string;
  additionalDefaultHiddenColumnIds?: string[];
  columnLabelOverrides?: Partial<Record<string, string>>;
  groupLabelBadges?: Record<string, WorkloadGroupLabelBadge>;
  /** Lets an owning platform page share one viewer-safe source-health poll. */
  inventorySourcesQuery?: WorkloadsInventorySourcesQuery;
  /** Keeps a warmed, hidden platform tab from parsing or rewriting another tab's URL state. */
  routeStateEnabled?: Accessor<boolean>;
}

export interface WorkloadsInventorySourcesQuery {
  error: Accessor<unknown>;
  refetch: (options?: { background?: boolean }) => Promise<RuntimeInventorySourcesResponse>;
  value: Accessor<RuntimeInventorySourcesResponse>;
}

export type WorkloadSortKey = WorkloadsSortKey;

export interface WorkloadGroupLabelBadge {
  label: string;
  classes: string;
  title?: string;
}

export function useWorkloadsState(props: WorkloadsStateOptions) {
  const navigate = useNavigate();
  const ws = useWebSocket();
  const { connected, activeAlerts, initialDataReceived, reconnecting, reconnect } = ws;
  const alertsActivation = useAlertsActivation();
  const alertsEnabled = alertsActivation.detectionEnabled;

  const workloads = useWorkloads(undefined, {
    resourceSnapshot: props.resourceSnapshot,
    resourceSnapshotChange: props.resourceSnapshotChange,
    refetchSnapshot: props.resourceSnapshotRefetch,
  });
  const metadataIds = createMemo<ReadonlySet<string>>(
    () => new Set(workloads.workloads().map(getWorkloadMetadataId)),
    new Set<string>(),
    {
      equals: (previous, next) =>
        previous.size === next.size && [...next].every((id) => previous.has(id)),
    },
  );
  const { guestMetadata, handleCustomUrlUpdate } = useWorkloadGuestMetadataState(metadataIds);
  const infrastructureSources = useUnifiedResources({
    query: WORKLOADS_INFRASTRUCTURE_SOURCES_QUERY,
    cacheKey: 'workloads-infrastructure-sources',
    enabled: () => !props.resourceSnapshot,
  });
  const infrastructureResources = createMemo(() =>
    props.resourceSnapshot ? (props.resourceSnapshot() ?? []) : infrastructureSources.resources(),
  );
  const infrastructureLoading = createMemo(() =>
    props.resourceSnapshot
      ? props.resourceSnapshot() === undefined
      : infrastructureSources.loading(),
  );
  const inventorySourcesResourceKey = createMemo(() =>
    props.inventorySourcesQuery ? null : 'enabled',
  );
  const ownedInventorySourcesSnapshot = createNonSuspendingQuery<
    RuntimeInventorySourcesResponse,
    string
  >({
    source: inventorySourcesResourceKey,
    fetcher: () => RuntimeInventorySourcesAPI.list(),
    initialValue: EMPTY_INVENTORY_SOURCES_RESPONSE,
    cacheKey: (key) => `workloads-inventory-sources:${key}`,
  });
  const inventorySourcesSnapshot = props.inventorySourcesQuery ?? ownedInventorySourcesSnapshot;

  const dedupeGuests = (guests: WorkloadGuest[]): WorkloadGuest[] => {
    const seen = new Set<string>();
    const deduped: WorkloadGuest[] = [];
    for (const guest of guests) {
      const canonicalId = getCanonicalWorkloadId(guest);
      if (seen.has(canonicalId)) continue;
      seen.add(canonicalId);
      deduped.push(guest);
    }
    return deduped;
  };

  const excludedWorkloadTypeSet = createMemo(() => new Set(props.excludedWorkloadTypes ?? []));
  const rawGuests = createMemo<WorkloadGuest[]>(() => workloads.workloads());
  const allGuests = createMemo<WorkloadGuest[]>(() =>
    dedupeGuests(
      selectVisibleWorkloadInventory({
        guests: rawGuests(),
        excludedTypes: excludedWorkloadTypeSet(),
        platformScope: props.forcedPlatform,
      }),
    ),
  );
  const nestedWorkloadContextByGuestId = createMemo<NestedWorkloadContextByGuestId>(() =>
    props.showNestedExcludedWorkloads
      ? buildNestedWorkloadContextByGuestId({
          guests: rawGuests(),
          visibleGuests: allGuests(),
          excludedWorkloadTypes: props.excludedWorkloadTypes,
          platformScope: props.forcedPlatform,
        })
      : {},
  );

  const [showFilters, setShowFilters] = usePersistentSignal<boolean>(
    'workloadsShowFilters',
    false,
    {
      deserialize: (raw) => raw === 'true',
      serialize: (value) => String(value),
    },
  );

  // Drives the Availability column's presence. Availability checks are opt-in
  // per resource, so a surface where nothing is probed would otherwise carry a
  // permanently empty column. Read the unfiltered guest set so narrowing the
  // table with a search or status filter never makes the column vanish.
  const hasAvailabilityData = createMemo(() =>
    allGuests().some(
      (guest) => Boolean(guest.availability) || (guest.availabilityChecks?.length ?? 0) > 0,
    ),
  );

  // One node per canonical Proxmox agent resource. Snapshot producers keep
  // resource IDs unique (the registry lists each ID once and the REST fetch
  // dedupes by ID), and each node keeps its resource's instance/node tuple, so
  // two installs whose names join to the same alias stay separate nodes.
  const infrastructureNodes = createMemo<Node[]>(() =>
    infrastructureResources()
      .filter(isProxmoxNodeResource)
      .map(nodeFromResource)
      .filter((node): node is Node => Boolean(node)),
  );

  const {
    clusterFilterConfig,
    clusterOptions,
    containerRuntime,
    containerRuntimeFilterConfig,
    handleNodeSelect,
    hostFilterConfig,
    isWorkloadsRoute,
    kubernetesContextOptions,
    kubernetesNamespaceOptions,
    namespaceFilterConfig,
    platformFilterConfig,
    platformOptions,
    resetWorkloadRouteFilters,
    selectedCluster,
    selectedHostHint,
    selectedPlatform,
    selectedKubernetesContext,
    selectedKubernetesNamespace,
    selectedNode,
    setContainerRuntime,
    setSelectedCluster,
    setSelectedPlatform,
    setSelectedKubernetesContext,
    setSelectedKubernetesNamespace,
    setViewMode,
    viewMode,
    workloadNodeOptions,
    containerRuntimeOptions,
  } = useWorkloadRouteState({
    allGuests,
    nodes: infrastructureNodes,
    forcedPlatform: props.forcedPlatform,
    forcedViewMode: props.forcedViewMode,
    showFilters,
    setShowFilters,
    routeStateEnabled: props.routeStateEnabled,
  });
  const effectiveViewMode = createMemo<ViewMode>(() => props.forcedViewMode ?? viewMode());
  const setEffectiveViewMode = (value: ViewMode): void => {
    if (props.forcedViewMode) return;
    setViewMode(value);
  };

  const {
    columnVisibility,
    workloadsFilterColumnVisibility,
    groupingMode,
    handleBeforeAutoFocus,
    handleSort,
    handleTagClick,
    isMobile,
    isSearchLocked,
    resetWorkloadsControls,
    search,
    setGroupingMode,
    setSearch,
    setSortDirection,
    setSortKey,
    setStatusMode,
    sortDirection,
    sortKey,
    statusMode,
    totalColumns,
    visibleColumns,
    workloadTableVisibleColumnIds,
    workloadTableVisibleColumns,
    workloadTableLayoutMode,
    workloadColumnWidths,
    workloadManualColumnSizing,
    workloadManualColumnSizingSupported,
    workloadTableManualWidth,
    beginWorkloadColumnResize,
    previewWorkloadColumnWidth,
    commitWorkloadColumnResize,
    cancelWorkloadColumnResize,
    clearWorkloadColumnWidth,
    resetWorkloadColumnWidths,
    workloadMetricDisplayMode,
    workloadMetricHoverMode,
    workloadMetricHistoryRange,
    setWorkloadMetricDisplayMode,
    setWorkloadMetricHoverMode,
    setWorkloadMetricHistoryRange,
  } = useWorkloadsControlsState({
    forcedGroupingMode: props.forcedGroupingMode,
    statusModeStorageScope: props.statusModeStorageScope,
    metricDisplayMode: props.metricDisplayMode,
    onMetricDisplayModeChange: props.onMetricDisplayModeChange,
    metricHoverMode: props.metricHoverMode,
    onMetricHoverModeChange: props.onMetricHoverModeChange,
    metricHistoryRange: props.metricHistoryRange,
    onMetricHistoryRangeChange: props.onMetricHistoryRangeChange,
    columnVisibilityStorageScope: props.columnVisibilityStorageScope,
    additionalDefaultHiddenColumnIds: props.additionalDefaultHiddenColumnIds,
    excludedWorkloadTypes: props.excludedWorkloadTypes,
    hasAvailabilityData,
    columnLabelOverrides: props.columnLabelOverrides,
    layoutWidth: props.layoutWidth,
    setShowFilters,
    showFilters,
    viewMode: effectiveViewMode,
    routeStateEnabled: props.routeStateEnabled,
  });

  const workloadMemoryDisplayBasis: Accessor<WorkloadsMemoryDisplayBasis> =
    props.memoryDisplayBasis ?? (() => 'guest');
  const memoryParentNodeByGuestId = createMemo(() =>
    buildGuestParentNodeMapFromNodes(allGuests(), infrastructureNodes()),
  );

  const workloadsInfrastructureEmptyState = createMemo(() =>
    getWorkloadsInfrastructureEmptyState(),
  );
  const workloadsGuestsEmptyState = createMemo(() => getWorkloadsGuestsEmptyState(search()));
  const workloadsLoadingState = createMemo(() => getWorkloadsLoadingState(reconnecting()));
  const workloadsNoInventoryState = createMemo(() =>
    getWorkloadsNoInventoryState(sessionCanReadInfrastructureSettings()),
  );
  const workloadsDisconnectedState = createMemo(() =>
    getWorkloadsDisconnectedState(reconnecting()),
  );
  const workloadInventoryIssues = createMemo(() =>
    buildWorkloadInventorySourceIssues(inventorySourcesSnapshot.value().sources ?? []),
  );
  const hasWorkloadsData = createMemo(() => allGuests().length > 0);
  const hasInfrastructureSources = createMemo(
    () => infrastructureNodes().length > 0 || infrastructureResources().length > 0,
  );
  const infrastructureSourceStateReady = createMemo(
    () => hasInfrastructureSources() || !infrastructureLoading(),
  );
  const surfaceConnected = createMemo(
    () => workloads.loading() || hasWorkloadsData() || !workloads.error(),
  );
  const surfaceInitialDataReceived = createMemo(
    () =>
      hasWorkloadsData() ||
      ((!workloads.loading() || Boolean(workloads.error())) && infrastructureSourceStateReady()),
  );

  const reconnectSurface = () => {
    void workloads.refetch();
    void inventorySourcesSnapshot.refetch({ background: true });
    reconnect();
  };

  createEffect(() => {
    if (props.inventorySourcesQuery) return;
    const handle = window.setInterval(() => {
      void inventorySourcesSnapshot.refetch({ background: true });
    }, WORKLOADS_INVENTORY_SOURCES_POLL_INTERVAL_MS);
    onCleanup(() => window.clearInterval(handle));
  });

  let lastConnected = connected();
  let hasSeenConnectedState = connected();
  createEffect(() => {
    const isConnected = connected();
    if (isConnected) {
      if (!lastConnected && hasSeenConnectedState) {
        void workloads.refetch();
      }
      hasSeenConnectedState = true;
    }
    lastConnected = isConnected;
  });

  const guestSortComparator = createMemo(() =>
    createWorkloadSortComparator(sortKey() || '', sortDirection(), {
      memoryValue: (guest) => {
        if (workloadMemoryDisplayBasis() !== 'host') {
          return guest.memory?.usage;
        }
        const hostTotal =
          memoryParentNodeByGuestId()[getCanonicalWorkloadId(guest)]?.memory?.total ?? 0;
        const used = guest.memory?.used;
        return Number.isFinite(hostTotal) &&
          hostTotal > 0 &&
          typeof used === 'number' &&
          Number.isFinite(used) &&
          used >= 0
          ? (used / hostTotal) * 100
          : null;
      },
    }),
  );

  const filteredGuests = createMemo(() => {
    const params: FilterWorkloadsParams = {
      guests: allGuests(),
      viewMode: effectiveViewMode(),
      statusMode: statusMode(),
      searchTerm: search().trim(),
      selectedNode: selectedNode(),
      selectedHostHint: selectedHostHint(),
      selectedPlatform: props.forcedPlatform?.trim() || selectedPlatform(),
      selectedKubernetesContext: selectedKubernetesContext(),
      selectedKubernetesNamespace: selectedKubernetesNamespace(),
      selectedCluster: selectedCluster(),
      containerRuntime: containerRuntime().trim() || null,
    };
    return filterWorkloads(params);
  });
  const groupLabelBadges = createMemo<Record<string, WorkloadGroupLabelBadge>>(
    () => props.groupLabelBadges ?? {},
  );

  const {
    activeSummaryWorkloadId,
    clearPinnedSummaryScope,
    hoveredWorkloadId,
    revealedGuestId,
    selectedGuestDrawerState,
    selectedGuestId,
    setClearSurfaceRootRef,
    setHoveredWorkloadId,
    setSelectedGuestId,
    setTableBodyRef,
    setTableRootRef,
    setTableWrapperRef,
    tableBodyRef,
  } = useWorkloadSelectionState({
    clearAdditionalPageStateOnEscape: () => {
      resetWorkloadsControls();
      resetWorkloadRouteFilters();
    },
    filteredGuests,
    routeStateEnabled: props.routeStateEnabled,
  });

  const activeHistoryGuest = createMemo(() => {
    const activeId = hoveredWorkloadId();
    if (!activeId) return null;
    return allGuests().find((guest) => getCanonicalWorkloadId(guest) === activeId) ?? null;
  });
  createEffect(() => {
    if (
      workloadMetricDisplayMode() === 'bars' &&
      workloadMetricHoverMode() === 'details' &&
      hoveredWorkloadId() !== null
    ) {
      setHoveredWorkloadId(null);
    }
  });
  const {
    bottomSpacerHeight,
    getGroupLabel,
    groupedGuests,
    groupedWindowing,
    guestParentNodeMap,
    inventoryStats,
    isScrollToTopVisible,
    nodeByInstance,
    topSpacerHeight,
    scrollToTop,
    totalStats,
    visibleGroupKeys,
    windowedGroupedGuests,
    workloadIOEmphasis,
  } = useWorkloadsDerivedState({
    activeAlerts: () => activeAlerts,
    alertsEnabled,
    allGuests,
    filteredGuests,
    groupingMode,
    guestSortComparator,
    nodes: infrastructureNodes,
    revealedGuestId,
    selectedGuestId,
    tableBodyRef,
    groupLabelBadges,
  });

  const metricHistoryPrefetchGuests = createMemo(() =>
    visibleGroupKeys().flatMap((groupKey) => windowedGroupedGuests()[groupKey] ?? []),
  );
  const workloadMetricHistory = useWorkloadTableMetricHistory({
    activeGuest: activeHistoryGuest,
    // Persistent Trends owns the estate-wide batch reader. Bars mode warms a
    // small visible/adjacent window so sequential row hover remains immediate.
    enabled: () => workloadMetricDisplayMode() === 'sparklines',
    onDemand: () =>
      workloadMetricDisplayMode() === 'bars' && workloadMetricHoverMode() === 'history',
    prefetchGuests: metricHistoryPrefetchGuests,
    range: workloadMetricHistoryRange,
    selectedNode,
    // Grouped node rows carry no metric cells, so this reader never polls
    // the infrastructure summary.
    series: 'guests',
    nodes: infrastructureNodes,
  });
  const [workloadHistoryHintSeen, setWorkloadHistoryHintSeen] = usePersistentSignal<boolean>(
    STORAGE_KEYS.WORKLOADS_HISTORY_HINT_SEEN,
    false,
    { deserialize: (raw) => raw === 'true' },
  );
  const workloadMetricHistoryHintVisible = createMemo(
    () =>
      !workloadHistoryHintSeen() &&
      workloadMetricDisplayMode() === 'bars' &&
      workloadMetricHoverMode() === 'history' &&
      filteredGuests().length > 0,
  );
  createEffect(() => {
    const active = activeHistoryGuest();
    if (!active || !workloadMetricHistory.hasGuestHistory?.(active)) return;
    recordWorkloadHistoryActivity('preview');
    if (!workloadHistoryHintSeen()) {
      setWorkloadHistoryHintSeen(true);
    }
  });

  return {
    activeAlerts,
    alertsEnabled,
    allGuests,
    inventoryStats,
    isScrollToTopVisible,
    activeSummaryWorkloadId,
    clearPinnedSummaryScope,
    bottomSpacerHeight,
    clusterFilterConfig,
    clusterOptions,
    columnVisibility,
    connected,
    containerRuntime,
    containerRuntimeFilterConfig,
    containerRuntimeOptions,
    workloadsFilterColumnVisibility,
    workloadsDisconnectedState,
    workloadsGuestsEmptyState,
    workloadsInfrastructureEmptyState,
    workloadsLoadingState,
    filteredGuests,
    getGroupLabel,
    groupedGuests,
    groupedWindowing,
    guestMetadata,
    guestParentNodeMap,
    handleBeforeAutoFocus,
    handleCustomUrlUpdate,
    handleNodeSelect,
    handleSort,
    handleTagClick,
    hasInfrastructureSources,
    hostFilterConfig,
    infrastructureSourceStateReady,
    infrastructureNodes,
    initialDataReceived,
    isMobile,
    isSearchLocked,
    isWorkloadsRoute,
    kubernetesContextOptions,
    kubernetesNamespaceOptions,
    navigate,
    nodeByInstance,
    namespaceFilterConfig,
    nestedWorkloadContextByGuestId,
    platformFilterConfig: props.suppressPlatformFilter ? () => undefined : platformFilterConfig,
    platformOptions,
    reconnect,
    reconnectSurface,
    search,
    scrollToTop,
    selectedCluster,
    selectedGuestDrawerState,
    selectedGuestId,
    selectedHostHint,
    selectedPlatform,
    selectedKubernetesContext,
    selectedKubernetesNamespace,
    selectedNode,
    setContainerRuntime,
    setClearSurfaceRootRef,
    setGroupingMode,
    setHoveredWorkloadId,
    setSearch,
    setSelectedCluster,
    setSelectedGuestId,
    setSelectedPlatform,
    setSelectedKubernetesContext,
    setSelectedKubernetesNamespace,
    setSortDirection,
    setSortKey,
    setStatusMode,
    setTableBodyRef,
    setTableRootRef,
    setTableWrapperRef,
    setViewMode: setEffectiveViewMode,
    setWorkloadMetricDisplayMode,
    setWorkloadMetricHoverMode,
    setWorkloadMetricHistoryRange,
    sortDirection,
    sortKey,
    statusMode,
    surfaceConnected,
    surfaceInitialDataReceived,
    topSpacerHeight,
    totalColumns,
    totalStats,
    viewMode: effectiveViewMode,
    visibleColumns,
    visibleGroupKeys,
    windowedGroupedGuests,
    workloadIOEmphasis,
    workloadMetricHistoryRange,
    workloadMetricHistoryHintVisible,
    workloadMetricDisplayMode,
    workloadMetricHoverMode,
    workloadMemoryDisplayBasis,
    workloadMetricHistory,
    workloadTableVisibleColumnIds,
    workloadTableVisibleColumns,
    workloadTableLayoutMode,
    workloadColumnWidths,
    workloadManualColumnSizing,
    workloadManualColumnSizingSupported,
    workloadTableManualWidth,
    beginWorkloadColumnResize,
    previewWorkloadColumnWidth,
    commitWorkloadColumnResize,
    cancelWorkloadColumnResize,
    clearWorkloadColumnWidth,
    resetWorkloadColumnWidths,
    workloadNodeOptions,
    workloads,
    workloadInventoryIssues,
    workloadsNoInventoryState,
    ws,
    groupingMode,
    groupLabelBadges,
  } as const;
}

export type WorkloadsState = ReturnType<typeof useWorkloadsState>;