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
Keep restore-point identity readable without hover
pulse-triage[bot]28e181830efe
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 3e03903d50..c49b1ea819 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -10644,3 +10644,27 @@ usage and `Dialog.test.tsx` owns modal isolation/focus. Browser proof exercisesthe consuming TrueNAS table with ordinary keyboard/phone taps, hover parity,updates and dismissal, and natively inspected desktop/narrow pixels. This repairscomposition access, not the reporter's missing native ARC or I/O/History source.++### Restore-point identity is readable before narrow-screen disclosure++The existing Proxmox By date list groups workload name/type/target ID, PVE+workload connection, source kind, reader connection and repository location in+one wrapping identity cell below 720px table width. These are different scopes:+a PBS reader/namespace never supplies an unknown guest's PVE connection. Age and+state retain independent columns and their existing meanings. Wider tables keep+separate source/location columns and expose PVE scope beneath the workload name;+a hidden Target ID column never hides the ID itself. Full provider identifiers,+size and existing owner links remain in the same single-point drawer. This+changes no matching, posture, verification, pruning, filter, poll or API contract.++The three-column narrow projection reserves enough width for the grouped+identity, Unknown age and full state words instead of the old single-name 40%+anchor. Normal-suite `recoverableIdentityAccess.test.tsx` exercises the real+parsed inventory consumer across 320/479/480/719/720/1200px, namesakes, every source+kind, unmatched/host scope and open-record live refresh/focus. The registered+`ProxmoxBackupsTable.test.tsx` checks workload/reader separation before disclosure;+`ProxmoxRecoverableTable.test.tsx` and `proxmoxBackupsTablePresentation.test.ts`+protect grouped metadata, responsive columns and bounded rendering. Browser+proof must exercise the consuming list at desktop/narrow widths, inspect actual+pixels, identity, state/age fit, touch/keyboard disclosure, filters and live+updates. This is safer evidence inspection, not a restore or installed recovery.diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.mdindex 0216b19dd1..c88a249966 100644--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md@@ -8264,3 +8264,27 @@ invalid instants. Browser proof must inspect the actual consuming record atdesktop and narrow widths, including UTC text, keyboard/touch disclosure andrefresh/recovery with the open record preserved. This is evidence inspection,not original incident recovery.++### Restore-point identity is readable before narrow-screen disclosure++The existing Proxmox By date list groups workload name/type/target ID, PVE+workload connection, source kind, reader connection and repository location in+one wrapping identity cell below 720px table width. These are different scopes:+a PBS reader/namespace never supplies an unknown guest's PVE connection. Age and+state retain independent columns and their existing meanings. Wider tables keep+separate source/location columns and expose PVE scope beneath the workload name;+a hidden Target ID column never hides the ID itself. Full provider identifiers,+size and existing owner links remain in the same single-point drawer. This+changes no matching, posture, verification, pruning, filter, poll or API contract.++The three-column narrow projection reserves enough width for the grouped+identity, Unknown age and full state words instead of the old single-name 40%+anchor. Normal-suite `recoverableIdentityAccess.test.tsx` exercises the real+parsed inventory consumer across 320/479/480/719/720/1200px, namesakes, every source+kind, unmatched/host scope and open-record live refresh/focus. The registered+`ProxmoxBackupsTable.test.tsx` checks workload/reader separation before disclosure;+`ProxmoxRecoverableTable.test.tsx` and `proxmoxBackupsTablePresentation.test.ts`+protect grouped metadata, responsive columns and bounded rendering. Browser+proof must exercise the consuming list at desktop/narrow widths, inspect actual+pixels, identity, state/age fit, touch/keyboard disclosure, filters and live+updates. This is safer evidence inspection, not a restore or installed recovery.diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex af08eaa656..9ed78f5406 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -9018,3 +9018,27 @@ usage and `Dialog.test.tsx` owns modal isolation/focus. Browser proof exercisesthe consuming TrueNAS table with ordinary keyboard/phone taps, hover parity,updates and dismissal, and natively inspected desktop/narrow pixels. This repairscomposition access, not the reporter's missing native ARC or I/O/History source.++### Restore-point identity is readable before narrow-screen disclosure++The existing Proxmox By date list groups workload name/type/target ID, PVE+workload connection, source kind, reader connection and repository location in+one wrapping identity cell below 720px table width. These are different scopes:+a PBS reader/namespace never supplies an unknown guest's PVE connection. Age and+state retain independent columns and their existing meanings. Wider tables keep+separate source/location columns and expose PVE scope beneath the workload name;+a hidden Target ID column never hides the ID itself. Full provider identifiers,+size and existing owner links remain in the same single-point drawer. This+changes no matching, posture, verification, pruning, filter, poll or API contract.++The three-column narrow projection reserves enough width for the grouped+identity, Unknown age and full state words instead of the old single-name 40%+anchor. Normal-suite `recoverableIdentityAccess.test.tsx` exercises the real+parsed inventory consumer across 320/479/480/719/720/1200px, namesakes, every source+kind, unmatched/host scope and open-record live refresh/focus. The registered+`ProxmoxBackupsTable.test.tsx` checks workload/reader separation before disclosure;+`ProxmoxRecoverableTable.test.tsx` and `proxmoxBackupsTablePresentation.test.ts`+protect grouped metadata, responsive columns and bounded rendering. Browser+proof must exercise the consuming list at desktop/narrow widths, inspect actual+pixels, identity, state/age fit, touch/keyboard disclosure, filters and live+updates. This is safer evidence inspection, not a restore or installed recovery.diff --git a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsxindex 10bad4e7b1..920c18f81d 100644--- a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx+++ b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx@@ -33,6 +33,7 @@ import { useObservedElementWidth } from '@/hooks/useObservedElementWidth';import type { RecoverableArtifact } from './proxmoxBackupRecoveryModel';import type { RecoverableSortKey } from './proxmoxBackupsTableModel';import {+ ArtifactSourceBadge,ArtifactSourceIdentity,ArtifactStateBadge,PROXMOX_BACKUP_COLUMN_LABELS,@@ -108,8 +109,8 @@ const artifactVerificationText = (artifact: RecoverableArtifact): string => {return artifact.sourceKind === 'snapshot' ? '' : 'Not reported';};-// Phones drop the location, size and details columns, so the drawer is where-// a restore point is always readable in full.+// Size and provider identifiers remain progressive detail. Workload and+// repository identity must also be readable before choosing a point on a phone.const buildRecoverableDetailSections = (artifact: RecoverableArtifact): DetailSection[] => {const source = getProxmoxBackupSourcePresentation(artifact.sourceKind);return compactDetailSections([@@ -204,6 +205,7 @@ export function ProxmoxRecoverableTable(props: {: 'full';});const visibleColumns = createMemo(() => getRecoverableColumns(layoutMode()));+ const stackedIdentity = () => isCompactBackupIdentityLayout(layoutMode());const columnVisible = (column: RecoverableColumnId) =>visibleColumns().some((candidate) => candidate.id === column);const showDayGroups = () => props.groupByDay && props.sortKey() === 'created';@@ -238,34 +240,54 @@ export function ProxmoxRecoverableTable(props: {data-proxmox-backup-row="recoverable"><TableCell class={`${getPlatformTableCellClassForKind('name')} text-base-content`}>- <div class="flex min-w-0 items-center gap-1">+ <div class={`flex min-w-0 gap-2 ${stackedIdentity() ? 'items-start' : 'items-center'}`}><PlatformResourceDetailToggleButtonexpanded={drawer.isExpanded(artifact)}resourceLabel={getBackupWorkloadDisclosureLabel(artifact.workload)}controlsId={drawer.detailRowId(artifact)}onToggle={() => drawer.toggle(artifact)}/>- <div- class="min-w-0 truncate font-semibold"- title={[- artifact.workload.name || artifact.workload.label,- artifact.workload.typeLabel,- artifact.workload.vmid,- // The phone projection has no location column, so the row's- // hover title carries the repository instead.- columnVisible('location') ? undefined : artifact.location,- ]- .filter(Boolean)- .join(' · ')}- >- {artifact.workload.name || artifact.workload.label}- </div>- <Show when={isCompactBackupIdentityLayout(layoutMode())}>- <span class="shrink-0 text-[10px] text-muted">- {artifact.workload.typeLabel}- <Show when={artifact.workload.vmid}> {artifact.workload.vmid}</Show>+ <div class="min-w-0 flex-1">+ <span+ class={`block font-semibold ${stackedIdentity() ? 'whitespace-normal wrap-anywhere' : 'truncate'}`}+ title={artifact.workload.label}+ >+ {artifact.workload.name || artifact.workload.label}</span>- </Show>+ <Show when={!columnVisible('targetId') && artifact.workload.vmid}>+ <span class="block text-[10px] text-muted">+ {artifact.workload.typeLabel} {artifact.workload.vmid}+ </span>+ </Show>+ <Show when={getBackupWorkloadPVEConnection(artifact.workload)}>+ {(connection) => (+ <span+ class={`block text-[10px] text-muted ${stackedIdentity() ? 'whitespace-normal wrap-anywhere' : 'truncate'}`}+ title={`PVE connection: ${connection()}`}+ data-backup-workload-connection+ >+ PVE: {connection()}+ </span>+ )}+ </Show>+ <Show when={stackedIdentity()}>+ <div class="mt-1 space-y-0.5 text-[10px] leading-snug">+ <ArtifactSourceBadge artifact={artifact} wrap />+ <span+ class="block whitespace-normal text-muted wrap-anywhere"+ data-backup-source-connection+ >+ Connection: {artifact.locationConnection || 'Unknown connection'}+ </span>+ <span+ class="block whitespace-normal text-muted wrap-anywhere"+ data-backup-location+ >+ Location: {artifact.location}+ </span>+ </div>+ </Show>+ </div></div></TableCell><Show when={columnVisible('type')}>@@ -283,9 +305,11 @@ export function ProxmoxRecoverableTable(props: {{artifact.workload.vmid || '—'}</TableCell></Show>- <TableCell class={`${getPlatformTableCellClassForKind('text')} text-base-content`}>- <ArtifactSourceIdentity artifact={artifact} />- </TableCell>+ <Show when={columnVisible('source')}>+ <TableCell class={`${getPlatformTableCellClassForKind('text')} text-base-content`}>+ <ArtifactSourceIdentity artifact={artifact} />+ </TableCell>+ </Show><Show when={columnVisible('location')}><TableCell class={`${getPlatformTableCellClassForKind('text')} text-base-content`}><span class="block truncate" title={artifact.location}>@@ -380,13 +404,13 @@ export function ProxmoxRecoverableTable(props: {header={<><SortableHead- label="Workload"+ label={stackedIdentity() ? 'Restore point' : 'Workload'}sortKey="workload"currentSort={props.sortKey}direction={props.sortDirection}onSort={props.onSort}align="left"- headClass={`${getPlatformTableHeadClassForKind('name')} platform-table-mobile-w-30`}+ headClass={getPlatformTableHeadClassForKind('name')}/><Show when={columnVisible('type')}><TableHead class={getPlatformTableHeadClassForKind('text')}>Type</TableHead>@@ -396,15 +420,17 @@ export function ProxmoxRecoverableTable(props: {{PROXMOX_BACKUP_COLUMN_LABELS.targetId}</TableHead></Show>- <SortableHead- label={layoutMode() === 'compact' ? 'Via' : 'Source'}- sortKey="source"- currentSort={props.sortKey}- direction={props.sortDirection}- onSort={props.onSort}- align="left"- headClass={getPlatformTableHeadClassForKind('text')}- />+ <Show when={columnVisible('source')}>+ <SortableHead+ label="Source"+ sortKey="source"+ currentSort={props.sortKey}+ direction={props.sortDirection}+ onSort={props.onSort}+ align="left"+ headClass={getPlatformTableHeadClassForKind('text')}+ />+ </Show><Show when={columnVisible('location')}><SortableHeadlabel={layoutMode() === 'compact' ? 'Loc' : 'Location'}@@ -458,7 +484,7 @@ export function ProxmoxRecoverableTable(props: {items={tableItems}keyExtractor={(item) => `${item.kind}:${item.key}`}colSpan={visibleColumns().length}- estimatedRowHeight={32}+ estimatedRowHeight={stackedIdentity() ? 128 : 44}reserveScrollExtent>{(item) => (diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsxindex 697bd7d4e1..babffc2e31 100644--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx@@ -2935,3 +2935,39 @@ describe('bare Backups entry retains its assessed workspace', () => {await screen.findByText('No backups yet');});});++describe('By-date restore-point scope', () => {+ afterEach(() => vi.useRealTimers());+ it('shows the workload connection independently of its backup reader before disclosure', async () => {+ vi.useFakeTimers({ now: BACKUP_IDENTITY_NOW, toFake: ['Date'] });+ window.history.replaceState({}, '', '/proxmox/backups/date');+ apiFetchMock.mockImplementation((url: string) =>+ Promise.resolve(+ jsonResponse({+ data:+ url === '/api/backups/pbs'+ ? { backups: [identityPBS({ instance: 'independent-pbs-reader' })] }+ : { backupTasks: [], storageBackups: [], guestSnapshots: [] },+ }),+ ),+ );+ apiFetchJSONMock.mockResolvedValue({ data: [], policy: protectionPolicy });+ renderInRouter(() => (+ <ProxmoxBackupsTable+ emptyIcon={<span />}+ workloads={[identityGuest('east-100', 'east', 'pve-1')]}+ />+ ));+ const toggle = await screen.findByRole('button', {+ name: 'Expand details for east-100 (VM 100) · PVE connection: east',+ });+ const point = toggle.closest('tr')!;+ expect(point.querySelector('[data-backup-workload-connection]')).toHaveTextContent('PVE: east');+ expect(point.querySelector('[data-backup-source-connection]')).toHaveTextContent(+ 'independent-pbs-reader',+ );+ expect(screen.queryByTestId('proxmox-recoverable-detail')).not.toBeInTheDocument();+ expect(apiFetchMock).toHaveBeenCalledTimes(2);+ vi.useRealTimers();+ });+});diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsxindex 3bf7fee62a..0c7cb8d3d6 100644--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx@@ -128,19 +128,20 @@ describe('ProxmoxRecoverableTable record drawer', () => {});describe('ProxmoxRecoverableTable responsive columns', () => {- it('keeps source, location, recovery age, and state visible in compact containers', () => {+ it('groups full restore-point identity beside age and state in compact containers', () => {renderTable(330);expect([...document.querySelectorAll('thead th')].map((th) => th.textContent?.trim())).toEqual([- 'Workload',- 'Via',+ 'Restore point','Age▼','State',]);expect(document.body.textContent).toContain('VM 100');- // The phone projection has no location column; the row title carries it.- expect(document.body.textContent).not.toContain('main / pve1');- expect(document.querySelector('td [title*="main / pve1"]')).not.toBeNull();+ // No hover is needed to identify the repository on a phone.+ expect(document.querySelector('[data-backup-location]')).toHaveTextContent('main / pve1');+ expect(document.querySelector('[data-backup-source-connection]')).toHaveTextContent(+ 'Connection: Unknown connection',+ );expect(document.body.textContent).not.toContain('5 PBS files');});diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.tsindex c38384a1eb..bf281fc88b 100644--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts@@ -190,22 +190,11 @@ describe('Proxmox backups responsive table presentation', () => {});it('keeps the recovery-point answer visible before verbose metadata', () => {- expect(ids(getRecoverableColumns('compact'))).toEqual([- 'workload',- 'source',- 'created',- 'state',- ]);- expect(getRecoverableColumnWidthStyle('workload', 'compact')).toEqual({ width: '40%' });- expect(getRecoverableColumnWidthStyle('created', 'compact')).toEqual({ width: '21%' });- expect(getRecoverableColumnWidthStyle('state', 'compact')).toEqual({ width: '23%' });- expect(ids(getRecoverableColumns('basic'))).toEqual([- 'workload',- 'source',- 'location',- 'created',- 'state',- ]);+ expect(ids(getRecoverableColumns('compact'))).toEqual(['workload', 'created', 'state']);+ expect(getRecoverableColumnWidthStyle('workload', 'compact')).toEqual({ width: '53%' });+ expect(getRecoverableColumnWidthStyle('created', 'compact')).toEqual({ width: '22%' });+ expect(getRecoverableColumnWidthStyle('state', 'compact')).toEqual({ width: '25%' });+ expect(ids(getRecoverableColumns('basic'))).toEqual(['workload', 'created', 'state']);expect(ids(getRecoverableColumns('expanded'))).not.toContain('details');expect(ids(getRecoverableColumns('full'))).toHaveLength(9);});diff --git a/frontend-modern/src/features/proxmox/__tests__/recoverableIdentityAccess.test.tsx b/frontend-modern/src/features/proxmox/__tests__/recoverableIdentityAccess.test.tsxnew file mode 100644index 0000000000..0936e54df8--- /dev/null+++ b/frontend-modern/src/features/proxmox/__tests__/recoverableIdentityAccess.test.tsx@@ -0,0 +1,218 @@+import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';+import { Route, Router } from '@solidjs/router';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';++import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';+import type { PBSBackup, PVEBackupsPayload } from '@/types/api';+import { protectionPolicy } from '@/utils/__fixtures__/protectionPosture';+import { ProxmoxBackupsTable } from '../ProxmoxBackupsTable';+import {+ BACKUP_IDENTITY_NOW,+ identityArchive,+ identityGuest,+ identityPBS,+ identitySnapshot,+} from '../__fixtures__/backupIdentity';++const api = vi.hoisted(() => ({ fetch: vi.fn(), json: vi.fn(), width: 320 }));+vi.mock('@/utils/apiClient', () => ({ apiFetch: api.fetch, apiFetchJSON: api.json }));+vi.mock('@/hooks/useObservedElementWidth', () => ({+ useObservedElementWidth: () => ({ setElement: () => {}, width: () => api.width }),+}));++const name = 'accounting-database-production-primary';+const scopes = [+ 'pve.cluster.production.london.example.internal',+ 'pve.cluster.production.bristol.example.internal',+];+const workloads = () =>+ scopes.map((scope, index) => ({+ ...identityGuest(`guest-${index}`, scope, 'pve-1'),+ name,+ displayName: name,+ }));+const emptyPVE: PVEBackupsPayload = { storageBackups: [], guestSnapshots: [], backupTasks: [] };+const response = (data: unknown) =>+ new Response(JSON.stringify({ data }), { headers: { 'Content-Type': 'application/json' } });++function mount({+ guests = workloads(),+ pve = () => ({+ ...emptyPVE,+ storageBackups: scopes.map((scope, index) =>+ identityArchive({ id: `file-${index}`, instance: scope, storage: `repository-${index}` }),+ ),+ }),+ pbs = () => [] as PBSBackup[],+} = {}) {+ api.fetch.mockImplementation((url: string) =>+ Promise.resolve(response(url === '/api/backups/pbs' ? { backups: pbs() } : pve())),+ );+ api.json.mockResolvedValue({ data: [], policy: protectionPolicy });+ render(() => (+ <Router>+ <Route+ path="/*"+ component={() => <ProxmoxBackupsTable emptyIcon={<span />} workloads={guests} />}+ />+ </Router>+ ));+}+async function rows() {+ await waitFor(() =>+ expect(document.querySelector('[data-proxmox-backup-row="recoverable"]')).not.toBeNull(),+ );+ return Array.from(+ document.querySelectorAll<HTMLElement>('[data-proxmox-backup-row="recoverable"]'),+ );+}++beforeEach(() => {+ vi.useFakeTimers({ now: BACKUP_IDENTITY_NOW, toFake: ['Date'] });+ vi.resetAllMocks();+ api.width = 320;+ resetCreateNonSuspendingQueryCacheForTest();+ window.history.replaceState({}, '', '/proxmox/backups/date');+});+afterEach(() => {+ cleanup();+ resetCreateNonSuspendingQueryCacheForTest();+ vi.useRealTimers();+});++describe('restore-point identity without hover', () => {+ it.each([320, 479, 480, 719, 720, 1200])(+ 'keeps namesake workload and reader scope distinct at %ipx',+ async (width) => {+ api.width = width;+ mount();+ const points = await rows();+ expect(points).toHaveLength(2);+ for (const [index, scope] of scopes.entries()) {+ const row = points.find((point) =>+ point.querySelector('[data-backup-workload-connection]')?.textContent?.includes(scope),+ )!;+ expect(row).toBeDefined();+ expect(row).toHaveTextContent(name);+ expect(row).toHaveTextContent('100');+ expect(row.querySelector('[data-backup-source-connection]')).toHaveTextContent(scope);+ expect(row).toHaveTextContent(`repository-${index}`);+ if (width < 720) {+ for (const element of [+ within(row).getByText(name, { exact: true }),+ row.querySelector('[data-backup-workload-connection]')!,+ row.querySelector('[data-backup-source-connection]')!,+ row.querySelector('[data-backup-location]')!,+ ]) {+ expect(element).toHaveClass('whitespace-normal', 'wrap-anywhere');+ expect(element).not.toHaveClass('truncate');+ }+ expect(row.children).toHaveLength(3);+ expect(row.closest('table')?.querySelector('thead th')).toHaveTextContent('Restore point');+ }+ fireEvent.click(within(row).getByRole('button', { name: /Expand details/ }));+ const panel = screen.getByTestId('proxmox-recoverable-detail');+ expect(panel).toHaveTextContent(scope);+ expect(panel).toHaveTextContent(`repository-${index}`);+ expect(panel).not.toHaveTextContent(`repository-${1 - index}`);+ expect(within(panel).getByRole('link', { name: `Open ${name}` })).toHaveAttribute(+ 'href',+ `/proxmox/overview?resource=guest-${index}`,+ );+ }+ expect(api.fetch).toHaveBeenCalledTimes(2);+ expect(screen.getByRole('button', { name: '2 unknown' })).toBeInTheDocument();+ },+ );++ it.each(['pbs', 'archive', 'snapshot'] as const)(+ 'exposes the complete %s reader/location without changing its source kind',+ async (kind) => {+ const reader = 'backup.connection.long-name.example.internal';+ const location = 'repository-with-a-long-preserved-name';+ mount({+ guests: workloads().slice(0, 1),+ pve: () => ({+ ...emptyPVE,+ storageBackups:+ kind === 'archive' ? [identityArchive({ instance: scopes[0], storage: location })] : [],+ guestSnapshots: kind === 'snapshot' ? [identitySnapshot({ instance: scopes[0] })] : [],+ }),+ pbs: () =>+ kind === 'pbs'+ ? [identityPBS({ instance: reader, namespace: 'pve-1', datastore: location })]+ : [],+ });+ const [point] = await rows();+ expect(point.querySelector('[data-backup-workload-connection]')).toHaveTextContent(scopes[0]);+ expect(point.querySelector('[data-backup-source-connection]')).toHaveTextContent(+ kind === 'pbs' ? reader : scopes[0],+ );+ expect(point.querySelector('[data-backup-location]')).toHaveTextContent(+ kind === 'pbs' ? `${location} / pve-1` : kind === 'archive' ? location : 'pve-1',+ );+ expect(+ within(point.children[0] as HTMLElement).getByText(+ kind === 'pbs' ? 'PBS' : kind === 'archive' ? 'PVE file' : 'Snapshot',+ ),+ ).toBeInTheDocument();+ expect(point).toHaveTextContent(+ kind === 'pbs' ? 'Verified' : kind === 'snapshot' ? 'Snapshot' : 'Backup file',+ );+ },+ );++ it('does not borrow a reader connection for an ambiguous guest or host backup', async () => {+ mount({+ pve: () => emptyPVE,+ pbs: () => [+ identityPBS({ instance: 'shared-pbs', namespace: 'pve-1' }),+ identityPBS({ id: 'host', instance: 'shared-pbs', backupType: 'host', vmid: '0' }),+ ],+ });+ const points = await rows();+ expect(points).toHaveLength(2);+ const guest = points.find((point) => point.textContent?.includes('VM 100'))!;+ expect(guest.querySelector('[data-backup-workload-connection]')).toHaveTextContent(+ 'PVE: Not reported',+ );+ expect(guest.querySelector('[data-backup-source-connection]')).toHaveTextContent('shared-pbs');+ const host = points.find((point) => point !== guest)!;+ expect(host.querySelector('[data-backup-workload-connection]')).toBeNull();+ expect(host.querySelector('[data-backup-source-connection]')).toHaveTextContent('shared-pbs');+ fireEvent.click(within(guest).getByRole('button', { name: /Expand details/ }));+ expect(within(screen.getByTestId('proxmox-recoverable-detail')).queryByRole('link')).toBeNull();+ });++ it('updates an open point in place without dropping focus or borrowing its new reader', async () => {+ vi.useFakeTimers({+ now: BACKUP_IDENTITY_NOW,+ toFake: ['Date', 'setInterval', 'clearInterval'],+ });+ let reader = 'pbs-before';+ let datastore = 'before';+ mount({+ guests: workloads().slice(0, 1),+ pve: () => emptyPVE,+ pbs: () => [identityPBS({ instance: reader, datastore })],+ });+ const [point] = await rows();+ const toggle = within(point).getByRole('button', { name: /Expand details/ });+ fireEvent.click(toggle);+ toggle.focus();+ const panel = screen.getByTestId('proxmox-recoverable-detail');+ reader = 'pbs-after';+ datastore = 'after';+ await vi.advanceTimersByTimeAsync(30_000);+ await waitFor(() =>+ expect(point.querySelector('[data-backup-source-connection]')).toHaveTextContent(reader),+ );+ expect(point.querySelector('[data-backup-workload-connection]')).toHaveTextContent(scopes[0]);+ expect(point.querySelector('[data-backup-location]')).toHaveTextContent('after / pve-1');+ expect(screen.getByTestId('proxmox-recoverable-detail')).toBe(panel);+ expect(panel).toHaveTextContent(reader);+ expect(panel).not.toHaveTextContent('pbs-before');+ expect(document.activeElement).toBe(toggle);+ expect(api.fetch).toHaveBeenCalledTimes(4);+ });+});diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts b/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.tsindex 9c6cf2c440..dfc9dbd8da 100644--- a/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts+++ b/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts@@ -263,14 +263,12 @@ export const RECOVERABLE_COLUMNS: readonly BackupTableColumn<RecoverableColumnId];const RECOVERABLE_VISIBLE: Record<ProxmoxBackupsTableLayoutMode, readonly RecoverableColumnId[]> = {- // A recovery-point feed starts with identity, source, location, age, and- // verification. Size and verbose details progressively return with usable- // room; the full values remain available through their title affordance.- // The phone projection keeps the source and state badges and the age whole;- // the repository location returns with the first wider layout and stays in- // the row's hover title meanwhile.- compact: ['workload', 'source', 'created', 'state'],- basic: ['workload', 'source', 'location', 'created', 'state'],+ // Narrow restore-point rows group full workload/source/location identity in+ // the first cell. Separate tiny columns hid namesake connections behind hover+ // titles on touch devices. Age and state remain independent scan columns;+ // size and provider identifiers stay progressive detail in the drawer.+ compact: ['workload', 'created', 'state'],+ basic: ['workload', 'created', 'state'],operational: ['workload', 'type', 'source', 'location', 'created', 'size', 'state'],expanded: ['workload', 'type', 'targetId', 'source', 'location', 'created', 'size', 'state'],full: RECOVERABLE_COLUMNS.map((column) => column.id),@@ -280,11 +278,10 @@ const RECOVERABLE_WEIGHTS: Record<ProxmoxBackupsTableLayoutMode,Partial<Record<RecoverableColumnId, number>>> = {- // Unknown is a safety answer, not an abbreviated age: reserve room for- // the whole word alongside complete state badges (including Failed and- // Running). Identity remains on the canonical 40% anchor.- compact: { workload: 40, source: 16, created: 21, state: 23 },- basic: { workload: 28, source: 14, location: 23, created: 18, state: 17 },+ // Grouping identity needs more room than a single name. Keep Unknown ages+ // and full state words readable rather than trading one hidden fact for another.+ compact: { workload: 53, created: 22, state: 25 },+ basic: { workload: 58, created: 20, state: 22 },operational: {workload: 24,type: 8,@@ -332,15 +329,6 @@ export const getRecoverableColumnWidthStyle = (columnId,RECOVERABLE_WEIGHTS[layout],RECOVERABLE_VISIBLE[layout],- layout === 'compact' || layout === 'basic'- ? {- columnId: 'workload',- widthPercent:- layout === 'compact'- ? PLATFORM_TABLE_NARROW_IDENTITY_WIDTH_PERCENT- : PLATFORM_TABLE_PHONE_IDENTITY_WIDTH_PERCENT,- }- : undefined,);export const isCompactBackupIdentityLayout = (layout: ProxmoxBackupsTableLayoutMode): boolean =>