feat(downloads): add live limits clipboard capture and byte progress

src/utils/downloadProgress.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { formatDownloadBytes, resolveDownloadSizeDisplay } from './downloadProgress';
+
+describe('download progress size display', () => {
+  it('formats byte counts using the binary units used by the download engines', () => {
+    expect(formatDownloadBytes(0)).toBe('0 B');
+    expect(formatDownloadBytes(1.2 * 1024 ** 3)).toBe('1.20 GB');
+  });
+
+  it('keeps estimated totals distinguishable from exact totals', () => {
+    expect(resolveDownloadSizeDisplay({
+      downloadedBytes: 1.2 * 1024 ** 3,
+      totalBytes: 2.4 * 1024 ** 3,
+      totalIsEstimate: true,
+      fallbackSize: 'Unknown'
+    })).toEqual({
+      downloaded: '1.20 GB',
+      total: '2.40 GB',
+      totalIsEstimate: true,
+      fallback: 'Unknown'
+    });
+  });
+});

src/utils/downloadProgress.ts

@@ -0,0 +1,61 @@
+export interface DownloadSizeDisplay {
+  downloaded: string | null;
+  total: string | null;
+  totalIsEstimate: boolean;
+  fallback: string;
+}
+
+const isUsableByteCount = (value: number | null | undefined): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value >= 0;
+
+export const formatDownloadBytes = (bytes: number): string => {
+  if (bytes < 1024) return `${Math.round(bytes)} B`;
+
+  const units = ['KB', 'MB', 'GB', 'TB'];
+  let value = bytes;
+  let unitIndex = -1;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+
+  const precision = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+  return `${value.toFixed(precision)} ${units[unitIndex]}`;
+};
+
+export const resolveDownloadSizeDisplay = ({
+  downloadedBytes,
+  totalBytes,
+  totalIsEstimate = false,
+  fallbackSize
+}: {
+  downloadedBytes?: number | null;
+  totalBytes?: number | null;
+  totalIsEstimate?: boolean;
+  fallbackSize?: string | null;
+}): DownloadSizeDisplay => ({
+  downloaded: isUsableByteCount(downloadedBytes) ? formatDownloadBytes(downloadedBytes) : null,
+  total: isUsableByteCount(totalBytes) && totalBytes > 0 ? formatDownloadBytes(totalBytes) : null,
+  totalIsEstimate: Boolean(totalIsEstimate && isUsableByteCount(totalBytes) && totalBytes > 0),
+  fallback: fallbackSize && fallbackSize !== '-' ? fallbackSize : 'Unknown'
+});
+
+export const downloadProgressColorClass = (status: string): string => {
+  switch (status) {
+    case 'completed':
+      return 'download-status-completed';
+    case 'paused':
+      return 'download-status-paused';
+    case 'failed':
+      return 'download-status-failed';
+    case 'processing':
+      return 'download-status-processing';
+    case 'queued':
+    case 'staged':
+      return 'download-status-queued';
+    case 'retrying':
+      return 'download-status-retrying';
+    default:
+      return 'download-status-downloading';
+  }
+};

src/utils/downloads.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import type { DownloadItem } from '../bindings/DownloadItem';
+import { redactDownloadForPersistence } from './downloads';
+
+const item = (status: DownloadItem['status']): DownloadItem => ({
+  id: 'download-1',
+  url: 'https://example.com/file.bin',
+  fileName: 'file.bin',
+  status,
+  category: 'Other',
+  dateAdded: '2026-07-15T00:00:00.000Z',
+  downloadedBytes: 1024,
+  totalBytes: 4096,
+  totalIsEstimate: false
+});
+
+describe('download persistence progress snapshots', () => {
+  it('does not write active byte counters on every progress event', () => {
+    const persisted = redactDownloadForPersistence(item('downloading'));
+
+    expect(persisted.downloadedBytes).toBeUndefined();
+    expect(persisted.totalBytes).toBeUndefined();
+    expect(persisted.totalIsEstimate).toBeUndefined();
+  });
+
+  it('keeps byte counters for paused snapshots', () => {
+    const persisted = redactDownloadForPersistence(item('paused'));
+
+    expect(persisted.downloadedBytes).toBe(1024);
+    expect(persisted.totalBytes).toBe(4096);
+    expect(persisted.totalIsEstimate).toBe(false);
+  });
+});

src/utils/downloads.ts

@@ -119,11 +119,22 @@ export const isMediaUrl = (rawUrl: string): boolean => {
  * persistence boundary so the user-data database contains no plaintext credentials.
  */
 const DOWNLOAD_SECRET_FIELDS = ['password', 'cookies', 'headers'] as const;
+const VOLATILE_PROGRESS_STATUSES = new Set([
+  'ready',
+  'staged',
+  'queued',
+  'downloading',
+  'processing',
+  'retrying'
+]);
 
 /**
  * Returns a shallow copy of `item` with secret fields removed. Volatile
  * progress fields (`fraction`, `speed`, `eta`) are also dropped as in the
- * existing persistence path.
+ * existing persistence path. Numeric byte totals remain for paused, failed,
+ * and completed rows so those snapshots keep their accurate Size-column
+ * display after restart; active-transfer counters stay in memory to avoid a
+ * database write for every progress tick.
  *
  * Note: standard persistence intentionally retains `url` because it is the
  * download source. The backend applies a stricter portable-mode policy: URL
@@ -135,6 +146,11 @@ export const redactDownloadForPersistence = (item: DownloadItem): DownloadItem =
   delete copy.fraction;
   delete copy.speed;
   delete copy.eta;
+  if (VOLATILE_PROGRESS_STATUSES.has(item.status)) {
+    delete copy.downloadedBytes;
+    delete copy.totalBytes;
+    delete copy.totalIsEstimate;
+  }
   for (const field of DOWNLOAD_SECRET_FIELDS) {
     delete copy[field];
   }