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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
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>;