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.

65.8 KB
Raw Blame
import { render } from '@solidjs/testing-library';
import {
  batch,
  createComponent,
  createEffect,
  createRenderEffect,
  createRoot,
  createSignal,
  Suspense,
} from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import useWorkloadsSource from '../useWorkloads.ts?raw';
import { guestDiskDeferrals } from '@/components/Workloads/__fixtures__/guestDiskDeferrals';
import type { VM } from '@/types/api';
import type { Resource } from '@/types/resource';
import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
import { getDiskUsagePercent, getWorkloadGroupKey } from '@/components/Workloads/workloadSelectors';

type UseWorkloadsModule = typeof import('@/hooks/useWorkloads');

const sampleResource = {
  id: 'cluster-a-pve1-101',
  type: 'vm',
  name: 'vm-101',
  status: 'running',
  lastSeen: '2026-02-06T12:00:00Z',
  vmid: 101,
  node: 'pve1',
  instance: 'cluster-a',
  metrics: {
    cpu: { percent: 25 },
    memory: { used: 2 * 1024, total: 4 * 1024, percent: 50 },
    disk: { used: 20 * 1024, total: 100 * 1024, percent: 20 },
  },
  sources: ['proxmox'],
};

const flushAsync = async () => {
  await Promise.resolve();
  await Promise.resolve();
};

const advanceAndFlush = async (ms: number) => {
  vi.advanceTimersByTime(ms);
  await flushAsync();
};

const deferred = <T>() => {
  let resolve!: (value: T | PromiseLike<T>) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
};

const waitForWorkloadCount = async (getCount: () => number, expectedMin = 1) => {
  for (let i = 0; i < 20; i += 1) {
    if (getCount() >= expectedMin) {
      return;
    }
    await flushAsync();
  }
  throw new Error(`Timed out waiting for at least ${expectedMin} workloads`);
};

describe('useWorkloads', () => {
  let apiFetchJSONMock: ReturnType<typeof vi.fn>;
  let useWorkloads: UseWorkloadsModule['useWorkloads'];
  let resetWorkloadsCacheForTests: UseWorkloadsModule['__resetWorkloadsCacheForTests'];
  let eventBus: (typeof import('@/stores/events'))['eventBus'];

  beforeEach(async () => {
    vi.useFakeTimers();
    vi.resetModules();

    apiFetchJSONMock = vi.fn().mockResolvedValue({
      data: [sampleResource],
      meta: { totalPages: 1 },
    });

    vi.doMock('@/utils/apiClient', () => ({
      apiFetchJSON: apiFetchJSONMock,
      getOrgID: () => 'default',
    }));

    ({ useWorkloads, __resetWorkloadsCacheForTests: resetWorkloadsCacheForTests } =
      await import('@/hooks/useWorkloads'));
    ({ eventBus } = await import('@/stores/events'));

    resetWorkloadsCacheForTests();
  });

  it.each(['api', 'snapshot'] as const)(
    'preserves aggregate disk presence and percentage points through %s refreshes',
    async (transport) => {
      const [snapshot, setSnapshot] = createSignal<Resource[]>([]);
      let dispose = () => {};
      let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
      createRoot((d) => {
        dispose = d;
        result = useWorkloads(
          () => true,
          transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},
        );
      });
      try {
        await flushAsync();
        for (const [metric, expected] of [
          [{ total: 100 }, null],
          [{ used: 0 }, null],
          [{}, null],
          [{ used: 0, total: 100 }, 0],
          [{ percent: 0 }, 0],
          [{ percent: 0.5 }, 0.5],
          [{ percent: 1 }, 1],
          [{ value: 0.5 }, 0.5],
          [{ value: 0, total: 100, unit: 'bytes' }, null],
          [{ value: 0, used: 0, total: 100, unit: 'bytes' }, 0],
          [{ value: 0, used: 50, total: 200, unit: 'bytes' }, 25],
          [{ value: 0.5, unit: 'percent' }, 0.5],
          [{ used: 50, total: 200 }, 25],
          [{ percent: -1, used: 0, total: 100 }, null],
          [{ percent: Infinity, used: 0, total: 100 }, null],
        ] as const) {
          if (transport === 'snapshot' && 'unit' in metric) continue;
          const raw = { ...sampleResource, metrics: { ...sampleResource.metrics, disk: metric } };
          if (transport === 'api') {
            apiFetchJSONMock.mockResolvedValue({ data: [raw] });
            await result.refetch();
          } else {
            const { percent, value, ...bytes } = metric as {
              percent?: number;
              value?: number;
              total?: number;
              used?: number;
            };
            setSnapshot([
              {
                ...raw,
                lastSeen: Date.parse(raw.lastSeen),
                memory: { current: 50, used: 2048, total: 4096 },
                disk: { ...bytes, current: percent ?? value } as Resource['disk'],
              } as unknown as Resource,
            ]);
          }
          await flushAsync();
          const row = result.workloads()[0];
          expect(row.id).toBe(sampleResource.id);
          expect(row.telemetryAvailability?.disk).toBe(expected !== null);
          expect(getDiskUsagePercent(row)).toBe(expected);
          if (expected === null && !('used' in metric)) expect(row.disk.used).toBeUndefined();
          expect(row.memory.usage).toBe(50);
        }
      } finally {
        dispose();
      }
    },
  );

  it.each(
    (['api', 'snapshot'] as const).flatMap((transport) =>
      (['vm', 'system-container'] as const).map((type) => ({ transport, type })),
    ),
  )(
    'preserves selected guest network interfaces through $transport for $type',
    async ({ transport, type }) => {
      const platformInterfaces = [
        { name: 'eth0', addresses: ['192.0.2.80'], mac: '02:00:00:00:00:80' },
        { name: 'podman0', addresses: ['10.88.0.1'] },
      ];
      const agentInterfaces = [
        { name: 'ens18', addresses: ['192.0.2.80'], rxBytes: 1024, txBytes: 2048 },
      ];
      const resource: Resource = {
        id: `${type}-site-a-2757`,
        type,
        name: 'guest-2757',
        displayName: 'guest-2757',
        platformId: 'site-a',
        platformType: 'proxmox-pve',
        sourceType: 'api',
        sources: ['proxmox'],
        status: 'running',
        lastSeen: Date.parse(sampleResource.lastSeen),
        identity: { ips: ['192.0.2.80', '10.88.0.1'] },
        metricsTarget: { resourceType: type, resourceId: 'site-a-node-a-2757' },
        proxmox: {
          vmid: 2757,
          nodeName: 'node-a',
          instance: 'site-a',
          networkInterfaces: platformInterfaces,
        },
      };
      const apiResource = (value: Resource) => ({
        ...value,
        lastSeen: new Date(value.lastSeen).toISOString(),
        identity: { ipAddresses: value.identity?.ips },
      });
      const [snapshot, setSnapshot] = createSignal([resource]);
      apiFetchJSONMock.mockResolvedValue({ data: [apiResource(resource)] });
      let dispose = () => {};
      let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
      createRoot((d) => {
        dispose = d;
        result = useWorkloads(
          () => true,
          transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},
        );
      });
      const update = async (value: Resource) => {
        if (transport === 'snapshot') setSnapshot([value]);
        else {
          apiFetchJSONMock.mockResolvedValue({ data: [apiResource(value)] });
          await result.refetch();
        }
        await flushAsync();
      };
      const check = (
        interfaces: typeof platformInterfaces | typeof agentInterfaces,
        fromAgent: boolean,
      ) => {
        const guest = result.workloads()[0];
        expect(guest.networkInterfaces).toEqual(interfaces);
        expect(guest).toMatchObject({
          id: resource.id,
          canonicalResourceId: resource.id,
          metricsTarget: resource.metricsTarget,
          vmid: 2757,
          node: 'node-a',
          instance: 'site-a',
          ipAddresses: ['192.0.2.80', '10.88.0.1'],
          lastSeen: new Date(resource.lastSeen).toISOString(),
          networkInterfacesFromAgent: fromAgent,
        });
        expect(Date.parse(guest.lastSeen)).toBe(resource.lastSeen);
      };
      try {
        await waitForWorkloadCount(() => result.workloads().length);
        check(platformInterfaces, false);
        // An agent facet without interfaces does not erase API-provided names
        // or make those API readings part of the silent agent's last report.
        await update({ ...resource, agent: { agentId: 'linked-agent', stale: true } });
        check(platformInterfaces, false);
        expect(result.workloads()[0].agentStale).toBe(true);
        await update({
          ...resource,
          agent: { agentId: 'linked-agent', networkInterfaces: agentInterfaces },
        });
        check(agentInterfaces, true);
        await update({
          ...resource,
          agent: { agentId: 'linked-agent', stale: true, networkInterfaces: agentInterfaces },
        });
        check(agentInterfaces, true);
        expect(result.workloads()[0].agentStale).toBe(true);
        // A reported empty list remains authoritative; do not resurrect a
        // different producer's interfaces merely because this list is empty.
        await update({ ...resource, agent: { agentId: 'linked-agent', networkInterfaces: [] } });
        check([], true);
        await update({ ...resource, proxmox: { ...resource.proxmox, networkInterfaces: [] } });
        check([], false);
        await update({
          ...resource,
          proxmox: { ...resource.proxmox, networkInterfaces: undefined },
        });
        expect(result.workloads()[0].networkInterfaces).toBeUndefined();
        expect(result.workloads()[0].networkInterfacesFromAgent).toBeUndefined();
        await update(resource);
        check(platformInterfaces, false);
        if (transport === 'snapshot') expect(apiFetchJSONMock).not.toHaveBeenCalled();
        else expect(apiFetchJSONMock).toHaveBeenCalledTimes(8);
        expect(resource.proxmox?.networkInterfaces).toEqual(platformInterfaces);
      } finally {
        dispose();
      }
    },
  );

  it.each([
    'invalid',
    '0002-01-01T00:00:00Z',
    '2026-09-31T11:00:00Z',
    '2026-10-04T11:00:00',
    '2026-10-04',
  ])('does not turn a present unusable backup time %s into absence', async (lastBackup) => {
    const [snapshot] = createSignal([{ ...sampleResource, proxmox: { lastBackup } }] as any);
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: snapshot });
    });
    try {
      await flushAsync();
      expect(result!.workloads()[0]?.lastBackup).not.toBe(0);
      if (lastBackup !== '0002-01-01T00:00:00Z') {
        expect(result!.workloads()[0]?.lastBackup).toBeNaN();
      }
    } finally {
      dispose();
    }
  });

  it('preserves linked-agent RAID arrays and agent ID from the VM resource for guest detail', async () => {
    const [snapshot] = createSignal([
      {
        ...sampleResource,
        agent: {
          agentId: 'host-guest-agent',
          agentVersion: '6.4.5',
          raid: [
            {
              device: '/dev/md0',
              name: 'data',
              level: 'raid1',
              state: 'clean',
              totalDevices: 2,
              activeDevices: 2,
              workingDevices: 2,
              failedDevices: 0,
              spareDevices: 0,
            },
          ],
        },
      },
    ] as any);
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: snapshot });
    });
    try {
      await flushAsync();
      expect(result!.workloads()[0]?.canonicalResourceId).toBe(sampleResource.id);
      // The guest drawer judges the agent's disks under this ID's overrides.
      expect(result!.workloads()[0]?.agentId).toBe('host-guest-agent');
      expect(result!.workloads()[0]?.agentRaid).toMatchObject([
        { device: '/dev/md0', level: 'raid1', state: 'clean' },
      ]);
      expect(apiFetchJSONMock).not.toHaveBeenCalled();
    } finally {
      dispose();
    }
  });

  it('marks a silent linked agent and the guest filesystems it supplied', async () => {
    const disk = (mountpoint: string) => ({
      mountpoint,
      type: 'ext4',
      total: 100,
      used: 40,
      free: 60,
      usage: 40,
    });
    const [snapshot] = createSignal([
      // Proxmox read no guest filesystems, so the agent's own report fills in.
      {
        ...sampleResource,
        id: 'vm-agent-disks',
        vmid: 102,
        sources: ['proxmox', 'agent'],
        agent: { agentVersion: '6.4.5', stale: true, disks: [disk('/agent')] },
      },
      // Proxmox guest filesystems win over a live agent's.
      {
        ...sampleResource,
        id: 'vm-platform-disks',
        vmid: 103,
        sources: ['proxmox', 'agent'],
        proxmox: { disks: [disk('/platform')] },
        agent: { agentVersion: '6.4.5', stale: false, disks: [disk('/agent')] },
      },
    ] as any);
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: snapshot });
    });
    try {
      await flushAsync();
      const byId = (id: string) =>
        result!.workloads().find((workload) => workload.canonicalResourceId === id);
      expect(byId('vm-agent-disks')).toMatchObject({ agentStale: true, disksFromAgent: true });
      expect(byId('vm-agent-disks')?.disks?.map((d) => d.mountpoint)).toEqual(['/agent']);
      expect(byId('vm-platform-disks')?.agentStale).toBeUndefined();
      expect(byId('vm-platform-disks')?.disksFromAgent).toBeUndefined();
      expect(byId('vm-platform-disks')?.disks?.map((d) => d.mountpoint)).toEqual(['/platform']);
    } finally {
      dispose();
    }
  });

  afterEach(() => {
    vi.useRealTimers();
    vi.clearAllMocks();
    vi.resetModules();
  });

  it.each(guestDiskDeferrals)(
    'preserves %s and the native lock through the resources API',
    async (reason) => {
      apiFetchJSONMock.mockResolvedValueOnce({
        data: [
          {
            ...sampleResource,
            proxmox: {
              vmid: 101,
              nodeName: 'pve1',
              instance: 'cluster-a',
              diskStatusReason: `prev-${reason}`,
              guestAgentStatus: 'deferred',
              guestAgentExpected: true,
              lock: 'backup',
            },
          },
        ],
        meta: { totalPages: 1 },
      });
      let dispose = () => {};
      let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
      createRoot((d) => {
        dispose = d;
        result = useWorkloads();
      });
      try {
        await waitForWorkloadCount(() => result.workloads().length);
        expect(result!.workloads()[0]).toMatchObject({
          diskStatusReason: `prev-${reason}`,
          guestAgentStatus: 'deferred',
          guestAgentExpected: true,
          lock: 'backup',
          disk: { usage: 20 },
        });
        expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
      } finally {
        dispose();
      }
    },
  );

  it.each(guestDiskDeferrals)(
    'preserves %s through the owning Proxmox snapshot without another request',
    async (reason) => {
      let dispose = () => {};
      let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
      createRoot((d) => {
        dispose = d;
        result = useWorkloads(() => true, {
          resourceSnapshot: () =>
            [
              {
                ...sampleResource,
                proxmox: {
                  vmid: 101,
                  nodeName: 'pve1',
                  instance: 'cluster-a',
                  diskStatusReason: reason,
                  guestAgentStatus: 'deferred',
                  guestAgentExpected: false,
                  lock: 'migrate',
                },
                disk: { current: 20, used: 20 * 1024, total: 100 * 1024 },
              },
            ] as any,
        });
      });
      try {
        await flushAsync();
        expect(result!.workloads()[0]).toMatchObject({
          diskStatusReason: reason,
          guestAgentStatus: 'deferred',
          guestAgentExpected: false,
          lock: 'migrate',
          disk: { usage: 20 },
        });
        expect(apiFetchJSONMock).not.toHaveBeenCalled();
      } finally {
        dispose();
      }
    },
  );

  it('updates read evidence even with unchanged metrics, preserving other site rows', async () => {
    const buildVM = (instance: string, proxmox: Record<string, unknown> = {}, current = 20) =>
      ({
        ...sampleResource,
        id: `${instance}-pve1-101`,
        proxmox: { vmid: 101, nodeName: 'pve1', instance, ...proxmox },
        disk: { current, used: current * 1024, total: 100 * 1024 },
      }) as any;
    const other = buildVM('cluster-b');
    const [snapshot, setSnapshot] = createSignal([
      buildVM('cluster-a', {
        diskStatusReason: 'prev-vm-locked',
        guestAgentStatus: 'deferred',
        guestAgentExpected: true,
        lock: 'backup',
      }),
      other,
    ]);
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: snapshot });
    });
    const target = () => result!.workloads().find((row) => row.instance === 'cluster-a')! as VM;
    try {
      await flushAsync();
      const prior = target();
      const otherRow = result!.workloads().find((row) => row.instance === 'cluster-b');
      expect(prior.diskStatusReason).toBe('prev-vm-locked');
      setSnapshot([buildVM('cluster-a', { guestAgentStatus: 'available' }), other]);
      await flushAsync();
      expect(target()).not.toBe(prior);
      expect(target().diskStatusReason).toBeUndefined();
      expect(target().lock).toBe('');
      expect(target().guestAgentStatus).toBe('available');
      expect(target().guestAgentExpected).toBeUndefined();
      expect(target().disk.usage).toBe(20);
      expect(result!.workloads().find((row) => row.instance === 'cluster-b')).toBe(otherRow);
      setSnapshot([buildVM('cluster-a', { guestAgentStatus: 'available' }, 0), other]);
      await flushAsync();
      expect(target().disk.usage).toBe(0);
      expect(apiFetchJSONMock).not.toHaveBeenCalled();
    } finally {
      dispose();
    }
  });

  it('does not treat a stopped native VM facet as current disk telemetry when health stays online', async () => {
    const other = {
      ...sampleResource,
      id: 'other-site',
      instance: 'other',
      disk: { current: 40, total: 100, used: 40 },
    };
    const snapshot = (runtimeStatus: string, diskStatusReason?: string) =>
      [
        {
          ...sampleResource,
          status: 'online',
          disk: { current: 20, used: 20 * 1024, total: 100 * 1024 },
          proxmox: {
            vmid: 101,
            nodeName: 'pve1',
            instance: 'cluster-a',
            runtimeStatus,
            diskStatusReason,
          },
        },
        other,
      ] as any;
    const [resources, setResources] = createSignal(snapshot('running'));
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']>;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: resources });
    });
    const target = () =>
      result!.workloads().find((row) => row.canonicalResourceId === sampleResource.id)!;
    try {
      await flushAsync();
      const otherRow = result!.workloads().find((row) => row.canonicalResourceId === 'other-site');
      expect(otherRow).toBeDefined();
      expect(getDiskUsagePercent(target())).toBe(20);
      setResources(snapshot('stopped'));
      await flushAsync();
      expect(target()).toMatchObject({
        status: 'stopped',
        resourceStatus: 'online',
        disk: { usage: 20 },
      });
      expect(getWorkloadGuestDiskRead(target(), true).state).toBe('unavailable');
      expect(getDiskUsagePercent(target())).toBeNull();
      setResources(snapshot('running', 'prev-agent-busy'));
      await flushAsync();
      expect(getDiskUsagePercent(target())).toBeNull();
      setResources(snapshot('running'));
      await flushAsync();
      expect(getDiskUsagePercent(target())).toBe(20);
      expect(result!.workloads().find((row) => row.canonicalResourceId === 'other-site')).toBe(
        otherRow,
      );
      expect(apiFetchJSONMock).not.toHaveBeenCalled();
    } finally {
      dispose();
    }
  });

  it('reuses fresh cache on remount without an extra network fetch', async () => {
    let disposeFirst = () => {};
    createRoot((d) => {
      disposeFirst = d;
      const [enabled] = createSignal(true);
      useWorkloads(enabled);
    });

    await flushAsync();
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);

    disposeFirst();

    let disposeSecond = () => {};
    createRoot((d) => {
      disposeSecond = d;
      const [enabled] = createSignal(true);
      useWorkloads(enabled);
    });

    await flushAsync();
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);

    disposeSecond();
  });

  it('keeps loads and polls out of the app-level Suspense fallback', async () => {
    const firstRead = deferred<unknown>();
    apiFetchJSONMock.mockReturnValueOnce(firstRead.promise);
    let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
    const { container, unmount } = render(() =>
      createComponent(Suspense, {
        fallback: 'Loading view...',
        get children() {
          return createComponent(() => {
            result = useWorkloads(() => true);
            const node = document.createTextNode('');
            createRenderEffect(() => {
              node.data = `workloads:${result.workloads().length}`;
            });
            return node;
          }, {});
        },
      }),
    );
    try {
      await flushAsync();
      // The first read is in flight: the surface shows its own loading state
      // and the route keeps its page.
      expect(result.loading()).toBe(true);
      expect(container.textContent).not.toContain('Loading view...');

      firstRead.resolve({ data: [sampleResource], meta: { totalPages: 1 } });
      await waitForWorkloadCount(() => result.workloads().length);
      expect(container.textContent).toBe('workloads:1');

      const pollRead = deferred<unknown>();
      apiFetchJSONMock.mockReturnValueOnce(pollRead.promise);
      await advanceAndFlush(5_000);
      expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
      // The poll is in flight: the last table stays on screen.
      expect(container.textContent).toBe('workloads:1');

      pollRead.resolve({
        data: [sampleResource, { ...sampleResource, id: 'cluster-a-pve1-102', vmid: 102 }],
        meta: { totalPages: 1 },
      });
      await waitForWorkloadCount(() => result.workloads().length, 2);
      expect(container.textContent).toBe('workloads:2');
    } finally {
      unmount();
    }
  });

  it('projects authoritative LXC and QEMU CPU once regardless of agent sources or cores', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'cluster-a-pve1-101',
          type: 'vm',
          name: 'qemu-101',
          sources: ['proxmox'],
          metrics: { ...sampleResource.metrics, cpu: { percent: 0.58 } },
          proxmox: { vmid: 101, nodeName: 'pve1', instance: 'cluster-a', cpus: 8 },
        },
        {
          ...sampleResource,
          id: 'cluster-a-pve1-102',
          type: 'system-container',
          name: 'lxc-102',
          vmid: 102,
          sources: ['proxmox', 'agent'],
          metrics: { ...sampleResource.metrics, cpu: { percent: 0.58 } },
          proxmox: { vmid: 102, nodeName: 'pve1', instance: 'cluster-a', cpus: 1 },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await waitForWorkloadCount(() => result!.workloads().length, 2);

    const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
    expect(byName.get('qemu-101')?.cpu).toBe(0.0058);
    expect(byName.get('qemu-101')?.cpus).toBe(8);
    expect(byName.get('lxc-102')?.cpu).toBe(0.0058);
    expect(byName.get('lxc-102')?.cpus).toBe(1);

    dispose();
  });

  it('projects agent-reported libvirt VM runtime metadata without Proxmox fields', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'vm-agent-domain-a1b2c3d4',
          name: 'libvirt-app',
          status: 'warning',
          sources: ['agent'],
          parentName: 'qnap-host',
          vmid: undefined,
          node: undefined,
          instance: undefined,
          proxmox: undefined,
          virtualMachine: {
            runtimeState: 'running',
            hypervisor: 'libvirt',
            vcpus: 6,
          },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await waitForWorkloadCount(() => result!.workloads().length);

    expect(result!.workloads()).toHaveLength(1);
    expect(result!.workloads()[0]).toMatchObject({
      id: 'vm-agent-domain-a1b2c3d4',
      name: 'libvirt-app',
      node: 'qnap-host',
      status: 'running',
      type: 'vm',
      cpus: 6,
      platformType: 'agent',
    });

    dispose();
  });

  it('handles empty responses without mutating into undefined state', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
    expect(result!.workloads()).toEqual([]);

    dispose();
  });

  it('uses an owning canonical resource snapshot without a second workload request', async () => {
    const snapshot = [
      {
        id: 'cluster-a-pve1-101',
        type: 'vm',
        name: 'vm-101',
        status: 'running',
        platformType: 'proxmox-pve',
        sources: ['proxmox'],
        identity: { hostname: 'vm-101', ips: ['192.0.2.101'] },
        metricsTarget: { resourceType: 'vm', resourceId: 'mock-cluster-a-pve1-101' },
        canonicalIdentity: {
          primaryId: 'vm:cluster-a-pve1-101',
          aliases: ['legacy-vm-101'],
        },
        proxmox: {
          sourceId: 'cluster-a-pve1-101',
          vmid: 101,
          nodeName: 'pve1',
          instance: 'cluster-a',
          lastBackup: '2026-02-06T06:00:00Z',
        },
        uptime: 86_400,
        cpu: { current: 25 },
        memory: { current: 50, used: 2 * 1024, total: 4 * 1024 },
        disk: { current: 20, used: 20 * 1024, total: 100 * 1024 },
      },
    ] as any;
    const refetchSnapshot = vi.fn().mockResolvedValue(undefined);

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled, {
        resourceSnapshot: () => snapshot,
        refetchSnapshot,
      });
    });

    await flushAsync();
    expect(apiFetchJSONMock).not.toHaveBeenCalled();
    expect(result!.workloads()).toMatchObject([
      {
        name: 'vm-101',
        vmid: 101,
        node: 'pve1',
        metricsTarget: { resourceType: 'vm', resourceId: 'mock-cluster-a-pve1-101' },
        uptime: 86_400,
        lastBackup: Date.parse('2026-02-06T06:00:00Z'),
        alertResourceIds: expect.arrayContaining([
          'cluster-a-pve1-101',
          'mock-cluster-a-pve1-101',
          'vm:cluster-a-pve1-101',
          'legacy-vm-101',
        ]),
      },
    ]);

    await result!.refetch();
    expect(refetchSnapshot).toHaveBeenCalledTimes(1);
    expect(apiFetchJSONMock).not.toHaveBeenCalled();

    dispose();
  });

  it.each(['api', 'snapshot'])(
    'keeps selected memory provenance through %s without borrowing a raw facet',
    async (transport) => {
      const original = {
        state: 'last-known',
        source: 'guest-agent-meminfo',
        observedAt: '2026-10-04T14:00:00Z',
      };
      const raw = { state: 'current', source: 'status-mem', observedAt: '2026-10-04T17:00:00Z' };
      const resource = {
        ...sampleResource,
        proxmox: {
          vmid: 101,
          nodeName: 'pve1',
          instance: 'cluster-a',
          memory: { observation: raw },
        },
        metrics: {
          ...sampleResource.metrics,
          memory: { ...sampleResource.metrics.memory, observation: original },
        },
        memory: { current: 50, total: 4096, used: 2048, observation: original },
      };
      apiFetchJSONMock.mockResolvedValue({ data: [resource], meta: { totalPages: 1 } });
      const [snapshot, setSnapshot] = createSignal([resource]);
      let dispose = () => {};
      let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
      createRoot((d) => {
        dispose = d;
        result = useWorkloads(
          () => true,
          transport === 'snapshot' ? { resourceSnapshot: snapshot as any } : {},
        );
      });
      try {
        await waitForWorkloadCount(() => result.workloads().length);
        expect(result.workloads()[0].memory).toMatchObject({ usage: 50, observation: original });
        const legacy = {
          ...resource,
          metrics: { ...resource.metrics, memory: sampleResource.metrics.memory },
          memory: { current: 50, total: 4096, used: 2048 },
        };
        if (transport === 'snapshot') setSnapshot([legacy] as any);
        else {
          apiFetchJSONMock.mockResolvedValue({ data: [legacy], meta: { totalPages: 1 } });
          await result.refetch();
        }
        await flushAsync();
        expect(result.workloads()[0].memory).not.toHaveProperty('observation');
        expect(result.workloads()[0].memory.usage).toBe(50);
        const live = {
          ...resource,
          metrics: {
            ...resource.metrics,
            memory: { ...resource.metrics.memory, observation: raw },
          },
          memory: { ...resource.memory, observation: raw },
        };
        if (transport === 'snapshot') setSnapshot([live]);
        else {
          apiFetchJSONMock.mockResolvedValue({ data: [live], meta: { totalPages: 1 } });
          await result.refetch();
        }
        await flushAsync();
        expect(result.workloads()[0].memory).toMatchObject({ usage: 50, observation: raw });
      } finally {
        dispose();
      }
    },
  );

  it('tracks canonical hybrid VM memory without substituting nested agent readings', async () => {
    // #1962: synthetic snapshots exercise Web reactivity, not poller recovery.
    const buildVM = (instance: string, percent?: number) =>
      ({
        id: `${instance}-pve1-101`,
        type: 'vm',
        name: `${instance}-vm`,
        status: 'running',
        platformType: 'proxmox-pve',
        sourceType: 'hybrid',
        sources: ['proxmox', 'agent'],
        proxmox: { vmid: 101, nodeName: 'pve1', instance },
        memory:
          percent === undefined
            ? undefined
            : {
                current: percent,
                used: percent * 1024,
                total: 100 * 1024,
              },
        agent: { memory: { used: 35 * 1024, total: 100 * 1024, usage: 35 } },
      }) as any;
    const otherVM = buildVM('cluster-b', 80);
    const [snapshot, setSnapshot] = createSignal([buildVM('cluster-a', 100), otherVM]);
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: snapshot });
    });
    try {
      await flushAsync();
      const target = () => result!.workloads().find((vm) => vm.name === 'cluster-a-vm')!;
      const other = () => result!.workloads().find((vm) => vm.name === 'cluster-b-vm')!;
      expect(target().memory.usage).toBe(100);
      expect(other().memory.usage).toBe(80);
      setSnapshot([buildVM('cluster-a', 35), otherVM]);
      await flushAsync();
      expect(target().memory).toMatchObject({ usage: 35, used: 35 * 1024, total: 100 * 1024 });
      expect(other().memory.usage).toBe(80);
      // Missing canonical telemetry must not revive the nested agent's old value.
      setSnapshot([buildVM('cluster-a'), otherVM]);
      await flushAsync();
      expect(target().memory.usageUnavailable).toBe(true);
      expect(target().telemetryAvailability?.memory).toBe(false);
      expect(other().memory.usage).toBe(80);
      setSnapshot([buildVM('cluster-a', 0), otherVM]);
      await flushAsync();
      expect(target().memory).toMatchObject({ usage: 0, usageUnavailable: false });
      expect(target().telemetryAvailability?.memory).toBe(true);
      expect(apiFetchJSONMock).not.toHaveBeenCalled();
    } finally {
      dispose();
    }
  });

  it('keeps row identity stable for guests whose data did not change', async () => {
    const buildGuest = (id: string, vmid: number, cpu: number) =>
      ({
        id,
        type: 'vm',
        name: `vm-${vmid}`,
        status: 'running',
        platformType: 'proxmox-pve',
        sources: ['proxmox'],
        proxmox: { sourceId: id, vmid, nodeName: 'pve1', instance: 'cluster-a' },
        cpu: { current: cpu },
      }) as any;
    const [snapshot, setSnapshot] = createSignal([
      buildGuest('vm-a', 101, 10),
      buildGuest('vm-b', 102, 20),
    ]);

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled, { resourceSnapshot: snapshot });
    });

    await flushAsync();
    const firstRows = result!.workloads();
    expect(firstRows).toHaveLength(2);

    // One guest changes; the untouched guest's row object must be reused.
    setSnapshot([buildGuest('vm-a', 101, 10), buildGuest('vm-b', 102, 85)]);
    await flushAsync();
    const secondRows = result!.workloads();
    expect(secondRows[0]).toBe(firstRows[0]);
    expect(secondRows[1]).not.toBe(firstRows[1]);
    expect(secondRows[1]?.cpu).toBeCloseTo(0.85);

    // A refresh that changes nothing must keep the array identity itself.
    setSnapshot([buildGuest('vm-a', 101, 10), buildGuest('vm-b', 102, 85)]);
    await flushAsync();
    expect(result!.workloads()).toBe(secondRows);

    dispose();
  });

  it('adapts only changed canonical guests and fully refreshes when change history is unavailable', async () => {
    const buildGuest = (id: string, name: string, cpu: number) =>
      ({
        id,
        type: 'vm',
        name,
        status: 'running',
        platformType: 'proxmox-pve',
        sources: ['proxmox'],
        proxmox: { sourceId: id, vmid: id === 'vm-a' ? 101 : 102, nodeName: 'pve1' },
        cpu: { current: cpu },
      }) as any;
    let untouchedNameReads = 0;
    const untouched = buildGuest('vm-a', 'vm-a', 10);
    Object.defineProperty(untouched, 'name', {
      get: () => {
        untouchedNameReads += 1;
        return 'vm-a';
      },
    });
    const [snapshot, setSnapshot] = createSignal([untouched, buildGuest('vm-b', 'vm-b', 20)]);
    const [change, setChange] = createSignal<{
      version: number;
      changedIds: ReadonlySet<string> | null;
    }>({ version: 1, changedIds: null });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, {
        resourceSnapshot: snapshot,
        resourceSnapshotChange: change,
      });
    });

    try {
      await flushAsync();
      const originalRow = result!.workloads()[0];
      untouchedNameReads = 0;
      batch(() => {
        setSnapshot([untouched, buildGuest('vm-b', 'vm-b', 85)]);
        setChange({ version: 2, changedIds: new Set(['vm-b']) });
      });
      await flushAsync();
      expect(untouchedNameReads).toBe(0);
      expect(result!.workloads()[0]).toBe(originalRow);
      expect(result!.workloads()[1]?.cpu).toBeCloseTo(0.85);

      batch(() => {
        setSnapshot([buildGuest('vm-a', 'renamed-a', 10), buildGuest('vm-b', 'vm-b', 85)]);
        setChange({ version: 3, changedIds: null });
      });
      await flushAsync();
      expect(result!.workloads()[0]?.name).toBe('renamed-a');

      batch(() => {
        setSnapshot([buildGuest('vm-a', 'renamed-again', 10), buildGuest('vm-b', 'vm-b', 85)]);
        setChange({ version: 5, changedIds: new Set(['vm-b']) });
      });
      await flushAsync();
      expect(result!.workloads()[0]?.name).toBe('renamed-again');
    } finally {
      dispose();
    }
  });

  it('retains the fulfilled workload snapshot when a forced refresh fails', async () => {
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length);
    const initialWorkloads = result!.workloads();

    apiFetchJSONMock.mockRejectedValueOnce(new Error('temporary backend gap'));
    await expect(result!.refetch()).rejects.toThrow('temporary backend gap');

    expect(result!.workloads()).toBe(initialWorkloads);
    expect(result!.workloads()).toHaveLength(1);
    expect(result!.loading()).toBe(false);
    expect(result!.error()).toBeInstanceOf(Error);

    dispose();
  });

  it('clears a transient refresh error after a later poll succeeds', async () => {
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length);

    apiFetchJSONMock.mockRejectedValueOnce(new Error('temporary backend gap'));
    await expect(result!.refetch()).rejects.toThrow('temporary backend gap');
    expect(result!.error()).toBeInstanceOf(Error);

    await advanceAndFlush(5_000);
    expect(result!.workloads()).toHaveLength(1);
    expect(result!.error()).toBeUndefined();

    dispose();
  });

  it('keeps Proxmox power state stable while carrying aggregate health, then removes an authoritative deletion', async () => {
    const guest = (vmid: number, status: string, runtimeStatus: string) => ({
      ...sampleResource,
      id: `cluster-a-pve1-${vmid}`,
      type: 'system-container',
      name: `lxc-${vmid}`,
      status,
      vmid,
      proxmox: {
        vmid,
        nodeName: 'pve1',
        instance: 'cluster-a',
        runtimeStatus,
      },
    });

    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        guest(101, 'online', 'running'),
        guest(102, 'online', 'running'),
        guest(103, 'online', 'running'),
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await waitForWorkloadCount(() => result!.workloads().length, 3);
    const initialIds = result!.workloads().map((workload) => workload.id);

    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        guest(101, 'warning', 'running'),
        {
          ...guest(102, 'online', 'running'),
          availability: { targetId: 'probe-102', protocol: 'icmp', enabled: true, available: true },
        },
        guest(103, 'warning', 'running'),
      ],
      meta: { totalPages: 1 },
    });
    await result!.refetch();

    expect(result!.workloads().map((workload) => workload.id)).toEqual(initialIds);
    expect(result!.workloads().map((workload) => workload.status)).toEqual([
      'running',
      'running',
      'running',
    ]);
    expect(result!.workloads().map((workload) => workload.resourceStatus)).toEqual([
      'warning',
      'online',
      'warning',
    ]);

    apiFetchJSONMock.mockResolvedValueOnce({
      data: [guest(101, 'online', 'running'), guest(102, 'online', 'running')],
      meta: { totalPages: 1 },
    });
    await result!.refetch();

    expect(result!.workloads().map((workload) => workload.id)).toEqual(initialIds.slice(0, 2));
    expect(result!.error()).toBeUndefined();

    dispose();
  });

  it('rejects a partial paged refresh and retains the last coherent snapshot', async () => {
    const secondResource = {
      ...sampleResource,
      id: 'cluster-a-pve1-102',
      name: 'vm-102',
      vmid: 102,
    };
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [sampleResource, secondResource],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await waitForWorkloadCount(() => result!.workloads().length, 2);
    const coherentSnapshot = result!.workloads();

    apiFetchJSONMock
      .mockResolvedValueOnce({
        data: [sampleResource],
        meta: { totalPages: 2 },
      })
      .mockRejectedValueOnce(new Error('page 2 unavailable'));

    await expect(result!.refetch()).rejects.toThrow('page 2 unavailable');
    expect(result!.workloads()).toBe(coherentSnapshot);
    expect(result!.workloads()).toHaveLength(2);
    expect(result!.error()).toBeInstanceOf(Error);

    apiFetchJSONMock
      .mockResolvedValueOnce({
        data: [sampleResource],
        meta: { totalPages: 2 },
      })
      .mockResolvedValueOnce({
        data: [],
        meta: { totalPages: 2 },
      });
    await result!.refetch();

    expect(result!.workloads()).toHaveLength(1);
    expect(result!.error()).toBeUndefined();

    dispose();
  });

  it('does not apply in-flight workload results after the hook is disabled', async () => {
    const pendingFetch = deferred<unknown>();
    apiFetchJSONMock.mockImplementationOnce(() => pendingFetch.promise as Promise<any>);

    let dispose = () => {};
    let setEnabled: ((enabled: boolean) => boolean) | undefined;
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled, updateEnabled] = createSignal(true);
      setEnabled = updateEnabled;
      result = useWorkloads(enabled);
    });

    await flushAsync();
    expect(result!.loading()).toBe(true);

    setEnabled!(false);
    await flushAsync();
    expect(result!.loading()).toBe(false);

    pendingFetch.resolve({
      data: [sampleResource],
      meta: { totalPages: 1 },
    });
    await flushAsync();

    expect(result!.workloads()).toEqual([]);
    expect(result!.error()).toBeUndefined();

    dispose();
  });

  it('normalizes workload source aliases into canonical platform types', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        { ...sampleResource, id: 'vm-pve', sources: ['PROXMOX'] },
        { ...sampleResource, id: 'vm-pbs', sources: ['pbs'], name: 'vm-pbs' },
        { ...sampleResource, id: 'vm-pmg', sources: ['pmg'], name: 'vm-pmg' },
        {
          ...sampleResource,
          id: 'app-container:truenas-main:nextcloud',
          type: 'app-container',
          name: 'nextcloud',
          status: 'healthy',
          sources: ['agent', 'truenas'],
          parentName: 'truenas-main',
          docker: {
            containerId: 'nextcloud-ctr',
            image: 'ix-nextcloud:latest',
          },
        },
        {
          ...sampleResource,
          id: 'docker-container-frigate-141',
          type: 'app-container',
          name: 'frigate',
          status: 'running',
          sources: ['docker'],
          platformScopes: ['proxmox-pve', 'docker'],
          parentName: 'homepage-docker.lab',
          docker: {
            containerId: 'frigate',
            hostSourceId: 'proxmox-lxc-docker:pve-a:node-a:141',
            hostname: 'homepage-docker.lab',
            runtime: 'docker',
            image: 'ghcr.io/blakeblackshear/frigate:stable',
          },
        },
        {
          ...sampleResource,
          id: 'vmware-vm-crm',
          name: 'crm-app-01',
          status: undefined,
          sources: ['vmware'],
          parentName: 'esxi-01',
          proxmox: undefined,
          vmware: {
            managedObjectId: 'vm-101',
            runtimeHostName: 'esxi-01',
            clusterName: 'Compute-A',
            connectionName: 'Production vCenter',
            powerState: 'poweredOn',
          },
        },
        {
          ...sampleResource,
          id: 'vmware-vm-legacy',
          name: 'legacy-app-01',
          status: undefined,
          sources: ['vmware'],
          parentName: 'esxi-02',
          proxmox: undefined,
          vmware: {
            managedObjectId: 'vm-102',
            runtimeHostName: 'esxi-02',
            clusterName: 'Compute-A',
            connectionName: 'Production vCenter',
            powerState: 'poweredOff',
          },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length, 7);

    const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
    expect(byName.get('vm-101')?.platformType).toBe('proxmox-pve');
    expect(byName.get('vm-pbs')?.platformType).toBe('proxmox-pbs');
    expect(byName.get('vm-pmg')?.platformType).toBe('proxmox-pmg');
    expect(byName.get('nextcloud')?.platformType).toBe('truenas');
    expect(byName.get('nextcloud')?.platformScopes).toEqual(['truenas']);
    expect(byName.get('nextcloud')?.id).toBe('app-container:truenas-main:nextcloud');
    expect(byName.get('nextcloud')?.containerId).toBe('nextcloud-ctr');
    expect(byName.get('nextcloud')?.dockerHostId).toBeUndefined();
    expect(byName.get('frigate')?.platformType).toBe('docker');
    expect(byName.get('frigate')?.platformScopes).toEqual(['proxmox-pve', 'docker']);
    expect(byName.get('frigate')?.dockerHostId).toBe('proxmox-lxc-docker:pve-a:node-a:141');
    expect(byName.get('frigate')?.dockerHostName).toBe('homepage-docker.lab');
    expect(byName.get('crm-app-01')?.platformType).toBe('vmware-vsphere');
    expect(byName.get('crm-app-01')?.node).toBe('esxi-01');
    expect(byName.get('crm-app-01')?.instance).toBe('Compute-A');
    expect(byName.get('crm-app-01')?.status).toBe('running');
    expect(byName.get('legacy-app-01')?.status).toBe('stopped');

    dispose();
  });

  it('falls back to canonical resource.uptime when no platform-specific carve-out exists (vSphere)', async () => {
    // vSphere VMs surface uptime only on the canonical Resource.Uptime
    // field; there is no proxmox/agent/docker/kubernetes carve-out. The
    // useWorkloads mapping must land on resource.uptime so the workloads
    // table renders real "N days" cells rather than the blank "0s"
    // placeholder.
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'vmware-vm-uptime',
          name: 'lab-app-01',
          status: 'online',
          uptime: 12345678,
          sources: ['vmware'],
          parentName: 'esxi-01',
          proxmox: undefined,
          vmware: {
            managedObjectId: 'vm-901',
            runtimeHostName: 'esxi-01',
            clusterName: 'Compute-A',
            connectionName: 'Production vCenter',
            powerState: 'poweredOn',
          },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length, 1);

    const vm = result!.workloads().find((workload) => workload.name === 'lab-app-01');
    expect(vm?.uptime).toBe(12345678);

    dispose();
  });

  it('preserves API telemetry absence separately from reported zero values on every platform', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          id: 'vmware-vm-unknown-telemetry',
          type: 'vm',
          name: 'unknown-telemetry',
          status: 'online',
          lastSeen: 'not-a-timestamp',
          sources: ['vmware'],
          metrics: {},
          agent: { agentVersion: '6.2.0' },
          vmware: {
            managedObjectId: 'vm-903',
            powerState: 'poweredOn',
            cpuCount: 8,
          },
        },
        {
          id: 'docker-container-zero-telemetry',
          type: 'app-container',
          name: 'zero-telemetry',
          status: 'running',
          lastSeen: '2026-08-13T10:00:00Z',
          sources: ['docker'],
          uptime: 0,
          metrics: {
            cpu: { percent: 0 },
            memory: { used: 0, total: 1024, percent: 0 },
            disk: { used: 0, total: 2048, percent: 0 },
            netIn: { value: 0 },
            netOut: { value: 0 },
            diskRead: { value: 0 },
            diskWrite: { value: 0 },
          },
          docker: { containerId: 'zero', runtime: 'docker', uptimeSeconds: 0 },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await waitForWorkloadCount(() => result!.workloads().length, 2);
    const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));

    expect(byName.get('unknown-telemetry')).toMatchObject({
      cpus: 8,
      agentKind: 'pulse',
      lastSeen: '',
      telemetryAvailability: {
        cpu: false,
        memory: false,
        disk: false,
        networkIO: false,
        diskIO: false,
        uptime: false,
      },
    });
    expect(byName.get('zero-telemetry')).toMatchObject({
      cpu: 0,
      networkIn: 0,
      networkOut: 0,
      diskRead: 0,
      diskWrite: 0,
      uptime: 0,
      telemetryAvailability: {
        cpu: true,
        memory: true,
        disk: true,
        networkIO: true,
        diskIO: true,
        uptime: true,
      },
    });

    dispose();
  });

  it('renders vSphere row tags from the vCenter facet, never the provenance keyword set', async () => {
    // `Resource.Tags` on vSphere is a mixed keyword set: adapter provenance
    // strings (kept so resource search and the `?tags=` filter keep matching)
    // plus the operator's real vCenter tags. A per-row Tags cell must show
    // only the vCenter tags, and a vSphere VM nobody tagged must show nothing
    // rather than falling back to six identical provenance dots.
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'vmware-vm-tagged',
          name: 'tagged-app-01',
          sources: ['vmware'],
          proxmox: undefined,
          tags: [
            'vmware',
            'vsphere',
            'vm',
            'source:vcenter',
            'Environment:Production',
            'Owner:Data',
          ],
          vmware: {
            managedObjectId: 'vm-902',
            powerState: 'poweredOn',
            tags: [
              { name: 'Production', category: 'Environment', label: 'Environment:Production' },
              { name: 'Data', category: 'Owner', label: 'Owner:Data' },
            ],
          },
        },
        {
          ...sampleResource,
          id: 'vmware-vm-untagged',
          name: 'untagged-app-01',
          sources: ['vmware'],
          proxmox: undefined,
          tags: ['vmware', 'vsphere', 'vm', 'source:vcenter'],
          vmware: {
            managedObjectId: 'vm-903',
            powerState: 'poweredOn',
          },
        },
        {
          ...sampleResource,
          id: 'proxmox-vm-tagged',
          name: 'pve-app-01',
          tags: ['production', 'web'],
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length, 3);

    const byName = (name: string) => result!.workloads().find((workload) => workload.name === name);
    expect(byName('tagged-app-01')?.tags).toEqual(['Environment:Production', 'Owner:Data']);
    expect(byName('untagged-app-01')?.tags).toEqual([]);
    // Platforms whose flat tags are already real labels are untouched.
    expect(byName('pve-app-01')?.tags).toEqual(['production', 'web']);

    dispose();
  });

  it('preserves canonical discovery targets for workloads instead of inferring them from platform type', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'app-container:truenas-main:nextcloud',
          type: 'app-container',
          name: 'nextcloud',
          status: 'healthy',
          sources: ['agent', 'truenas'],
          parentName: 'truenas-main',
          discoveryTarget: {
            resourceType: 'app-container',
            agentId: 'truenas-helper',
            resourceId: 'nextcloud',
          },
          docker: {
            containerId: 'nextcloud-ctr',
            image: 'ix-nextcloud:latest',
          },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length, 1);

    expect(result!.workloads()[0]?.discoveryTarget).toEqual({
      resourceType: 'app-container',
      agentId: 'truenas-helper',
      resourceId: 'nextcloud',
      hostname: undefined,
    });

    dispose();
  });

  it('flags a workload whose canonical health names an open alert, not backup age', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'alerting',
          name: 'alerting',
          health: { verdict: 'attention', reasons: [{ code: 'warning_alert', detail: 'memory' }] },
        },
        {
          ...sampleResource,
          id: 'stale-backup',
          name: 'stale-backup',
          vmid: 102,
          health: { verdict: 'attention', reasons: [{ code: 'backup_stale' }] },
        },
        { ...sampleResource, id: 'quiet', name: 'quiet', vmid: 103 },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length, 3);

    const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
    expect(byName.get('alerting')?.hasOpenAlert).toBe(true);
    expect(byName.get('stale-backup')?.hasOpenAlert).toBe(false);
    expect(byName.get('quiet')?.hasOpenAlert).toBe(false);

    dispose();
  });

  it('uses the canonical Kubernetes cluster name for pod context labels', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'pod-1',
          type: 'pod',
          name: 'pod-1',
          kubernetes: {
            clusterId: 'cluster-id-a',
            clusterName: 'cluster-a',
            context: 'cluster-context',
            namespace: 'default',
            podUid: 'pod-uid-1',
          },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length);

    expect(result!.workloads()[0]?.contextLabel).toBe('cluster-a');
    expect(result!.workloads()[0]?.instance).toBe('cluster-a');
    expect(result!.workloads()[0]?.kubernetesClusterId).toBe('cluster-id-a');

    dispose();
  });

  it('retains canonical vSphere parent grouping through snapshot enrichment', async () => {
    const resource = {
      ...sampleResource,
      id: 'vm-warehouse-api',
      name: 'warehouse-api',
      sources: ['vmware'],
      parentId: 'host-vcenter-a:esxi-01',
      parentName: 'esxi-01',
      vmid: 0,
      node: undefined,
      instance: undefined,
      proxmox: undefined,
    };
    const [snapshot, setSnapshot] = createSignal([resource] as any);
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      result = useWorkloads(() => true, { resourceSnapshot: snapshot });
    });
    try {
      await flushAsync();
      const first = result!.workloads()[0]!;
      expect(first.parentResourceId).toBe(resource.parentId);
      expect(first.instance).toBe('');
      const group = getWorkloadGroupKey(first);
      setSnapshot([
        {
          ...resource,
          vmware: {
            runtimeHostName: 'esxi-01',
            clusterName: 'Production Cluster',
            connectionName: 'Lab vCenter',
          },
        },
      ]);
      await flushAsync();
      const enriched = result!.workloads()[0]!;
      expect(enriched.id).toBe(first.id);
      expect(enriched.instance).toBe('Production Cluster');
      expect(getWorkloadGroupKey(enriched)).toBe(group);
    } finally {
      dispose();
    }
  });

  it('never labels a vSphere or standalone Proxmox workload as its own cluster', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'vmware-vm-etl',
          name: 'etl-batch-01',
          sources: ['vmware'],
          parentName: 'esxi-01.lab.local',
          proxmox: undefined,
          vmware: {
            managedObjectId: 'vm-206',
            runtimeHostName: 'esxi-01.lab.local',
            clusterName: 'Production Cluster',
            connectionName: 'Lab vCenter',
            powerState: 'poweredOn',
          },
        },
        {
          ...sampleResource,
          id: 'pve-home-pve1-102',
          name: 'standalone-vm',
          vmid: 102,
          instance: 'pve-home',
          proxmox: {},
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length, 2);

    const byName = new Map(result!.workloads().map((workload) => [workload.name, workload]));
    expect(byName.get('etl-batch-01')?.clusterName).toBe('Production Cluster');
    expect(byName.get('etl-batch-01')?.contextLabel).toBe('esxi-01.lab.local (Production Cluster)');
    expect(byName.get('etl-batch-01')?.instance).toBe('Production Cluster');
    expect(byName.get('standalone-vm')?.clusterName).toBeUndefined();
    expect(byName.get('standalone-vm')?.contextLabel).toBe('pve1 (pve-home)');
    expect(byName.get('standalone-vm')?.instance).toBe('pve-home');

    dispose();
  });

  it('uses the shared cluster-name helper for proxmox workload labels', async () => {
    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'vm-1',
          type: 'vm',
          name: 'vm-1',
          instance: undefined,
          proxmox: {
            clusterName: 'cluster-b',
          },
        },
      ],
      meta: { totalPages: 1 },
    });

    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length);

    expect(result!.workloads()[0]?.clusterName).toBe('cluster-b');
    expect(result!.workloads()[0]?.contextLabel).toBe('pve1 (cluster-b)');
    expect(result!.workloads()[0]?.instance).toBe('cluster-b');
    expect(result!.workloads()[0]?.id).toBe('vm-1');

    dispose();
  });

  it('keeps workload reference stable when polling returns identical payload', async () => {
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    let effectRuns = 0;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
      createEffect(() => {
        result!.workloads();
        effectRuns += 1;
      });
    });

    await flushAsync();
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
    await waitForWorkloadCount(() => result!.workloads().length);
    const initialRef = result!.workloads();
    const initialEffectRuns = effectRuns;

    await advanceAndFlush(5_000);
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
    expect(result!.workloads()).toBe(initialRef);
    expect(effectRuns).toBe(initialEffectRuns);

    dispose();
  });

  it('maintains polling cadence under load without overlapping fetch churn', async () => {
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
    await waitForWorkloadCount(() => result!.workloads().length);

    const slowPoll = deferred<unknown>();
    apiFetchJSONMock.mockImplementationOnce(() => slowPoll.promise as Promise<any>);

    await advanceAndFlush(5_000);
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);

    await advanceAndFlush(10_000);
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);

    slowPoll.resolve({
      data: [sampleResource],
      meta: { totalPages: 1 },
    });
    await flushAsync();

    await advanceAndFlush(5_000);
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(3);

    dispose();
  });

  it('scopes shared cache by org and restores cached data when switching back', async () => {
    let dispose = () => {};
    let result: ReturnType<UseWorkloadsModule['useWorkloads']> | undefined;
    createRoot((d) => {
      dispose = d;
      const [enabled] = createSignal(true);
      result = useWorkloads(enabled);
    });

    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length);
    expect(apiFetchJSONMock).toHaveBeenCalledTimes(1);
    expect(result!.workloads()[0]?.id).toBe(sampleResource.id);

    apiFetchJSONMock.mockResolvedValueOnce({
      data: [
        {
          ...sampleResource,
          id: 'cluster-b-pve2-202',
          name: 'vm-202',
          vmid: 202,
          node: 'pve2',
          instance: 'cluster-b',
        },
      ],
      meta: { totalPages: 1 },
    });

    eventBus.emit('org_switched', 'tenant-b');
    await flushAsync();
    await waitForWorkloadCount(() => result!.workloads().length);

    expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
    expect(result!.workloads()[0]?.id).toBe('cluster-b-pve2-202');

    eventBus.emit('org_switched', 'default');
    await flushAsync();

    expect(apiFetchJSONMock).toHaveBeenCalledTimes(2);
    expect(result!.workloads()[0]?.id).toBe(sampleResource.id);

    dispose();
  });

  it('normalizes org scope through the shared helper', () => {
    expect(useWorkloadsSource).toContain('normalizeOrgScope(getOrgID())');
    expect(useWorkloadsSource).not.toContain("const DEFAULT_ORG_SCOPE = 'default'");
    expect(useWorkloadsSource).not.toContain('const normalizeOrgScope =');
  });
});

describe('resource-owned workload identity', () => {
  it.each(['vm', 'system-container', 'pod'] as const)(
    'preserves %s row identity when placement changes',
    async (type) => {
      const { useWorkloads, __resetWorkloadsCacheForTests } = await import('@/hooks/useWorkloads');
      __resetWorkloadsCacheForTests();
      const original = {
        ...sampleResource,
        id: 'stable-resource',
        type,
        proxmox: { instance: 'cluster-a', node: 'node-1', vmid: 101 },
        kubernetes: { clusterId: 'cluster-a', podUid: 'native-pod-uid' },
      };
      const [snapshot, setSnapshot] = createSignal([original] as any);
      let dispose = () => {};
      let result: ReturnType<typeof useWorkloads> | undefined;
      createRoot((d) => {
        dispose = d;
        result = useWorkloads(() => true, { resourceSnapshot: snapshot });
      });
      try {
        await flushAsync();
        expect(result!.workloads()[0]?.id).toBe(original.id);
        setSnapshot([
          { ...original, node: 'node-2', proxmox: { ...original.proxmox, node: 'node-2' } },
        ]);
        await flushAsync();
        expect(result!.workloads()[0]?.id).toBe(original.id);
        expect(result!.workloads()[0]?.canonicalResourceId).toBe(original.id);
      } finally {
        dispose();
      }
    },
  );
});