fix(downloads): preserve live progress across lifecycle edges

src/store/downloadStore.test.ts

@@ -11,6 +11,7 @@ vi.mock('../ipc', () => ({
 describe('useDownloadProgressStore', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    vi.mocked(ipc.invokeCommand).mockResolvedValue(undefined);
     useDownloadProgressStore.setState({ progressMap: {} });
   });
 
@@ -156,4 +157,48 @@ describe('useDownloadProgressStore', () => {
     expect(useDownloadProgressStore.getState().progressMap).toEqual({});
     release();
   });
+
+  it('snapshots live progress before clearing it on a terminal transition', async () => {
+    const handlers: Record<string, (event: any) => void> = {};
+    vi.mocked(ipc.listenEvent).mockImplementation((event, handler) => {
+      handlers[event] = handler as (event: any) => void;
+      return Promise.resolve(vi.fn());
+    });
+    useDownloadStore.setState({
+      downloads: [{
+        id: 'snapshot',
+        url: 'https://example.com/file',
+        fileName: 'file.bin',
+        status: 'downloading',
+        category: 'Other',
+        dateAdded: ''
+      }]
+    });
+
+    const release = await initDownloadListener();
+    handlers['download-progress']({ payload: {
+      id: 'snapshot',
+      fraction: 0.8,
+      speed: '1 MB/s',
+      eta: '2s',
+      size: '8 MB',
+      size_is_final: false,
+      downloaded_bytes: 8192,
+      total_bytes: 10240,
+      total_is_estimate: true
+    } });
+    handlers['download-state']({ payload: {
+      id: 'snapshot',
+      status: 'paused'
+    } });
+
+    const row = useDownloadStore.getState().downloads[0];
+    expect(row.status).toBe('paused');
+    expect(row.fraction).toBe(0.8);
+    expect(row.downloadedBytes).toBe(8192);
+    expect(row.totalBytes).toBe(10240);
+    expect(row.totalIsEstimate).toBe(true);
+    expect(useDownloadProgressStore.getState().progressMap).toEqual({});
+    release();
+  });
 });

src/store/downloadStore.ts

@@ -61,7 +61,7 @@ const startDownloadListeners = async () => {
       if (payload.total_bytes !== null && payload.total_bytes !== undefined) {
         updates.totalBytes = payload.total_bytes;
       }
-      if (payload.downloaded_bytes !== null && payload.downloaded_bytes !== undefined) {
+      if (payload.total_is_estimate !== null && payload.total_is_estimate !== undefined) {
         updates.totalIsEstimate = payload.total_is_estimate;
       }
       if (Object.keys(updates).length > 0) {
@@ -84,13 +84,24 @@ const startDownloadListeners = async () => {
         return;
       }
 
+      const progress = useDownloadProgressStore.getState().progressMap[payload.id];
       if (['queued', 'retrying', 'completed', 'failed', 'paused'].includes(status)) {
         useDownloadProgressStore.getState().clearDownloadProgress(payload.id);
       }
-      const progress = useDownloadProgressStore.getState().progressMap[payload.id];
       const updates: Partial<DownloadItem> = {
         status,
-        ...(progress ? { fraction: progress.fraction } : {}),
+        ...(progress ? {
+          fraction: progress.fraction,
+          ...(progress.downloaded_bytes != null
+            ? { downloadedBytes: progress.downloaded_bytes }
+            : {}),
+          ...(progress.total_bytes != null
+            ? { totalBytes: progress.total_bytes }
+            : {}),
+          ...(progress.total_is_estimate != null
+            ? { totalIsEstimate: progress.total_is_estimate }
+            : {})
+        } : {}),
         ...(payload.error ? { lastError: payload.error } : {}),
         ...((status === 'downloading' || status === 'retrying')
           ? { lastTry: new Date().toISOString() }
@@ -122,9 +133,6 @@ const startDownloadListeners = async () => {
       } else if (status === 'completed' || status === 'failed') {
         mainStore.unregisterBackendIds([payload.id]);
       }
-      if (['queued', 'retrying', 'completed', 'failed', 'paused'].includes(status)) {
-        useDownloadProgressStore.getState().clearDownloadProgress(payload.id);
-      }
     }),
     listen('tray-action', (event) => {
       const mainStore = useDownloadStore.getState();

src/store/useDownloadStore.test.ts

@@ -571,6 +571,38 @@ describe('useDownloadStore', () => {
     );
   });
 
+  it('treats the legacy media zero sentinel as inheriting the global limit', async () => {
+    const defaultSettings = useSettingsStore.getState();
+    vi.mocked(useSettingsStore.getState).mockReturnValue({
+      ...defaultSettings,
+      globalSpeedLimit: '2M'
+    });
+    vi.mocked(ipc.invokeCommand).mockImplementation(async (cmd: string) => {
+      if (cmd === 'get_pending_order') return ['legacy-media-limit'];
+      return undefined;
+    });
+
+    await useDownloadStore.getState().addDownload({
+      id: 'legacy-media-limit',
+      url: 'https://www.youtube.com/watch?v=legacy',
+      fileName: 'media.mp4',
+      category: 'Movies',
+      dateAdded: '',
+      isMedia: true,
+      speedLimit: '0'
+    }, { type: 'start-now' });
+
+    expect(ipc.invokeCommand).toHaveBeenCalledWith(
+      'enqueue_download',
+      expect.objectContaining({
+        item: expect.objectContaining({
+          id: 'legacy-media-limit',
+          speed_limit: '2M'
+        })
+      })
+    );
+  });
+
   it('reports a rejected immediate start instead of claiming success', async () => {
     vi.mocked(ipc.invokeCommand).mockImplementation(async (command: string) => {
       if (command === 'enqueue_download') {

src/store/useDownloadStore.ts

@@ -147,6 +147,12 @@ const speedLimitForDispatch = (
   globalSpeedLimit: string,
   isMedia: boolean | undefined
 ): string | null => {
+  // Older Add-window rows used "0" as the no-override sentinel. Media
+  // downloads do not have aria2's daemon-wide cap, so preserve the intended
+  // inherit-global behavior when dispatching those persisted rows.
+  if (isMedia && itemSpeedLimit?.trim() === '0') {
+    return normalizeSpeedLimitForBackend(globalSpeedLimit);
+  }
   const explicitLimit = explicitSpeedLimitForDispatch(itemSpeedLimit);
   if (explicitLimit !== null || !isMedia) return explicitLimit;
   return normalizeSpeedLimitForBackend(globalSpeedLimit);