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.

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.md
index 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 recovery
Coverage’s existing expanded detail shows the scoped latest PVE task’s reported
diff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
index 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 (one
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index 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 recovery
Coverage’s existing expanded detail shows the scoped latest PVE task’s reported
diff --git a/frontend-modern/src/components/Workloads/__tests__/backupTimestampFlow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/backupTimestampFlow.test.tsx
new file mode 100644
index 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.ts
index 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.ts
index 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): bool
return !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.ts
index 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.ts
index 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 keeps
diff --git a/frontend-modern/src/utils/__tests__/backupTimestamp.test.ts b/frontend-modern/src/utils/__tests__/backupTimestamp.test.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 70680f830e..02e5162276 100644
--- a/frontend-modern/src/utils/format.ts
+++ b/frontend-modern/src/utils/format.ts
@@ -1,5 +1,6 @@
// Type-safe formatting utilities
import 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())