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 Workloads backup completions on the strict timestamp path
pulse-triage[bot]d60e4a5541b5
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex f788125c84..fa66961484 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -20,6 +20,18 @@## Purpose+### Backup age and completion do not normalise malformed strings++The backup badge, shield disclosure and guest drawer share Backups inventory's+strict calendar/zone parser. A present impossible, unzoned or date-only time is+Unknown, never a green completed backup or an invented exact UTC completion.+Numeric/Date inputs and valid zoned instants retain policy-relative age,+current activity and existing absence/future semantics. `backupTimestamp.test.ts`+and `backupTimestampFlow.test.tsx` cover direct formatting and REST/snapshot+production consumers, recovery/recurrence, details and focus. Desktop/narrow+browser proof must exercise these changed producers through the real consumers.+See storage-recovery's backup completion rule; no restore/thaw claim is added.+### Latest backup task evidence stays separate from recoveryCoverage’s existing expanded detail shows the scoped latest PVE task’s reporteddiff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex acf31ff234..966c641453 100644--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md@@ -15,6 +15,18 @@## Purpose+### Workloads maps backup instants once per resource update++The REST and owning-snapshot adapters use the shared strict backup timestamp+parser before producing numeric WorkloadGuest completion evidence. Impossible,+unzoned/date-only input produces unknown numeric evidence (NaN), not a normalised+completion or absence. Zero/Go-zero absence, valid zoned values, VM/LXC identity,+backup activity, snapshot ownership, row reconciliation and polling are unchanged.+No new request, clock subscription or per-visible-row parse loop is added.+The existing `useWorkloads.test.ts` invalid-evidence controls and normal-suite+`backupTimestampFlow.test.tsx` exercise producer-to-badge/shield/drawer updates;+source-bound desktop/narrow browser proof covers live recovery and recurrence.+### Drawer History scrubbing does not reflow (26 October 2026)Reserved readout widths are derived from the points a panel already holds (onediff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.mdindex 4f263272fc..3da26f8451 100644--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md@@ -21,6 +21,29 @@## Purpose+### Backup completion strings share one strict instant rule++Backups inventory and Workloads use the same calendar-checked, explicitly zoned+RFC3339 parser for reported backup times. Workloads must not turn impossible+calendar dates, date-only strings or browser-local times into numeric completed+backups before the badge, shield or guest drawer sees them. Age and exact UTC+completion formatting apply the same rule to direct string inputs. Invalid+present evidence stays Unknown, not fresh or absent; only existing absence+sentinels (including Go zero time in resource mapping) mean no recorded backup.+Numeric/Date inputs, valid offsets/leap days/fractions, future-time uncertainty,+policy thresholds, backup activity, identity and canonical posture are unchanged.+No backup/restore, filesystem or guest operation is added.++Normal-suite `backupTimestamp.test.ts` checks shared age/completion admission and+valid controls. `backupTimestampFlow.test.tsx` drives REST and owning-snapshot+resource updates through real badge, shield disclosure and guest drawer for+VM/LXC, recovery and recurrence while preserving open details/focus. Existing+inventory timestamp tests continue to cover PBS/files/snapshots/task chronology.+Source-bound desktop/narrow browser proof must exercise the changed resource+producer and those consuming surfaces, not just a formatter demonstration.+This is presentation truthfulness, not original stale-date causality, restore+availability, thaw or every-filesystem recovery.+### Latest backup task evidence stays separate from recoveryCoverage’s existing expanded detail shows the scoped latest PVE task’s reporteddiff --git a/frontend-modern/src/components/Workloads/__tests__/backupTimestampFlow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/backupTimestampFlow.test.tsxnew file mode 100644index 0000000000..d3bf3fc3a4--- /dev/null+++ b/frontend-modern/src/components/Workloads/__tests__/backupTimestampFlow.test.tsx@@ -0,0 +1,184 @@+import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';+import { Show, createSignal } from 'solid-js';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { useWorkloads, __resetWorkloadsCacheForTests } from '@/hooks/useWorkloads';+import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';+import type { Resource } from '@/types/resource';+import { GuestDrawer } from '../GuestDrawer';+import { BackupIndicator, BackupStatusCell } from '../GuestRowCells';++const api = vi.hoisted(() => ({ json: vi.fn() }));+vi.mock('@/utils/apiClient', () => ({+ apiFetchJSON: api.json,+ getOrgID: () => 'default',+}));+vi.mock('@/stores/alertsActivation', () => ({+ useAlertsActivation: () => ({+ getBackupThresholds: () => ({ freshHours: 24, staleHours: 72 }),+ getMetricThresholds: () => null,+ }),+}));+vi.mock('@/api/charts', async () => {+ const actual = await vi.importActual<typeof import('@/api/charts')>('@/api/charts');+ return {+ ...actual,+ ChartsAPI: {+ ...actual.ChartsAPI,+ getMetricsHistory: vi.fn().mockResolvedValue({ metrics: {} }),+ },+ };+});+vi.mock('@/api/resourceOperatorState', () => ({+ getResourceOperatorState: vi.fn().mockResolvedValue(null),+}));+vi.mock('@/stores/license', () => ({+ isRangeLocked: () => false,+ loadRuntimeCapabilities: vi.fn(),+ maxHistoryDays: () => 90,+}));++const now = Date.parse('2026-10-04T12:00:00Z');+const valid = '2026-10-04T13:00:00.123456789+02:00';+const iso = '2026-10-04T11:00:00.123Z';+const malformed = ['2026-09-31T11:00:00Z', '2026-10-04T11:00:00', '2026-10-04'];++const rawResource = (lastBackup: string, type: 'vm' | 'system-container', running: boolean) => ({+ id: 'east-100',+ name: 'backup-time-guest',+ type,+ status: 'running',+ lastSeen: new Date(now).toISOString(),+ sources: ['proxmox'],+ proxmox: { vmid: 100, instance: 'east', node: 'pve-1', lastBackup, backupInProgress: running },+});++function mount(transport: 'api' | 'snapshot', type: 'vm' | 'system-container') {+ let raw = rawResource(malformed[0], type, false);+ api.json.mockImplementation(() => Promise.resolve({ data: [raw], meta: { totalPages: 1 } }));+ const [snapshot, setSnapshot] = createSignal<Resource[]>([raw as unknown as Resource]);+ let source!: ReturnType<typeof useWorkloads>;+ render(() => {+ source = useWorkloads(+ () => true,+ transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},+ );+ const guest = () => source.workloads()[0];+ return (+ <Show when={guest()}>+ <BackupStatusCell+ lastBackup={guest().lastBackup}+ backupRunning={guest().backupInProgress}+ />+ <BackupIndicator+ lastBackup={guest().lastBackup}+ backupRunning={guest().backupInProgress}+ isTemplate={false}+ />+ <GuestDrawer guest={guest()} onClose={() => {}} />+ </Show>+ );+ });+ return {+ source: () => source,+ update: async (value: string, running = false) => {+ raw = rawResource(value, type, running);+ if (transport === 'snapshot') setSnapshot([raw as unknown as Resource]);+ else await source.refetch();+ },+ };+}++const backupRow = () =>+ within(screen.getByTestId('guest-drawer-overview'))+ .getByText('Last completed backup')+ .closest('tr')!;++beforeEach(() => {+ vi.useFakeTimers({ now, toFake: ['Date'] });+ __resetWorkloadsCacheForTests();+ resetCreateNonSuspendingQueryCacheForTest();+ api.json.mockReset();+});+afterEach(() => {+ cleanup();+ __resetWorkloadsCacheForTests();+ resetCreateNonSuspendingQueryCacheForTest();+ vi.useRealTimers();+});++describe.each(['api', 'snapshot'] as const)(+ 'backup time through %s resource producer',+ (transport) => {+ it.each(['vm', 'system-container'] as const)(+ '[regression] keeps malformed %s evidence unknown through live recovery and recurrence',+ async (type) => {+ const view = mount(transport, type);+ const badge = await screen.findByRole('button', { name: /^Backup status:/ });+ const details = screen.getByTestId('guest-technical-details') as HTMLDetailsElement;+ details.open = true;+ badge.focus();+ fireEvent.click(badge);+ const dialog = screen.getByRole('dialog', { name: /^Backup status details/ });+ const close = within(dialog).getByRole('button', { name: 'Close backup details' });+ close.focus();+ for (const value of malformed) {+ await view.update(value);+ await waitFor(() => expect(badge).toHaveTextContent('Unknown'));+ expect(view.source().workloads()[0].lastBackup).toBeNaN();+ expect(badge.className).not.toContain('green');+ expect(+ screen.getByRole('button', { name: /^Backup time unavailable:/ }),+ ).toBeInTheDocument();+ expect(dialog.querySelector('time')).toBeNull();+ expect(backupRow()).toHaveTextContent('invalid timestamp');+ expect(backupRow().querySelector('time')).toBeNull();+ expect(screen.getByTestId('guest-technical-details')).toBe(details);+ expect(close).toHaveFocus();+ }+ await view.update(valid);+ await waitFor(() => expect(badge).toHaveAccessibleName(/fresh/));+ expect(view.source().workloads()[0].lastBackup).toBe(Date.parse(iso));+ expect(dialog.querySelector('time')).toHaveAttribute('datetime', iso);+ expect(backupRow().querySelector('time')).toHaveAttribute('datetime', iso);+ expect(dialog.querySelector('time')).toHaveTextContent('2026-10-04 11:00:00 UTC');+ expect(badge.className).toContain('green');+ await view.update(malformed[0], true);+ await waitFor(() => expect(badge).toHaveTextContent('Running'));+ expect(badge).toHaveAccessibleName(/invalid timestamp/);+ expect(dialog.querySelector('time')).toBeNull();+ expect(backupRow().querySelector('time')).toBeNull();+ expect(screen.getByTestId('guest-drawer-overview')).toHaveTextContent(+ 'Running · not completed yet',+ );+ expect(screen.getByRole('dialog', { name: /^Backup status details/ })).toBe(dialog);+ expect(close).toHaveFocus();+ fireEvent.click(close);+ expect(badge).toHaveFocus();+ expect(view.source().workloads()[0]).toMatchObject({+ id: 'east-100',+ name: 'backup-time-guest',+ instance: 'east',+ vmid: 100,+ node: 'pve-1',+ });+ if (transport === 'snapshot') expect(api.json).not.toHaveBeenCalled();+ else expect(api.json).toHaveBeenCalledTimes(6);+ },+ );++ it('[control] preserves explicit absence, valid offsets and future uncertainty', async () => {+ const view = mount(transport, 'vm');+ const badge = await screen.findByRole('button', { name: /^Backup status:/ });+ for (const value of ['', '0001-01-01T00:00:00Z', '0001-01-01T00:00:00.000000000Z']) {+ await view.update(value);+ await waitFor(() => expect(badge).toHaveTextContent('None'));+ expect(view.source().workloads()[0].lastBackup).toBe(0);+ }+ await view.update('2026-10-04T04:00:00-07:00');+ await waitFor(() => expect(badge).toHaveAccessibleName(/fresh/));+ await view.update('2026-10-04T12:00:01Z');+ await waitFor(() => expect(badge).toHaveAccessibleName(/timestamp is in the future/));+ expect(view.source().workloads()[0].lastBackup).toBe(now + 1000);+ });+ },+);diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.tsindex da2628e44f..ef88d29bc3 100644--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts@@ -3,6 +3,7 @@ import { describe, expect, it } from 'vitest';import type { BackupTask, GuestSnapshot, PBSBackup, StorageBackup } from '@/types/api';import type { ProtectionPosture, ProtectionState } from '@/types/recovery';import type { Resource } from '@/types/resource';+import { getBackupInfo, formatBackupCompletionTime } from '@/utils/format';import {buildProxmoxBackupRecoveryModel,coverageRowMatchesSearch,@@ -741,3 +742,36 @@ describe('completed restore-point totals', () => {expect(complete.recoverableArtifacts[0].id).toBe(pending.recoverableArtifacts[0].id);});});++describe('shared backup instant rule across inventory and workload age', () => {+ it.each([+ ['2026-09-31T11:00:00Z', undefined],+ ['2026-10-04T11:00:00', undefined],+ ['2026-10-04', undefined],+ ['2026-10-04T13:00:00+02:00', Date.parse('2026-10-04T11:00:00Z')],+ ] as const)('keeps the same evidence for %s', (time, expectedMs) => {+ const nowMs = Date.parse('2026-10-04T12:00:00Z');+ const model = buildProxmoxBackupRecoveryModel({+ workloads: [workload({})],+ pbsBackups: [pbsBackup({ backupTime: time })],+ archives: [],+ snapshots: [],+ tasks: [],+ nowMs,+ });+ expect(model.recoverableArtifacts).toHaveLength(1);+ expect(model.recoverableArtifacts[0].createdAt).toBe(time);+ expect(model.recoverableArtifacts[0].createdMs).toBe(expectedMs);+ expect(model.coverageSummary.recoverableArtifacts).toBe(1);+ const info = getBackupInfo(time, undefined, nowMs);+ if (expectedMs === undefined) {+ expect(info.status).toBe('unknown');+ expect(formatBackupCompletionTime(time)).toBeNull();+ } else {+ expect(info.status).toBe('fresh');+ expect(formatBackupCompletionTime(time)?.completedAt).toBe(+ new Date(expectedMs).toISOString(),+ );+ }+ });+});diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts b/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.tsindex b68f548c14..18a3f25269 100644--- a/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts+++ b/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts@@ -1,6 +1,7 @@import type { BackupTask, GuestSnapshot, PBSBackup, StorageBackup } from '@/types/api';import type { ProtectionPosture, ProtectionState } from '@/types/recovery';import type { Resource } from '@/types/resource';+import { parseBackupTimestampMs } from '@/utils/backupTimestamp';import { backupLocationScope, type BackupLocationScope } from './proxmoxBackupLocation';import {@@ -165,43 +166,6 @@ export function isCompletedRecoveryArtifact(artifact: RecoverableArtifact): boolreturn !artifact.running && !artifact.failed;}-function parseTimestampMs(value: string | undefined): number | undefined {- if (!value) return undefined;- // The API's time.Time values carry an explicit RFC3339 zone. Date.parse- // alone also accepts browser-local dates and normalises impossible dates- // (September 31 becomes October 1). Neither is evidence for age or order.- const parts =- /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(Z|[+-]\d{2}:\d{2})$/.exec(- value,- );- if (!parts) return undefined;- const [, yearText, monthText, dayText, hourText, minuteText, secondText, zone] = parts;- const [year, month, day, hour, minute, second] = [- yearText,- monthText,- dayText,- hourText,- minuteText,- secondText,- ].map(Number);- const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);- const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];- if (- month < 1 ||- month > 12 ||- day < 1 ||- day > daysInMonth[month - 1] ||- hour > 23 ||- minute > 59 ||- second > 59 ||- (zone !== 'Z' && (Number(zone.slice(1, 3)) > 23 || Number(zone.slice(4)) > 59))- ) {- return undefined;- }- const ms = Date.parse(value);- return Number.isFinite(ms) ? ms : undefined;-}-function archiveFileName(volid: string | undefined): string {const trimmed = volid?.trim() ?? '';if (!trimmed) return '';@@ -579,8 +543,8 @@ function taskLabel(task: BackupTask): string {}function taskDurationSeconds(task: BackupTask): number | undefined {- const start = parseTimestampMs(task.startTime);- const end = parseTimestampMs(task.endTime);+ const start = parseBackupTimestampMs(task.startTime);+ const end = parseBackupTimestampMs(task.endTime);if (start === undefined || end === undefined || end <= start) return undefined;return Math.round((end - start) / 1000);}@@ -686,7 +650,7 @@ export function buildProxmoxBackupRecoveryModel(for (const backup of input.pbsBackups) {const workload = resolvePBSWorkload(candidateIndex, backup);- const parsedMs = parseTimestampMs(backup.backupTime);+ const parsedMs = parseBackupTimestampMs(backup.backupTime);const createdMs =getRecoveryAgeBand(parsedMs, input.nowMs) === 'unknown' ? undefined : parsedMs;const running =@@ -726,7 +690,7 @@ export function buildProxmoxBackupRecoveryModel(archive.instance,archive.node,);- const parsedMs = parseTimestampMs(archive.time);+ const parsedMs = parseBackupTimestampMs(archive.time);const createdMs =getRecoveryAgeBand(parsedMs, input.nowMs) === 'unknown' ? undefined : parsedMs;addArtifact({@@ -762,7 +726,7 @@ export function buildProxmoxBackupRecoveryModel(snapshot.instance,snapshot.node,);- const parsedMs = parseTimestampMs(snapshot.time);+ const parsedMs = parseBackupTimestampMs(snapshot.time);const createdMs =getRecoveryAgeBand(parsedMs, input.nowMs) === 'unknown' ? undefined : parsedMs;addArtifact({@@ -787,7 +751,7 @@ export function buildProxmoxBackupRecoveryModel(const workload = resolveTaskWorkload(candidateIndex, pveWorkloadsByVmid, task);if (!workload) continue;const row = ensureRow(workload, true);- const parsedStart = parseTimestampMs(task.startTime);+ const parsedStart = parseBackupTimestampMs(task.startTime);const candidateTask: CoverageTask = {id: task.id,status: task.status,diff --git a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts b/frontend-modern/src/hooks/__tests__/useWorkloads.test.tsindex 26aa3fa2fd..3e7aa66b6d 100644--- a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts+++ b/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts@@ -269,24 +269,30 @@ describe('useWorkloads', () => {},);- it.each(['invalid', '0002-01-01T00:00:00Z'])(- '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);- } 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([diff --git a/frontend-modern/src/hooks/useWorkloads.ts b/frontend-modern/src/hooks/useWorkloads.tsindex d2afcaff1e..766dea599f 100644--- a/frontend-modern/src/hooks/useWorkloads.ts+++ b/frontend-modern/src/hooks/useWorkloads.ts@@ -10,6 +10,7 @@ import {} from '@/utils/sourcePlatforms';import { canonicalDiscoveryResourceType } from '@/utils/discoveryTarget';import { normalizeDiskArray } from '@/utils/format';+import { parseBackupTimestampMs } from '@/utils/backupTimestamp';import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';import {getWorkloadCPUFraction,@@ -643,7 +644,7 @@ const mapResourceToWorkload = (resource: APIResource): WorkloadGuest | null => {// Go zero time is an explicit absence sentinel. Keep other invalid// readings (NaN included) distinct so the UI can report uncertainty.if (!timestamp || /^0001-01-01T00:00:00(?:\.0+)?Z$/.test(timestamp)) return 0;- return Date.parse(timestamp);+ return parseBackupTimestampMs(timestamp) ?? NaN;})(),backupInProgress: resource.proxmox?.backupInProgress ?? false,// vSphere's flat `resource.tags` is a mixed keyword set: the adapter keepsdiff --git a/frontend-modern/src/utils/__tests__/backupTimestamp.test.ts b/frontend-modern/src/utils/__tests__/backupTimestamp.test.tsnew file mode 100644index 0000000000..8962a47bf6--- /dev/null+++ b/frontend-modern/src/utils/__tests__/backupTimestamp.test.ts@@ -0,0 +1,61 @@+import { describe, expect, it } from 'vitest';+import { parseBackupTimestampMs } from '../backupTimestamp';+import { formatBackupCompletionTime, getBackupInfo } from '../format';++const now = Date.parse('2026-10-04T12:00:00Z');++describe('shared backup timestamp evidence', () => {+ it.each([+ '2026-09-31T11:00:00Z',+ '2026-02-29T11:00:00Z',+ '2026-04-31T11:00:00Z',+ '1900-02-29T11:00:00Z',+ '2026-10-04T11:00:00',+ '2026-10-04',+ '10/04/2026',+ '2026-10-04T24:00:00Z',+ '2026-10-04T11:60:00Z',+ '2026-10-04T11:00:60Z',+ '2026-10-04T11:00:00+24:00',+ '2026-10-04T11:00:00+01:60',+ '2026-10-04T11:00:00.1234567890Z',+ '2026-10-04T11:00:00Z trailing',+ 'invalid',+ ])('[regression] never manufactures backup age or completion from %s', (value) => {+ expect(parseBackupTimestampMs(value)).toBeUndefined();+ expect(getBackupInfo(value, undefined, now)).toEqual({+ status: 'unknown',+ ageMs: null,+ ageFormatted: 'Backup time unavailable: invalid timestamp.',+ });+ expect(formatBackupCompletionTime(value)).toBeNull();+ });++ it.each([+ ['2026-10-04T11:00:00Z', '2026-10-04T11:00:00.000Z'],+ ['2026-10-04T13:00:00+02:00', '2026-10-04T11:00:00.000Z'],+ ['2026-10-04T04:00:00-07:00', '2026-10-04T11:00:00.000Z'],+ ['2026-10-04T11:00:00.123456789Z', '2026-10-04T11:00:00.123Z'],+ ['2024-02-29T11:00:00Z', '2024-02-29T11:00:00.000Z'],+ ['2000-02-29T11:00:00Z', '2000-02-29T11:00:00.000Z'],+ ['2026-10-04T00:30:00+14:00', '2026-10-03T10:30:00.000Z'],+ ])('[control] preserves a real zoned instant %s', (value, iso) => {+ const ms = Date.parse(iso);+ expect(parseBackupTimestampMs(value)).toBe(ms);+ expect(getBackupInfo(value, undefined, now)).toEqual(getBackupInfo(ms, undefined, now));+ expect(formatBackupCompletionTime(value)).toEqual(formatBackupCompletionTime(ms));+ expect(formatBackupCompletionTime(value)?.completedAt).toBe(iso);+ });++ it.each([null, undefined, '', 0])('[control] keeps absence sentinel %s distinct', (value) => {+ expect(getBackupInfo(value, undefined, now).status).toBe('never');+ });++ it('[control] keeps numeric/Date completions, future uncertainty and policy limits', () => {+ const ms = now - 2 * 3600_000;+ expect(formatBackupCompletionTime(new Date(ms))).toEqual(formatBackupCompletionTime(ms));+ expect(getBackupInfo(ms, { freshHours: 1 }, now).status).toBe('stale');+ expect(getBackupInfo(ms, { freshHours: 3 }, now).status).toBe('fresh');+ expect(getBackupInfo('2026-10-04T12:00:01Z', undefined, now).status).toBe('unknown');+ });+});diff --git a/frontend-modern/src/utils/backupTimestamp.ts b/frontend-modern/src/utils/backupTimestamp.tsnew file mode 100644index 0000000000..edb3646eeb--- /dev/null+++ b/frontend-modern/src/utils/backupTimestamp.ts@@ -0,0 +1,37 @@+/** Read a reported backup instant without inventing a date or browser timezone. */+export function parseBackupTimestampMs(value: string | undefined): number | undefined {+ if (!value) return undefined;+ // The API's time.Time values carry an explicit RFC3339 zone. Date.parse+ // alone also accepts browser-local dates and normalises impossible dates+ // (September 31 becomes October 1). Neither is evidence for age or order.+ const parts =+ /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(Z|[+-]\d{2}:\d{2})$/.exec(+ value,+ );+ if (!parts) return undefined;+ const [, yearText, monthText, dayText, hourText, minuteText, secondText, zone] = parts;+ const [year, month, day, hour, minute, second] = [+ yearText,+ monthText,+ dayText,+ hourText,+ minuteText,+ secondText,+ ].map(Number);+ const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);+ const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];+ if (+ month < 1 ||+ month > 12 ||+ day < 1 ||+ day > daysInMonth[month - 1] ||+ hour > 23 ||+ minute > 59 ||+ second > 59 ||+ (zone !== 'Z' && (Number(zone.slice(1, 3)) > 23 || Number(zone.slice(4)) > 59))+ ) {+ return undefined;+ }+ const ms = Date.parse(value);+ return Number.isFinite(ms) ? ms : undefined;+}diff --git a/frontend-modern/src/utils/format.ts b/frontend-modern/src/utils/format.tsindex 70680f830e..02e5162276 100644--- a/frontend-modern/src/utils/format.ts+++ b/frontend-modern/src/utils/format.ts@@ -1,5 +1,6 @@// Type-safe formatting utilitiesimport type { Disk } from '@/types/api';+import { parseBackupTimestampMs } from './backupTimestamp';type DiskInput = {device?: string;@@ -291,8 +292,15 @@ export interface BackupInfo {export function formatBackupCompletionTime(timestamp: string | number | Date,): { completedAt: string; dateLabel: string } | null {- const date = new Date(timestamp instanceof Date ? timestamp.getTime() : timestamp);- if (!Number.isFinite(date.getTime()) || date.getTime() <= 0) return null;+ const ms =+ typeof timestamp === 'string'+ ? parseBackupTimestampMs(timestamp)+ : timestamp instanceof Date+ ? timestamp.getTime()+ : timestamp;+ if (ms === undefined || !Number.isFinite(ms) || ms <= 0) return null;+ const date = new Date(ms);+ if (!Number.isFinite(date.getTime())) return null;const completedAt = date.toISOString();return {completedAt,@@ -338,14 +346,11 @@ export function getBackupInfo(return { status: 'never', ageMs: null, ageFormatted: 'Never' };}- let timestamp: number;- if (typeof lastBackup === 'string') {- timestamp = new Date(lastBackup).getTime();- } else {- timestamp = lastBackup;- }+ const timestamp =+ typeof lastBackup === 'string' ? parseBackupTimestampMs(lastBackup) : lastBackup;if (+ timestamp === undefined ||!Number.isFinite(timestamp) ||timestamp <= 0 ||!Number.isFinite(new Date(timestamp).getTime())