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 incomplete backup entries out of completed restore totals

pulse-triage[bot]a91d1ed89d8a
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index 38d99d7e52..27753f069d 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
+### Backups distinguishes completed points from inventory entries (24 October 2026)
+
+The existing health strip names completed restore points and separately counts
+running and failed entries. The existing per-day chart measures only completed
+restore points in both count and volume modes, while the dated table and its
+filters keep incomplete entries available for inspection. Table and day-group
+counters name entries so they cannot imply completion. The incomplete-only
+chart state says that no completed dated points are visible, not that no
+backup activity occurred. The consuming Backups tests cover summary, chart,
+volume, date selection and route views together; existing table interaction
+primitives, access boundaries and routes are unchanged.
+
### Backup posture failure and retry stay source-local (24 October 2026)
The Backups posture notice offers a keyboard-operable retry with the existing
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index f66f9c54c3..c188a1a802 100644
--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md
+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md
@@ -21,6 +21,20 @@
## Purpose
+### Completed restore totals exclude incomplete inventory (24 October 2026)
+
+The Backups restore-point total, completed-byte total, PBS-target count and
+per-day count/volume chart all exclude explicitly running or terminally
+incomplete artifacts. The same completion predicate selects the last backup.
+Running and failed entries remain in the dated inventory and row evidence,
+with separate summary counts; inventory and day-group counts name entries,
+not completed backups. Unknown dates and unverified completed points remain
+evidence, not absent or failed points. Completion establishes neither an
+independent backup (guest snapshots remain distinct), tested restore nor guest
+thaw. Registered recovery-model and consuming-table tests cover mixed,
+incomplete-only, unknown-date and completion-transition controls without any
+new backup execution, QGA requests, schema or persisted state.
+
### Failed posture refreshes withdraw retained assessments (24 October 2026)
Protection posture remains visible while a refresh is pending, but a settled
diff --git a/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx
index 8a96a8247f..2c8081f04f 100644
--- a/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx
+++ b/frontend-modern/src/features/proxmox/ProxmoxBackupsTable.tsx
@@ -43,6 +43,7 @@ import {
import {
buildProxmoxBackupRecoveryModel,
coverageRowMatchesSearch,
+ isCompletedRecoveryArtifact,
selectWorkloadRecoveryArtifacts,
recoverableArtifactMatchesSearch,
type RecoverableArtifact,
@@ -502,11 +503,13 @@ export const ProxmoxBackupsTable: Component<{
recoveryModel().recoverableArtifacts,
(artifact) => artifact.createdMs,
(artifact) =>
- artifact.sourceKind === 'pbs'
- ? 'pbs'
- : artifact.sourceKind === 'archive'
- ? 'archive'
- : 'snapshot',
+ !isCompletedRecoveryArtifact(artifact)
+ ? null
+ : artifact.sourceKind === 'pbs'
+ ? 'pbs'
+ : artifact.sourceKind === 'archive'
+ ? 'archive'
+ : 'snapshot',
{
now: new Date(nowMs()),
getValue:
@@ -753,8 +756,17 @@ export const ProxmoxBackupsTable: Component<{
tail={
<span>
{liveTotalCount()} targets ·{' '}
- {recoveryModel().coverageSummary.recoverableArtifacts} restore points
+ {recoveryModel().coverageSummary.recoverableArtifacts} completed restore{' '}
+ {recoveryModel().coverageSummary.recoverableArtifacts === 1 ? 'point' : 'points'}
{inventoryIncomplete() ? ' read' : ''}
+ <Show when={recoveryModel().coverageSummary.runningArtifacts > 0}>
+ {' · '}
+ {recoveryModel().coverageSummary.runningArtifacts} running
+ </Show>
+ <Show when={recoveryModel().coverageSummary.failedArtifacts > 0}>
+ {' · '}
+ {recoveryModel().coverageSummary.failedArtifacts} failed
+ </Show>
<Show when={recoveryModel().coverageSummary.withPBS > 0}>
{' · '}
{recoveryModel().coverageSummary.withPBS} with{' '}
@@ -830,7 +842,10 @@ export const ProxmoxBackupsTable: Component<{
when={hasRecoverableActivityInRange()}
fallback={
<div class="flex flex-col gap-2 rounded-md border border-border-subtle px-3 py-3 text-xs text-muted sm:flex-row sm:items-center sm:justify-between">
- <span>No dated backup activity in the selected {chartRange()}-day window.</span>
+ <span>
+ No completed restore points with known dates in the selected {chartRange()}
+ -day window.
+ </span>
<div class="flex items-center gap-2">
<button
type="button"
@@ -854,10 +869,10 @@ export const ProxmoxBackupsTable: Component<{
<BackupActivityChart
title={
recoverableMetricMode() === 'volume'
- ? 'Backup volume per day'
- : 'Backups per day'
+ ? 'Completed restore volume per day'
+ : 'Completed restore points per day'
}
- noun="backup"
+ noun="restore point"
segmentKinds={RECOVERABLE_SEGMENT_KINDS}
range={chartRange}
onRangeChange={setChartRange}
@@ -906,8 +921,8 @@ export const ProxmoxBackupsTable: Component<{
rowNoun={
view() === 'date'
? inventoryIncomplete()
- ? 'backups read'
- : 'backups'
+ ? 'backup entries read'
+ : 'backup entries'
: 'targets'
}
/>
diff --git a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
index 7c80891ddf..92567f1a51 100644
--- a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
+++ b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
@@ -475,7 +475,7 @@ export function ProxmoxRecoverableTable(props: {
{item.kind === 'day' ? item.label : ''}{' '}
<span class="ml-2 normal-case tracking-normal text-muted">
{item.kind === 'day' ? item.count : 0}{' '}
- {item.kind === 'day' && item.count === 1 ? 'backup' : 'backups'}
+ {item.kind === 'day' && item.count === 1 ? 'entry' : 'entries'}
</span>
</TableCell>
</TableRow>
diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
index 5e7b37af71..d1415530bc 100644
--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
@@ -438,7 +438,7 @@ describe('ProxmoxBackupsTable', () => {
expect(screen.getByText('main / minipc')).toBeInTheDocument();
expect(
screen.getByRole('cell', {
- name: `${getRecoveryFullDateLabel('2026-05-25')} 3 backups`,
+ name: `${getRecoveryFullDateLabel('2026-05-25')} 3 entries`,
}),
).toBeInTheDocument();
const tables = screen.getAllByRole('table');
@@ -994,7 +994,7 @@ describe('independent Proxmox backup inventory reads', () => {
mountBackupReadState();
await screen.findByText(/PVE backup inventory is loading/);
await waitFor(() => expect(recoverableRows()).toHaveLength(1));
- expect(screen.getByText(/1 restore points read/)).toBeInTheDocument();
+ expect(screen.getByText(/1 completed restore point read/)).toBeInTheDocument();
pending.resolve(jsonResponse(readPvePayload));
await waitFor(() => expect(recoverableRows()).toHaveLength(2));
expect(screen.queryByText(/inventory is loading/)).not.toBeInTheDocument();
@@ -1303,7 +1303,7 @@ describe('backup-date-evidence connected inventory', () => {
);
expect(warning).toHaveAttribute('role', 'status');
expect(warning).toHaveTextContent('excluded from the activity chart and day filters');
- expect(screen.getByText(/No dated backup activity/)).toBeInTheDocument();
+ expect(screen.getByText(/No completed restore points with known dates/)).toBeInTheDocument();
const future = [...document.querySelectorAll('[data-proxmox-backup-row="recoverable"]')].find(
(row) => row.textContent?.includes('PBS'),
)! as HTMLElement;
@@ -1609,3 +1609,91 @@ describe('Coverage withdraws failed protection assessments', () => {
}
});
});
+
+describe('completed restore-point summary and activity', () => {
+ afterEach(() => vi.restoreAllMocks());
+
+ const mountInventory = (incompleteOnly = false) => {
+ vi.spyOn(Date, 'now').mockReturnValue(BACKUP_IDENTITY_NOW);
+ const completedPBS = identityPBS({ id: 'complete', size: 2048 });
+ const runningPBS = identityPBS({ id: 'running', inProgress: true, size: 1024 * 1024 });
+ const failedPBS = identityPBS({
+ id: 'failed',
+ inProgress: true,
+ writeActivityObserved: true,
+ writeActive: false,
+ size: 2 * 1024 * 1024,
+ });
+ apiFetchMock.mockImplementation((url: string) =>
+ Promise.resolve(
+ jsonResponse({
+ data: url.endsWith('/pbs')
+ ? { backups: [...(incompleteOnly ? [] : [completedPBS]), runningPBS, failedPBS] }
+ : {
+ storageBackups: incompleteOnly ? [] : [identityArchive({ size: 1024 })],
+ guestSnapshots: incompleteOnly ? [] : [identitySnapshot()],
+ backupTasks: [],
+ },
+ }),
+ ),
+ );
+ apiFetchJSONMock.mockResolvedValue({ data: [], policy: {} });
+ window.history.replaceState({}, '', '/proxmox/backups/date');
+ return renderInRouter(() => (
+ <ProxmoxBackupsTable
+ emptyIcon={<span />}
+ workloads={[identityGuest('east-100', 'east', 'pve-1')]}
+ />
+ ));
+ };
+
+ it('counts completed points and volume separately while retaining running and failed rows for inspection', async () => {
+ const { container } = mountInventory();
+ await screen.findByText(/3 completed restore points · 1 running · 1 failed/);
+ expect(container.querySelectorAll('[data-proxmox-backup-row="recoverable"]')).toHaveLength(5);
+ expect(
+ screen.getByRole('cell', { name: `${getRecoveryFullDateLabel('2026-10-04')} 5 entries` }),
+ ).toBeInTheDocument();
+ const day = screen.getByRole('button', { name: /: 3 restore points$/ });
+ expect(day).toBeInTheDocument();
+ expect(screen.queryByRole('button', { name: /: 5 restore points$/ })).not.toBeInTheDocument();
+ expect(screen.getByText('Completed restore points per day')).toBeInTheDocument();
+ await fireEvent.click(screen.getByRole('button', { name: 'Volume', exact: true }));
+ expect(screen.getByText('Completed restore volume per day')).toBeInTheDocument();
+ expect(screen.getByRole('button', { name: /: 3.00 KB$/ })).toBeInTheDocument();
+ expect(screen.getAllByText('Running').length).toBeGreaterThan(0);
+ expect(screen.getAllByText('Failed').length).toBeGreaterThan(0);
+ });
+
+ it('does not draw completed activity or claim PBS restore coverage for an incomplete-only inventory', async () => {
+ const { container } = mountInventory(true);
+ const summary = await screen.findByText(/0 completed restore points · 1 running · 1 failed/);
+ expect(summary).not.toHaveTextContent('with PBS snapshots');
+ expect(screen.getByText(/No completed restore points with known dates/)).toBeInTheDocument();
+ expect(screen.queryByRole('group', { name: 'Activity metric' })).not.toBeInTheDocument();
+ expect(container.querySelectorAll('[data-proxmox-backup-row="recoverable"]')).toHaveLength(2);
+ expect(
+ screen.getByRole('cell', { name: `${getRecoveryFullDateLabel('2026-10-04')} 2 entries` }),
+ ).toBeInTheDocument();
+ await fireEvent.click(screen.getByRole('link', { name: 'Coverage', exact: true }));
+ expect(screen.queryByText(/completed restore points with known dates/)).not.toBeInTheDocument();
+ expect(
+ screen.getByText(/0 completed restore points · 1 running · 1 failed/),
+ ).toBeInTheDocument();
+ });
+
+ it('keeps incomplete entries available under a completed day filter and when it is cleared', async () => {
+ const { container } = mountInventory();
+ await screen.findByText(/3 completed restore points/);
+ await fireEvent.click(screen.getByRole('button', { name: /: 3 restore points$/ }));
+ await waitFor(() => expect(window.location.search).toContain('day=2026-10-04'));
+ expect(container.querySelectorAll('[data-proxmox-backup-row="recoverable"]')).toHaveLength(5);
+ await fireEvent.click(screen.getByRole('button', { name: 'Clear date filter' }));
+ await waitFor(() => expect(window.location.search).not.toContain('day='));
+ expect(screen.getByRole('button', { name: /: 3 restore points$/ })).toHaveAttribute(
+ 'aria-pressed',
+ 'false',
+ );
+ expect(container.querySelectorAll('[data-proxmox-backup-row="recoverable"]')).toHaveLength(5);
+ });
+});
diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupActivityPresentation.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupActivityPresentation.test.ts
index 20d94dee63..ed9f5d3204 100644
--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupActivityPresentation.test.ts
+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupActivityPresentation.test.ts
@@ -425,6 +425,8 @@ describe('proxmoxBackupActivityPresentation', () => {
[0, 'backup', '0 backups'],
[1, 'backup', '1 backup'],
[2, 'backup', '2 backups'],
+ [1, 'restore point', '1 restore point'],
+ [3, 'restore point', '3 restore points'],
[1, 'snapshot', '1 snapshot'],
[5, 'task', '5 tasks'],
[2, 'archive', '2 archives'],
diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.branchcov.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.branchcov.test.ts
index 9ec3528ff7..51289afdb3 100644
--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.branchcov.test.ts
+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.branchcov.test.ts
@@ -500,6 +500,8 @@ describe('buildProxmoxBackupRecoveryModel summary, sort, and empty edges', () =>
unknown: 0,
withPBS: 0,
recoverableArtifacts: 0,
+ runningArtifacts: 0,
+ failedArtifacts: 0,
totalBytes: 0,
});
});
diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts
index 25a1cb00ac..2288ac8bcb 100644
--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts
+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupRecoveryModel.test.ts
@@ -598,3 +598,104 @@ describe('backup-date-evidence model', () => {
expect(getRecoveryAgeBand(nowMs - 30 * 86400000 - 1, nowMs)).toBe('stale');
});
});
+
+describe('completed restore-point totals', () => {
+ const nowMs = Date.parse('2026-05-26T08:00:00Z');
+ const build = (
+ pbsBackups: PBSBackup[],
+ archives: StorageBackup[] = [],
+ snapshots: GuestSnapshot[] = [],
+ ) =>
+ buildProxmoxBackupRecoveryModel({
+ workloads: [workload({})],
+ pbsBackups,
+ archives,
+ snapshots,
+ tasks: [],
+ nowMs,
+ });
+
+ it('keeps incomplete PBS and PVE entries visible without inflating completed counts or bytes', () => {
+ const model = build(
+ [
+ pbsBackup({ id: 'complete', size: 100 }),
+ pbsBackup({ id: 'running', size: 10_000, inProgress: true }),
+ pbsBackup({
+ id: 'failed',
+ size: 20_000,
+ inProgress: true,
+ writeActivityObserved: true,
+ writeActive: false,
+ }),
+ ],
+ [
+ archive({ id: 'complete-file', size: 200 }),
+ archive({ id: 'writing-file', size: 40_000, inProgress: true }),
+ ],
+ [snapshot({ sizeBytes: 300 })],
+ );
+ expect(model.recoverableArtifacts).toHaveLength(6);
+ expect(model.coverageRows[0].artifacts).toHaveLength(6);
+ expect(model.coverageSummary).toMatchObject({
+ recoverableArtifacts: 3,
+ runningArtifacts: 2,
+ failedArtifacts: 1,
+ totalBytes: 600,
+ withPBS: 1,
+ });
+ expect(model.coverageRows[0].latestBackup?.nativeId).toBe('complete');
+ });
+
+ it.each([false, true])(
+ 'does not count an incomplete-only PBS target when write activity is %s',
+ (writeActive) => {
+ const model = build([
+ pbsBackup({
+ inProgress: true,
+ writeActivityObserved: true,
+ writeActive,
+ protected: true,
+ verified: true,
+ }),
+ ]);
+ expect(model.coverageSummary).toMatchObject({
+ recoverableArtifacts: 0,
+ withPBS: 0,
+ totalBytes: 0,
+ runningArtifacts: writeActive ? 1 : 0,
+ failedArtifacts: writeActive ? 0 : 1,
+ });
+ expect(model.recoverableArtifacts).toHaveLength(1);
+ expect(model.recoverableArtifacts[0].verified).toBeUndefined();
+ expect(model.coverageRows[0].latestBackup).toBeUndefined();
+ },
+ );
+
+ it('keeps unknown chronology and missing verification separate from completion', () => {
+ const model = build([pbsBackup({ backupTime: 'not-a-date', verified: false, size: 123 })]);
+ expect(model.coverageSummary).toMatchObject({
+ recoverableArtifacts: 1,
+ totalBytes: 123,
+ withPBS: 1,
+ });
+ expect(model.coverageRows[0].latestBackup).toBeUndefined();
+ expect(model.coverageRows[0].ageUnknown?.backup).toBe(true);
+ expect(model.recoverableArtifacts[0].verified).toBe(false);
+ });
+
+ it('moves the same observed entry into completed totals only when its producer reports completion', () => {
+ const pending = build([pbsBackup({ inProgress: true, size: 100 })]);
+ const complete = build([pbsBackup({ inProgress: false, size: 200 })]);
+ expect(pending.coverageSummary).toMatchObject({
+ recoverableArtifacts: 0,
+ runningArtifacts: 1,
+ totalBytes: 0,
+ });
+ expect(complete.coverageSummary).toMatchObject({
+ recoverableArtifacts: 1,
+ runningArtifacts: 0,
+ totalBytes: 200,
+ });
+ expect(complete.recoverableArtifacts[0].id).toBe(pending.recoverableArtifacts[0].id);
+ });
+});
diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupActivityPresentation.ts b/frontend-modern/src/features/proxmox/proxmoxBackupActivityPresentation.ts
index f11ab09f2a..9a98ba8ed7 100644
--- a/frontend-modern/src/features/proxmox/proxmoxBackupActivityPresentation.ts
+++ b/frontend-modern/src/features/proxmox/proxmoxBackupActivityPresentation.ts
@@ -148,7 +148,8 @@ export interface BackupActivityTooltipRow {
muted: boolean;
}
-export type BackupActivityNoun = 'archive' | 'artifact' | 'backup' | 'task' | 'snapshot';
+export type BackupActivityNoun =
+ 'archive' | 'artifact' | 'backup' | 'task' | 'snapshot' | 'restore point';
function formatActivityValue(value: number, mode: BackupActivityMetricMode): string {
if (mode === 'volume') return formatBytes(Math.max(0, value));
diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts b/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts
index 7c52f4d144..43091538ac 100644
--- a/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts
+++ b/frontend-modern/src/features/proxmox/proxmoxBackupRecoveryModel.ts
@@ -100,6 +100,7 @@ export interface WorkloadCoverageRow {
export interface ProxmoxBackupRecoveryModel {
coverageRows: WorkloadCoverageRow[];
+ /** All observed entries, including incomplete artifacts retained for inspection. */
recoverableArtifacts: RecoverableArtifact[];
coverageSummary: {
totalWorkloads: number;
@@ -108,7 +109,10 @@ export interface ProxmoxBackupRecoveryModel {
unprotected: number;
unknown: number;
withPBS: number;
+ /** Completed restore points only; completion is not a successful restore or thaw. */
recoverableArtifacts: number;
+ runningArtifacts: number;
+ failedArtifacts: number;
totalBytes: number;
};
}
@@ -154,6 +158,11 @@ export function isBackupArtifact(artifact: RecoverableArtifact): boolean {
return artifact.sourceKind !== 'snapshot';
}
+/** Incomplete artifacts remain evidence, but are not completed restore points. */
+export function isCompletedRecoveryArtifact(artifact: RecoverableArtifact): boolean {
+ return !artifact.running && !artifact.failed;
+}
+
function parseTimestampMs(value: string | undefined): number | undefined {
if (!value) return undefined;
const ms = Date.parse(value);
@@ -511,7 +520,7 @@ export function selectWorkloadRecoveryArtifacts(
> {
// Completion remains independent of age. Keep every artifact listed, but
// don't guess the latest when even one completed date cannot be ordered.
- const completed = artifacts.filter((artifact) => !artifact.running && !artifact.failed);
+ const completed = artifacts.filter(isCompletedRecoveryArtifact);
const select = (items: RecoverableArtifact[]) => {
const unknown = items.some(
(artifact) => getRecoveryAgeBand(artifact.createdMs, nowMs) === 'unknown',
@@ -782,7 +791,8 @@ export function buildProxmoxBackupRecoveryModel(
});
artifacts.sort((left, right) => (right.createdMs ?? 0) - (left.createdMs ?? 0));
- const totalBytes = artifacts.reduce((sum, artifact) => sum + (artifact.size ?? 0), 0);
+ const completedArtifacts = artifacts.filter(isCompletedRecoveryArtifact);
+ const totalBytes = completedArtifacts.reduce((sum, artifact) => sum + (artifact.size ?? 0), 0);
return {
coverageRows,
recoverableArtifacts: artifacts,
@@ -792,8 +802,14 @@ export function buildProxmoxBackupRecoveryModel(
attention: coverageRows.filter((row) => isCoverageAttention(row.posture)).length,
unprotected: coverageRows.filter((row) => row.posture === 'unprotected').length,
unknown: coverageRows.filter((row) => row.posture === 'unknown').length,
- withPBS: coverageRows.filter((row) => row.pbsCount > 0).length,
- recoverableArtifacts: artifacts.length,
+ withPBS: coverageRows.filter((row) =>
+ row.artifacts.some(
+ (artifact) => artifact.sourceKind === 'pbs' && isCompletedRecoveryArtifact(artifact),
+ ),
+ ).length,
+ recoverableArtifacts: completedArtifacts.length,
+ runningArtifacts: artifacts.filter((artifact) => artifact.running).length,
+ failedArtifacts: artifacts.filter((artifact) => artifact.failed).length,
totalBytes,
},
};