From 7d1971d58b71896ef9ea0d29712772eb5b768efd Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:22 +0000
Subject: [PATCH 01/16] fix(application/electron): wait for completed torrent
 files before setup

---
 .../src/electron/handlers/handler.torrent.ts  |  3 +-
 application/src/electron/lib/torrent-files.ts | 53 +++++++++++++++++++
 .../electron/manager/manager.webtorrent.ts    | 18 +++++++
 application/tests/torrent-files.test.ts       | 30 +++++++++++
 4 files changed, 103 insertions(+), 1 deletion(-)
 create mode 100644 application/src/electron/lib/torrent-files.ts
 create mode 100644 application/tests/torrent-files.test.ts

diff --git a/application/src/electron/handlers/handler.torrent.ts b/application/src/electron/handlers/handler.torrent.ts
index 1c198fa1..d9b75697 100644
--- a/application/src/electron/handlers/handler.torrent.ts
+++ b/application/src/electron/handlers/handler.torrent.ts
@@ -88,6 +88,7 @@ interface WebTorrentControls {
   pause: () => void;
   resume: () => void;
   destroy: () => void;
+  waitUntilFilesReady: () => Effect.Effect<void, TorrentError>;
 }
 
 const downloads = new Map<string, TorrentDownload>();
@@ -306,7 +307,7 @@ class TorrentDownload {
           );
 
           yield* Deferred.await(completed);
-          yield* Effect.sleep('1 second');
+          yield* this.wtBlock.waitUntilFilesReady();
 
           if (this.status === 'cancelled' || this.status === 'failed') {
             return false;
diff --git a/application/src/electron/lib/torrent-files.ts b/application/src/electron/lib/torrent-files.ts
new file mode 100644
index 00000000..4759848e
--- /dev/null
+++ b/application/src/electron/lib/torrent-files.ts
@@ -0,0 +1,53 @@
+import { open, stat } from 'node:fs/promises';
+
+export interface TorrentFileExpectation {
+  path: string;
+  length: number;
+}
+
+interface TorrentFileReadinessOptions {
+  timeoutMs?: number;
+  intervalMs?: number;
+  probe?: (file: TorrentFileExpectation) => Promise<void>;
+}
+
+async function probeTorrentFile(file: TorrentFileExpectation): Promise<void> {
+  const fileStat = await stat(file.path);
+  if (fileStat.size !== file.length) {
+    throw new Error(
+      `Torrent file has size ${fileStat.size}, expected ${file.length}: ${file.path}`
+    );
+  }
+
+  const handle = await open(file.path, 'r');
+  await handle.close();
+}
+
+/** Wait until WebTorrent's completed files can be safely reopened by setup/seeding. */
+export async function waitForTorrentFiles(
+  files: readonly TorrentFileExpectation[],
+  options: TorrentFileReadinessOptions = {}
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 10_000;
+  const intervalMs = options.intervalMs ?? 100;
+  const probe = options.probe ?? probeTorrentFile;
+  const deadline = Date.now() + timeoutMs;
+  let lastError: unknown;
+
+  do {
+    try {
+      await Promise.all(files.map(probe));
+      return;
+    } catch (error) {
+      lastError = error;
+      if (Date.now() >= deadline) break;
+      await new Promise<void>((resolveDelay) =>
+        setTimeout(resolveDelay, intervalMs)
+      );
+    }
+  } while (Date.now() <= deadline);
+
+  throw lastError instanceof Error
+    ? lastError
+    : new Error('Torrent files did not become ready');
+}
diff --git a/application/src/electron/manager/manager.webtorrent.ts b/application/src/electron/manager/manager.webtorrent.ts
index d606e77e..10882216 100644
--- a/application/src/electron/manager/manager.webtorrent.ts
+++ b/application/src/electron/manager/manager.webtorrent.ts
@@ -1,7 +1,9 @@
+import { resolve as resolvePath } from 'node:path';
 import { TorrentError } from '@ogi-sdk/errors';
 import { createLogger, LOGGER_PREFIXES } from '@ogi-sdk/logger';
 import { Effect } from 'effect';
 import webtorrent from 'webtorrent';
+import { waitForTorrentFiles } from '@/electron/lib/torrent-files.js';
 
 const logger = createLogger(LOGGER_PREFIXES.electron);
 
@@ -12,6 +14,7 @@ type TorrentControls = {
   pause: () => void;
   resume: () => void;
   destroy: () => void;
+  waitUntilFilesReady: () => Effect.Effect<void, TorrentError>;
 };
 
 export function torrent(torrentId: string | Buffer, path: string) {
@@ -82,6 +85,21 @@ export function torrent(torrentId: string | Buffer, path: string) {
                   stopProgressReporting();
                   activeTorrent.destroy();
                 },
+                waitUntilFilesReady: () =>
+                  Effect.tryPromise({
+                    try: () =>
+                      waitForTorrentFiles(
+                        activeTorrent.files.map((file) => ({
+                          path: resolvePath(path, file.path),
+                          length: file.length,
+                        }))
+                      ),
+                    catch: (cause) =>
+                      new TorrentError({
+                        message: `Torrent files did not become ready: ${String(cause)}`,
+                        cause,
+                      }),
+                  }),
               })
             );
           });
diff --git a/application/tests/torrent-files.test.ts b/application/tests/torrent-files.test.ts
new file mode 100644
index 00000000..d851b2d8
--- /dev/null
+++ b/application/tests/torrent-files.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  type TorrentFileExpectation,
+  waitForTorrentFiles,
+} from '../src/electron/lib/torrent-files.js';
+
+describe('torrent file readiness', () => {
+  test('retries until every completed torrent file can be reopened', async () => {
+    const files: TorrentFileExpectation[] = [
+      { path: '/download/setup.exe', length: 10 },
+      { path: '/download/MD5/QuickSFV.ini', length: 20 },
+    ];
+    const attempts = new Map<string, number>();
+
+    await waitForTorrentFiles(files, {
+      timeoutMs: 100,
+      intervalMs: 0,
+      probe: async (file: TorrentFileExpectation): Promise<void> => {
+        const attempt = (attempts.get(file.path) ?? 0) + 1;
+        attempts.set(file.path, attempt);
+        if (file.path.endsWith('QuickSFV.ini') && attempt === 1) {
+          throw new Error('ENOENT');
+        }
+      },
+    });
+
+    expect(attempts.get('/download/setup.exe')).toBe(2);
+    expect(attempts.get('/download/MD5/QuickSFV.ini')).toBe(2);
+  });
+});

From 6ff9fcbc4cd5fb4f846762e627435fd1a0fc8a16 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:22 +0000
Subject: [PATCH 02/16] feat(application): report moving-files progress during
 extraction

---
 .../src/electron/handlers/handler.fs.ts       | 28 +++++++---
 packages/ogi-addon/src/extraction.ts          | 51 ++++++++++++++++---
 2 files changed, 64 insertions(+), 15 deletions(-)

diff --git a/application/src/electron/handlers/handler.fs.ts b/application/src/electron/handlers/handler.fs.ts
index 6daa4c8a..dff33fcd 100644
--- a/application/src/electron/handlers/handler.fs.ts
+++ b/application/src/electron/handlers/handler.fs.ts
@@ -71,15 +71,27 @@ const extractArchive = (arg: {
         ],
       });
     }
+    // Throttle progress IPC: per-file move callbacks can fire thousands of
+    // times for large games. Always let stage changes and completion through.
+    let lastProgressSent = 0;
+    let lastStage: string | undefined;
     yield* fsTryPromise(arg.outputDir, () =>
-      extraction(archivePath, arg.outputDir, (progress) => {
-        if (arg.downloadId) {
-          sendIPCMessage('processing:progress', {
-            id: arg.downloadId,
-            phase: 'Extracting archive',
-            progress,
-          });
-        }
+      extraction(archivePath, arg.outputDir, (progress, stage) => {
+        if (!arg.downloadId) return;
+        const now = Date.now();
+        if (
+          stage === lastStage &&
+          progress !== 1 &&
+          now - lastProgressSent < 100
+        )
+          return;
+        lastProgressSent = now;
+        lastStage = stage;
+        sendIPCMessage('processing:progress', {
+          id: arg.downloadId,
+          phase: stage === 'moving' ? 'Moving files' : 'Extracting archive',
+          progress,
+        });
       })
     ).pipe(
       Effect.tapError((error) =>
diff --git a/packages/ogi-addon/src/extraction.ts b/packages/ogi-addon/src/extraction.ts
index c7389cab..f052d3e3 100644
--- a/packages/ogi-addon/src/extraction.ts
+++ b/packages/ogi-addon/src/extraction.ts
@@ -23,7 +23,12 @@ const progressPollIntervalMs = 150;
 type ExtractionError = FileSystemError | PlatformError;
 
 export type ExtractionProgress = number | null;
-export type ExtractionProgressCallback = (progress: ExtractionProgress) => void;
+/** 'extracting' while the archive unpacks; 'moving' while staged files move into the output directory. */
+export type ExtractionStage = 'extracting' | 'moving';
+export type ExtractionProgressCallback = (
+  progress: ExtractionProgress,
+  stage: ExtractionStage
+) => void;
 
 const spawnProcess = (
   command: string,
@@ -197,9 +202,23 @@ const getRegularFileBytes = async (directory: string): Promise<number> => {
   return total;
 };
 
+const countRegularFiles = async (directory: string): Promise<number> => {
+  let total = 0;
+  const entries = await fsAsync.readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      total += await countRegularFiles(join(directory, entry.name));
+    } else if (entry.isFile()) {
+      total += 1;
+    }
+  }
+  return total;
+};
+
 const mergeDirectory = async (
   sourceDir: string,
-  destinationDir: string
+  destinationDir: string,
+  onFileMoved?: () => void
 ): Promise<void> => {
   const destinationStat = await fsAsync
     .lstat(destinationDir)
@@ -213,21 +232,23 @@ const mergeDirectory = async (
     const source = join(sourceDir, entry.name);
     const destination = join(destinationDir, entry.name);
     if (entry.isDirectory()) {
-      await mergeDirectory(source, destination);
+      await mergeDirectory(source, destination, onFileMoved);
       await fsAsync.rm(source, { recursive: true, force: true });
       continue;
     }
     await fsAsync.rm(destination, { recursive: true, force: true });
     await fsAsync.rename(source, destination);
+    onFileMoved?.();
   }
 };
 
 const reportProgress = (
   callback: ExtractionProgressCallback | undefined,
-  progress: ExtractionProgress
+  progress: ExtractionProgress,
+  stage: ExtractionStage = 'extracting'
 ): void => {
   try {
-    callback?.(progress);
+    callback?.(progress, stage);
   } catch {
     // Progress observers must not be able to fail extraction.
   }
@@ -386,8 +407,24 @@ const extractArchiveEffect = (
             )
           )
       );
+      // Move staged files into the output directory, reporting per-file
+      // progress so big games don't look stuck after extraction finishes.
       yield* Effect.tryPromise({
-        try: () => mergeDirectory(stagingDir, outputDir),
+        try: async () => {
+          const totalFiles = await countRegularFiles(stagingDir).catch(() => 0);
+          reportProgress(onProgress, totalFiles > 0 ? 0 : null, 'moving');
+          let movedFiles = 0;
+          await mergeDirectory(stagingDir, outputDir, () => {
+            movedFiles++;
+            if (totalFiles > 0) {
+              reportProgress(
+                onProgress,
+                Math.min(movedFiles / totalFiles, 0.99),
+                'moving'
+              );
+            }
+          });
+        },
         catch: (cause) =>
           new FileSystemError({
             message: `Failed to move extracted files: ${String(cause)}`,
@@ -395,7 +432,7 @@ const extractArchiveEffect = (
             cause,
           }),
       });
-      reportProgress(onProgress, 1);
+      reportProgress(onProgress, 1, 'moving');
     }).pipe(
       Effect.ensuring(
         Effect.promise(() =>

From ebc180b83fa57274d1d05efad773eba1d1180721 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:22 +0000
Subject: [PATCH 03/16] feat(application/frontend): recover post-download
 processing after a crash

---
 .../src/frontend/lib/downloads/persistence.ts |  16 +-
 .../src/frontend/lib/recovery/failedSetups.ts |  40 ++++-
 .../frontend/managers/DownloadManager.svelte  | 141 ++++++++++++------
 3 files changed, 147 insertions(+), 50 deletions(-)

diff --git a/application/src/frontend/lib/downloads/persistence.ts b/application/src/frontend/lib/downloads/persistence.ts
index 5da5d4b8..5d1c42d1 100644
--- a/application/src/frontend/lib/downloads/persistence.ts
+++ b/application/src/frontend/lib/downloads/persistence.ts
@@ -15,6 +15,7 @@ const logger = createLogger(LOGGER_PREFIXES.frontend);
 
 type PersistableStatus =
   | 'downloading'
+  | 'merging'
   | 'paused'
   | 'installing-redistributables';
 
@@ -52,11 +53,24 @@ function isPersistableStatus(
 ): status is PersistableStatus {
   return (
     status === 'downloading' ||
+    status === 'merging' ||
     status === 'paused' ||
     status === 'installing-redistributables'
   );
 }
 
+// 'merging' is only persistable while the backend merges chunk files: the
+// chunk files on disk let a restart resume without re-downloading. Post-
+// download processing (moving/extracting) is covered by the failed-setups
+// recovery file instead.
+function isPersistableDownload(download: DownloadStatusAndInfo): boolean {
+  return (
+    isPersistableStatus(download.status) &&
+    (download.status !== 'merging' ||
+      download.processingPhase === 'Merging chunks')
+  );
+}
+
 function recordPath(id: string) {
   return `${PERSIST_DIR}/${id}.json`;
 }
@@ -237,7 +251,7 @@ export function initDownloadPersistence() {
       latestDownloads = downloads;
       const nextSnapshot: Record<string, string> = {};
       for (const download of downloads) {
-        if (!isPersistableStatus(download.status)) continue;
+        if (!isPersistableDownload(download)) continue;
         // Addon-enqueued downloads can't be restored (owning addon session is gone).
         if (download.isAddonDownload) continue;
         const serialized = JSON.stringify(download);
diff --git a/application/src/frontend/lib/recovery/failedSetups.ts b/application/src/frontend/lib/recovery/failedSetups.ts
index 79e8341d..891788c3 100644
--- a/application/src/frontend/lib/recovery/failedSetups.ts
+++ b/application/src/frontend/lib/recovery/failedSetups.ts
@@ -2,6 +2,7 @@ import type { SetupCommandData } from '@ogi-sdk/connect';
 import { FileSystemError, formatError } from '@ogi-sdk/errors';
 import { createLogger, LOGGER_PREFIXES } from '@ogi-sdk/logger';
 import { Effect, Schedule } from 'effect';
+import { get } from 'svelte/store';
 import { electronRpc } from '@/frontend/lib/electron-rpc';
 import {
   unrarAndReturnOutputDir,
@@ -46,6 +47,13 @@ export function loadFailedSetups() {
       )
     ),
     Effect.map((files) => {
+      // Pending recoveries share this directory; hide entries whose download
+      // is still live in this session so they only surface after a crash.
+      const activeDownloadIds = new Set(
+        get(currentDownloads)
+          .filter((download) => download.status !== 'error')
+          .map((download) => download.id)
+      );
       const byDownloadId = new Map<string, FailedSetup>();
       for (const file of files) {
         if (!file.endsWith('.json')) continue;
@@ -54,7 +62,7 @@ export function loadFailedSetups() {
             window.electronAPI.fs.read(`${FAILED_SETUPS_DIR}/${file}`)
           ) as FailedSetup;
           const key = setup.downloadInfo?.id ?? setup.id;
-          if (!key) continue;
+          if (!key || activeDownloadIds.has(key)) continue;
           const existing = byDownloadId.get(key);
           if (!existing || (setup.timestamp ?? 0) > (existing.timestamp ?? 0)) {
             byDownloadId.set(key, setup);
@@ -114,6 +122,36 @@ export function saveFailedSetup(setupInfo: {
   }
 }
 
+/**
+ * Writes a recovery file to disk without surfacing it in the failed-setups
+ * store. Saved before post-download processing (moving files, extraction) so
+ * closing the app mid-processing leaves a recoverable entry on next launch
+ * instead of forcing a re-download. Deleted once setup completes.
+ */
+export function savePendingRecovery(setupInfo: {
+  downloadInfo: DownloadStatusAndInfo;
+  setupData: SetupCommandData;
+  should: 'call-addon' | 'call-unrar' | 'call-unzip';
+}): void {
+  try {
+    ensureFailedSetupsDir();
+    const id = setupInfo.downloadInfo.id;
+    const saved: FailedSetup = {
+      id,
+      timestamp: Date.now(),
+      ...setupInfo,
+      error: 'The app was closed before setup could finish.',
+      retryCount: 0,
+    };
+    window.electronAPI.fs.write(
+      failedSetupPath(id),
+      JSON.stringify(saved, null, 2)
+    );
+  } catch (error) {
+    logger.sync.error('Failed to save pending recovery:', error);
+  }
+}
+
 function updateRetry(failedSetup: FailedSetup, error: unknown): void {
   const updated = {
     ...failedSetup,
diff --git a/application/src/frontend/managers/DownloadManager.svelte b/application/src/frontend/managers/DownloadManager.svelte
index 35c151a8..ff555f8a 100644
--- a/application/src/frontend/managers/DownloadManager.svelte
+++ b/application/src/frontend/managers/DownloadManager.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-import type { LibraryInfo } from '@ogi-sdk/connect';
+import type { LibraryInfo, SetupCommandData } from '@ogi-sdk/connect';
 import { FileSystemError } from '@ogi-sdk/errors';
 import { createLogger, LOGGER_PREFIXES } from '@ogi-sdk/logger';
 import { Effect } from 'effect';
@@ -8,7 +8,11 @@ import type { AddonDownloadCardPayload } from '@/electron/server/addon-downloads
 import { getApp } from '@/frontend/lib/core/library';
 import { runFrontendEffect } from '@/frontend/lib/core/runtime';
 import { electronRpc } from '@/frontend/lib/electron-rpc';
-import { saveFailedSetup } from '@/frontend/lib/recovery/failedSetups';
+import {
+  removeFailedSetup,
+  saveFailedSetup,
+  savePendingRecovery,
+} from '@/frontend/lib/recovery/failedSetups';
 // no direct use of EventListenerTypes in this module anymore
 import {
   resolveRarArchivePath,
@@ -53,6 +57,26 @@ function dispatchSetupEvent(
   );
 }
 
+function buildSetupData(item: DownloadStatusAndInfo): SetupCommandData {
+  return {
+    path: item.downloadPath,
+    type: item.downloadType as 'direct' | 'torrent' | 'magnet',
+    name: item.name,
+    usedRealDebrid: item.usedDebridService !== undefined,
+    clearOldFilesBeforeUpdate: item.clearOldFilesBeforeUpdate,
+    appID: item.appID,
+    multiPartFiles: item.files || [],
+    storefront: item.storefront,
+    manifest: item.manifest || {},
+    ...(item.isUpdate
+      ? {
+          for: 'update' as const,
+          currentLibraryInfo: getApp(item.appID) as LibraryInfo,
+        }
+      : { for: 'game' as const }),
+  };
+}
+
 const processingDownloadCompletions = new Set<string>();
 
 function shouldSkipDownloadCompleteProcessing(
@@ -111,6 +135,31 @@ async function processDownloadComplete(
 
   let originalOutputDir = outputDir;
 
+  // Persist a recovery file before post-download processing: if the app is
+  // closed mid-processing, the next launch offers a retry from disk instead
+  // of forcing a re-download. Removed once setup completes.
+  const pendingShould =
+    !isTorrent &&
+    (downloadedItem.usedDebridService === 'realdebrid' ||
+      downloadedItem.usedDebridService === 'alldebrid')
+      ? ('call-unrar' as const)
+      : downloadedItem.usedDebridService === 'torbox' ||
+          downloadedItem.usedDebridService === 'premiumize'
+        ? ('call-unzip' as const)
+        : ('call-addon' as const);
+  savePendingRecovery({
+    downloadInfo: downloadedItem,
+    setupData: {
+      ...buildSetupData(downloadedItem),
+      // Extraction retries resolve the archive from downloadPath; a direct
+      // addon retry needs the directory the setup would have received.
+      ...(pendingShould === 'call-addon' && !isTorrent
+        ? { path: outputDir }
+        : {}),
+    },
+    should: pendingShould,
+  });
+
   const shouldStageOldFiles =
     downloadedItem.isUpdate !== true ||
     downloadedItem.clearOldFilesBeforeUpdate !== false;
@@ -123,8 +172,12 @@ async function processDownloadComplete(
   const filesNotToMove = [
     ...(downloadedItem.files ?? []).map((file) => file.name),
     basename(downloadedItem.downloadPath),
+    ...(isTorrent ? [basename(downloadedItem.downloadPath) + '.torrent'] : []),
     'old_files',
   ];
+  const filesToMove = currentFiles.filter(
+    (file) => !filesNotToMove.includes(file)
+  );
   logger.sync.info('Current files: ', currentFiles);
   logger.sync.info('downloadedItem.files: ', downloadedItem.files);
   logger.sync.info('outputDir: ', outputDir);
@@ -134,24 +187,27 @@ async function processDownloadComplete(
     downloadedItem.downloadPath
   );
 
-  if (shouldStageOldFiles && currentFiles.length > 0) {
+  if (shouldStageOldFiles && filesToMove.length > 0) {
     dispatchSetupEvent('log', downloadID, ['Moving all files to old_files']);
     await window.electronAPI.fs.mkdir(outputDir + '/old_files');
     stagedOldFiles = true;
 
     logger.sync.info('Files not to move: ', filesNotToMove);
-    for (const file of currentFiles) {
-      if (!filesNotToMove.includes(file)) {
-        const result = await runFrontendEffect(
-          electronRpc.fs.move({
-            source: outputDir + '/' + file,
-            destination: outputDir + '/old_files/' + file,
-          })
-        );
-        if (result !== 'success') {
-          logger.sync.error('Failed to move file: ', file);
-        }
+    let movedCount = 0;
+    for (const file of filesToMove) {
+      const result = await runFrontendEffect(
+        electronRpc.fs.move({
+          source: outputDir + '/' + file,
+          destination: outputDir + '/old_files/' + file,
+        })
+      );
+      if (result !== 'success') {
+        logger.sync.error('Failed to move file: ', file);
       }
+      movedCount++;
+      updateDownloadStatus(downloadID, {
+        progress: movedCount / filesToMove.length,
+      });
     }
     dispatchSetupEvent('log', downloadID, ['Moved all files']);
     logger.sync.info('Moved all files to old_files');
@@ -295,27 +351,15 @@ async function processDownloadComplete(
       });
 
       await revertOldFiles();
+      updateDownloadStatus(downloadedItem.id, {
+        status: 'error',
+        error: 'Failed to extract RAR file',
+      });
 
       // add a failed setup
       saveFailedSetup({
         downloadInfo: downloadedItem,
-        setupData: {
-          path: downloadedItem.downloadPath,
-          type: downloadedItem.downloadType as 'direct' | 'torrent' | 'magnet',
-          name: downloadedItem.name,
-          usedRealDebrid: downloadedItem.usedDebridService !== undefined,
-          clearOldFilesBeforeUpdate: downloadedItem.clearOldFilesBeforeUpdate,
-          appID: downloadedItem.appID,
-          multiPartFiles: downloadedItem.files || [],
-          storefront: downloadedItem.storefront,
-          manifest: downloadedItem.manifest || {},
-          ...(downloadedItem.isUpdate
-            ? {
-                for: 'update' as const,
-                currentLibraryInfo: getApp(downloadedItem.appID) as LibraryInfo,
-              }
-            : { for: 'game' as const }),
-        },
+        setupData: buildSetupData(downloadedItem),
         error: 'Failed to extract RAR file',
         should: 'call-unrar',
       });
@@ -393,23 +437,7 @@ async function processDownloadComplete(
       });
       saveFailedSetup({
         downloadInfo: downloadedItem,
-        setupData: {
-          path: downloadedItem.downloadPath,
-          type: downloadedItem.downloadType as 'direct' | 'torrent' | 'magnet',
-          name: downloadedItem.name,
-          usedRealDebrid: downloadedItem.usedDebridService !== undefined,
-          clearOldFilesBeforeUpdate: downloadedItem.clearOldFilesBeforeUpdate,
-          appID: downloadedItem.appID,
-          multiPartFiles: downloadedItem.files || [],
-          storefront: downloadedItem.storefront,
-          manifest: downloadedItem.manifest || {},
-          ...(downloadedItem.isUpdate
-            ? {
-                for: 'update' as const,
-                currentLibraryInfo: getApp(downloadedItem.appID) as LibraryInfo,
-              }
-            : { for: 'game' as const }),
-        },
+        setupData: buildSetupData(downloadedItem),
         error: 'Failed to process ZIP file',
         should: 'call-unzip',
       });
@@ -434,6 +462,14 @@ async function processDownloadComplete(
     );
   }
 
+  // Extraction (if any) is done and archives are deleted, so a recovery
+  // from this point on should go straight to the addon with the final path.
+  savePendingRecovery({
+    downloadInfo: downloadedItem,
+    setupData: { ...buildSetupData(downloadedItem), path: outputDir },
+    should: 'call-addon',
+  });
+
   try {
     // Check if this is an update download and route to appropriate setup function
     updateDownloadStatus(downloadedItem.id, {
@@ -450,6 +486,7 @@ async function processDownloadComplete(
         runSetupApp(downloadedItem, outputDir, isTorrent, additionalData)
       );
     }
+    removeFailedSetup(downloadID);
 
     // delete the old_files directory
     try {
@@ -469,6 +506,14 @@ async function processDownloadComplete(
     }
   } catch (error) {
     logger.sync.error('Error setting up app: ', error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    dispatchSetupEvent('log', downloadedItem.id, [
+      `Setup failed: ${errorMessage}`,
+    ]);
+    updateDownloadStatus(downloadedItem.id, {
+      status: 'error',
+      error: errorMessage,
+    });
     await revertOldFiles();
   } finally {
     processingDownloadCompletions.delete(downloadID);

From 2e6f08a346d17bcd4567881ec0bf192af0eff39d Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:22 +0000
Subject: [PATCH 04/16] fix(application/frontend): serialize reactive setup
 payloads before RPC

---
 .../src/frontend/lib/setup/serialize.ts       |  4 ++++
 application/src/frontend/lib/setup/setup.ts   |  5 +++--
 application/tests/setup-serialization.test.ts | 19 +++++++++++++++++++
 3 files changed, 26 insertions(+), 2 deletions(-)
 create mode 100644 application/src/frontend/lib/setup/serialize.ts
 create mode 100644 application/tests/setup-serialization.test.ts

diff --git a/application/src/frontend/lib/setup/serialize.ts b/application/src/frontend/lib/setup/serialize.ts
new file mode 100644
index 00000000..2c82185f
--- /dev/null
+++ b/application/src/frontend/lib/setup/serialize.ts
@@ -0,0 +1,4 @@
+/** Remove reactive proxies before addon data crosses the RPC boundary. */
+export function toSerializable<Value>(value: Value): Value {
+  return JSON.parse(JSON.stringify(value)) as Value;
+}
diff --git a/application/src/frontend/lib/setup/setup.ts b/application/src/frontend/lib/setup/setup.ts
index 823622a9..6ddad510 100644
--- a/application/src/frontend/lib/setup/setup.ts
+++ b/application/src/frontend/lib/setup/setup.ts
@@ -17,6 +17,7 @@ import { getApp } from '@/frontend/lib/core/library';
 import { updateDownloadStatus } from '@/frontend/lib/downloads/lifecycle';
 import { electronRpc } from '@/frontend/lib/electron-rpc';
 import { saveFailedSetup } from '@/frontend/lib/recovery/failedSetups';
+import { toSerializable } from '@/frontend/lib/setup/serialize';
 import { updatesManager } from '@/frontend/states.svelte';
 import {
   createNotification,
@@ -99,9 +100,9 @@ export function createSetupPayload(
     ...(currentLibraryInfo ? { currentLibraryInfo } : {}),
     multiPartFiles:
       downloadedItem.downloadType === 'direct'
-        ? structuredClone(downloadedItem.files ?? [])
+        ? toSerializable(downloadedItem.files ?? [])
         : [],
-    manifest: structuredClone(downloadedItem.manifest ?? {}),
+    manifest: toSerializable(downloadedItem.manifest ?? {}),
     ...additionalData,
   } as SetupCommandData & { addonID: string };
 }
diff --git a/application/tests/setup-serialization.test.ts b/application/tests/setup-serialization.test.ts
new file mode 100644
index 00000000..03c38123
--- /dev/null
+++ b/application/tests/setup-serialization.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'bun:test';
+import { toSerializable } from '../src/frontend/lib/setup/serialize.js';
+
+describe('setup payload serialization', () => {
+  test('copies proxy-backed addon data into a plain RPC value', () => {
+    const manifest = new Proxy(
+      { service: '1337x', nested: { source: 'Fatboy Unpack' } },
+      {}
+    );
+
+    const serialized = toSerializable(manifest);
+
+    expect(serialized).toEqual({
+      service: '1337x',
+      nested: { source: 'Fatboy Unpack' },
+    });
+    expect(serialized).not.toBe(manifest);
+  });
+});

From 1d3e27182dee510b83b88f9b39dbe2838bb0b5c0 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:23 +0000
Subject: [PATCH 05/16] fix(application): buffer terminal events for
 already-ready handshakes

---
 application/src/lib/download-handshake.ts    |  1 +
 application/tests/download-handshake.test.ts | 33 ++++++++++++++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 application/tests/download-handshake.test.ts

diff --git a/application/src/lib/download-handshake.ts b/application/src/lib/download-handshake.ts
index f76173e2..f7828a35 100644
--- a/application/src/lib/download-handshake.ts
+++ b/application/src/lib/download-handshake.ts
@@ -99,6 +99,7 @@ export function waitForDownloadHandshake(
 ): Promise<DownloadHandshakeResult> {
   const existing = lastKnownState.get(id);
   if (existing && isReadyState(existing)) {
+    settledHandshakes.add(id);
     return Promise.resolve(existing);
   }
 
diff --git a/application/tests/download-handshake.test.ts b/application/tests/download-handshake.test.ts
new file mode 100644
index 00000000..3a4027b5
--- /dev/null
+++ b/application/tests/download-handshake.test.ts
@@ -0,0 +1,33 @@
+import { beforeAll, describe, expect, mock, test } from 'bun:test';
+
+mock.module('@/electron/rpc/router-core.js', () => ({
+  procedure: mock(() => ({})),
+  router: mock(() => ({})),
+}));
+mock.module('@/lib/electron-rpc.js', () => ({
+  ElectronRpc: { download: {} },
+}));
+
+let handshake: typeof import('../src/lib/download-handshake.js');
+
+beforeAll(async () => {
+  handshake = await import('../src/lib/download-handshake.js');
+});
+
+describe('download handshake replay', () => {
+  test('buffers a terminal event when the initial state was already ready', async () => {
+    const id = 'already-downloading';
+    handshake.registerDownloadHandshake(id);
+    handshake.updateDownloadHandshake({ id, status: 'downloading' });
+
+    await handshake.waitForDownloadHandshake(id);
+    handshake.updateDownloadHandshake(
+      { id, status: 'seeding' },
+      { channel: 'torrent:download-complete', data: { id } }
+    );
+
+    expect(handshake.consumeDownloadReplayEvents(id)).toEqual([
+      { channel: 'torrent:download-complete', data: { id } },
+    ]);
+  });
+});

From f75e571219cc4a15fd8bde8fa03211016f5b34dc Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:23 +0000
Subject: [PATCH 06/16] fix(application/frontend): check updates per addon and
 fork update download

---
 .../components/built/UpdateAppModal.svelte    | 20 ++++-----
 .../frontend/managers/AppUpdateManager.svelte | 45 +++++++++----------
 2 files changed, 30 insertions(+), 35 deletions(-)

diff --git a/application/src/frontend/components/built/UpdateAppModal.svelte b/application/src/frontend/components/built/UpdateAppModal.svelte
index a47c69b7..26e990a5 100644
--- a/application/src/frontend/components/built/UpdateAppModal.svelte
+++ b/application/src/frontend/components/built/UpdateAppModal.svelte
@@ -225,9 +225,16 @@ async function handleDownloadClick(
     updateVersion: updateVersion,
   } as SearchResultWithAddon & { isUpdate: boolean; updateVersion: string };
 
-  const started = await runFrontendEffect(
-    startDownloadEffect(updateResult, appID, event).pipe(
+  startDownloadEffect(updateResult, appID, event)
+    .pipe(
       Effect.as(true),
+      Effect.tap(() => {
+        createNotification({
+          id: Math.random().toString(36).substring(7),
+          message: `Starting update download for ${gameName}`,
+          type: 'info',
+        });
+      }),
       Effect.catchAll((error) =>
         Effect.sync(() => {
           logger.sync.error('Failed to start update download:', error);
@@ -240,15 +247,8 @@ async function handleDownloadClick(
         })
       )
     )
-  );
-  if (!started) return;
+    .pipe(Effect.runFork);
   onClose();
-
-  createNotification({
-    id: Math.random().toString(36).substring(7),
-    message: `Starting update download for ${gameName}`,
-    type: 'info',
-  });
 }
 
 function toggleAddonCollapse(addonId: string) {
diff --git a/application/src/frontend/managers/AppUpdateManager.svelte b/application/src/frontend/managers/AppUpdateManager.svelte
index c4ea7612..b37f9ba5 100644
--- a/application/src/frontend/managers/AppUpdateManager.svelte
+++ b/application/src/frontend/managers/AppUpdateManager.svelte
@@ -96,32 +96,27 @@ function checkForAppUpdates(connectedAddons: AddonInfo[]) {
       checkableApps,
       ({ app, addons }) =>
         Effect.gen(function* () {
-          if (addons.length > 1) {
-            return yield* Effect.fail(
-              new UpdateError({
-                message: 'Multiple clients found to serve this storefront',
-              })
-            );
-          }
-          const update = yield* Effect.tryPromise({
-            try: () =>
-              addonServer.addon(addons[0].id).checkForUpdates({
-                appID: app.appID,
-                storefront: app.storefront,
-                currentVersion: app.version,
-              }) as Promise<{ available: boolean; version: string }>,
-            catch: (cause) =>
-              new UpdateError({
-                message: `Failed to check for updates: ${formatError(cause)}`,
-              }),
-          });
-          if (runId === updateCheckRunId && update.available) {
-            updatesManager.addAppUpdate({
-              appID: app.appID,
-              name: app.name,
-              updateAvailable: true,
-              updateVersion: update.version,
+          for (const addon of addons) {
+            const update = yield* Effect.tryPromise({
+              try: () =>
+                addonServer.addon(addon.id).checkForUpdates({
+                  appID: app.appID,
+                  storefront: app.storefront,
+                  currentVersion: app.version,
+                }) as Promise<{ available: boolean; version: string }>,
+              catch: (cause) =>
+                new UpdateError({
+                  message: `Failed to check for updates: ${formatError(cause)}`,
+                }),
             });
+            if (runId === updateCheckRunId && update.available) {
+              updatesManager.addAppUpdate({
+                appID: app.appID,
+                name: addon.name,
+                updateAvailable: true,
+                updateVersion: update.version,
+              });
+            }
           }
         }).pipe(
           Effect.catchAll((error) =>

From 53a8ce1adae72827a3e2d401f0b2ed642da25017 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:23 +0000
Subject: [PATCH 07/16] fix(application/electron): back up shortcuts.vdf before
 rewriting

---
 application/src/electron/lib/steam-installation.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/application/src/electron/lib/steam-installation.ts b/application/src/electron/lib/steam-installation.ts
index 794a6bf2..a41ebc7e 100644
--- a/application/src/electron/lib/steam-installation.ts
+++ b/application/src/electron/lib/steam-installation.ts
@@ -513,6 +513,7 @@ export const SteamRepositoryLive = (
           const configExisted = config.existed;
           let shortcutsCommitted = false;
           let configCommitted = false;
+          let shortcutsBackupWritten = false;
           const restore = (
             filePath: string,
             fileExisted: boolean,
@@ -553,6 +554,13 @@ export const SteamRepositoryLive = (
                   yield* writeFileAtomic(configPath, options.configSource);
                   configCommitted = true;
                 }
+                if (existed && !shortcutsBackupWritten) {
+                  yield* writeFileAtomic(
+                    `${shortcutsPath}.ogi-backup`,
+                    original
+                  );
+                  shortcutsBackupWritten = true;
+                }
                 const written = yield* Effect.either(
                   write(shortcutsPath, updatedRoot)
                 );

From 5d30235c2f2b93683d4a56ac4da995c176dfb7fa Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:23 +0000
Subject: [PATCH 08/16] fix(application/frontend): mark my-addons tab as
 selected

---
 application/src/frontend/views/ConfigView.svelte | 1 +
 1 file changed, 1 insertion(+)

diff --git a/application/src/frontend/views/ConfigView.svelte b/application/src/frontend/views/ConfigView.svelte
index b5ba2469..71dddd18 100644
--- a/application/src/frontend/views/ConfigView.svelte
+++ b/application/src/frontend/views/ConfigView.svelte
@@ -215,6 +215,7 @@ async function resetMarketplaceSources() {
     >
       <div class="absolute inset-0 flex flex-row gap-4 h-12 z-10">
         <button
+          data-selected={$view === 'my-addons'}
           onclick={() => view.set('my-addons')}
           class="h-full flex-1 border-none text-accent-dark font-archivo rounded-lg bg-accent-lighter data-[selected=true]:bg-accent-light shadow-md text-lg hover:bg-accent-light transition-colors"
           >My Addons</button

From 5b7ea9462e1b361fd78921e12d102150757ee1af Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:33:23 +0000
Subject: [PATCH 09/16] chore: tailwind css data, tsconfig rootDir, yargs
 override, drop clean-log

---
 .vscode/settings.json                  |   4 +-
 .vscode/tailwind.css-data.json         |  45 +++++++++++
 application/scripts/clean-log.py       | 105 -------------------------
 application/src/electron/tsconfig.json |   2 +-
 bun.lock                               |   3 +-
 package.json                           |   3 +-
 6 files changed, 53 insertions(+), 109 deletions(-)
 create mode 100644 .vscode/tailwind.css-data.json
 delete mode 100755 application/scripts/clean-log.py

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 7987f3d5..0030bc12 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -51,7 +51,9 @@
     "**/.hg/**",
     "**/.svn/**"
   ],
-  "css.validate": false,
+  "css.customData": [".vscode/tailwind.css-data.json"],
+  "css.lint.unknownAtRules": "ignore",
+  "css.validate": true,
   "tailwindCSS.validate": true,
   "tailwindCSS.emmetCompletions": true,
   "typescript.preferences.autoImportSpecifierExcludeRegexes": [
diff --git a/.vscode/tailwind.css-data.json b/.vscode/tailwind.css-data.json
new file mode 100644
index 00000000..838287ec
--- /dev/null
+++ b/.vscode/tailwind.css-data.json
@@ -0,0 +1,45 @@
+{
+  "version": 1.1,
+  "atDirectives": [
+    {
+      "name": "@apply",
+      "description": "Inline Tailwind utility classes into a CSS rule."
+    },
+    {
+      "name": "@config",
+      "description": "Load a legacy Tailwind JavaScript configuration file."
+    },
+    {
+      "name": "@custom-variant",
+      "description": "Define a custom Tailwind variant."
+    },
+    {
+      "name": "@plugin",
+      "description": "Load a legacy Tailwind JavaScript plugin."
+    },
+    {
+      "name": "@reference",
+      "description": "Import a Tailwind stylesheet for theme and utility references without emitting CSS."
+    },
+    {
+      "name": "@source",
+      "description": "Register source files for Tailwind class detection."
+    },
+    {
+      "name": "@tailwind",
+      "description": "Insert a Tailwind CSS layer."
+    },
+    {
+      "name": "@theme",
+      "description": "Define Tailwind theme variables."
+    },
+    {
+      "name": "@utility",
+      "description": "Define a custom Tailwind utility."
+    },
+    {
+      "name": "@variant",
+      "description": "Apply a Tailwind variant to CSS rules."
+    }
+  ]
+}
diff --git a/application/scripts/clean-log.py b/application/scripts/clean-log.py
deleted file mode 100755
index 1cd1b5b6..00000000
--- a/application/scripts/clean-log.py
+++ /dev/null
@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-import re
-import sys
-from pathlib import Path
-
-NOISE_PATTERNS = [
-    re.compile(r"^\[steam-integration\] (Using cached|Cached) "),
-    re.compile(r"^task finished "),
-    re.compile(r"^\[steam-integration\] dispatched response to "),
-    re.compile(r"^\[fatboy-unpack\] dispatched response to "),
-    re.compile(r"^\[steamrip-addon\] dispatched response to "),
-    re.compile(r"^Checking for updates for "),
-    re.compile(r"^\[steam-integration\] Checking for updates for "),
-    re.compile(r"^Setting events-available to "),
-]
-
-IMPORTANT_PATTERNS = [
-    re.compile(r"Error|UnhandledPromiseRejection|fatal:|failed|Failed|ENOENT|AxiosError|NetworkError|Cloudflare|not a git repository|readyState|timeout|SIGTERM|AbortError", re.I),
-    re.compile(r"Addon .*updates?|updated successfully|addons failed", re.I),
-    re.compile(r"Starting addon|Stopping addon|All addons started|Stopping server|Addon Server", re.I),
-]
-
-DUMP_START_PATTERNS = [
-    re.compile(r"^\[fatboy-unpack\] directHeader HTMLHeadingElement"),
-    re.compile(r"^\s+\[Symbol\(impl\)\]:"),
-]
-
-DUMP_END_PATTERNS = [
-    re.compile(r"^\[Error:"),
-    re.compile(r"^\[[^\]]+\]"),
-    re.compile(r"^task finished "),
-    re.compile(r"^Sent app details"),
-    re.compile(r"^dispatched response"),
-]
-
-STACK_CONTINUATION = re.compile(r"^\s+(at |code:|killed:|signal:|cmd:|errno:|syscall:|path:|message:|name:|stack:|isAxiosError:|})")
-
-def is_noise(line: str) -> bool:
-    return any(p.search(line) for p in NOISE_PATTERNS)
-
-def is_important(line: str) -> bool:
-    return any(p.search(line) for p in IMPORTANT_PATTERNS)
-
-def clean_log(src: Path, dst: Path) -> None:
-    lines = src.read_text(errors="replace").splitlines()
-    out = []
-    skipped_noise = 0
-    skipped_dump = 0
-    in_dump = False
-    previous_kept_was_blank = False
-
-    for i, line in enumerate(lines, start=1):
-        if in_dump:
-            if any(p.search(line) for p in DUMP_END_PATTERNS):
-                out.append(f"[clean-log] omitted {skipped_dump} lines of verbose object dump")
-                out.append("")
-                in_dump = False
-                skipped_dump = 0
-                # fall through and process this line normally
-            else:
-                skipped_dump += 1
-                continue
-
-        if any(p.search(line) for p in DUMP_START_PATTERNS):
-            out.append(f"{i}: {line}")
-            in_dump = True
-            skipped_dump = 0
-            continue
-
-        if is_noise(line) and not is_important(line):
-            skipped_noise += 1
-            continue
-
-        keep = is_important(line) or STACK_CONTINUATION.search(line) or line.strip() == "" or line.startswith("From ") or line.startswith("Updating ") or line.startswith("Fast-forward")
-
-        if keep:
-            if line.strip() == "":
-                if previous_kept_was_blank:
-                    continue
-                previous_kept_was_blank = True
-                out.append("")
-            else:
-                previous_kept_was_blank = False
-                out.append(f"{i}: {line}")
-
-    if in_dump:
-        out.append(f"[clean-log] omitted {skipped_dump} lines of verbose object dump")
-
-    header = [
-        f"Cleaned log: {src}",
-        f"Original lines: {len(lines)}",
-        f"Removed low-value repeated lines: {skipped_noise}",
-        "",
-    ]
-    dst.write_text("\n".join(header + out) + "\n")
-
-if __name__ == "__main__":
-    if len(sys.argv) not in (2, 3):
-        print(f"Usage: {sys.argv[0]} INPUT_LOG [OUTPUT_LOG]", file=sys.stderr)
-        sys.exit(2)
-
-    src = Path(sys.argv[1]).expanduser()
-    dst = Path(sys.argv[2]).expanduser() if len(sys.argv) == 3 else src.with_suffix(src.suffix + ".cleaned")
-    clean_log(src, dst)
-    print(dst)
diff --git a/application/src/electron/tsconfig.json b/application/src/electron/tsconfig.json
index 41d7efbb..60cd82dc 100644
--- a/application/src/electron/tsconfig.json
+++ b/application/src/electron/tsconfig.json
@@ -2,7 +2,7 @@
   "compileOnSave": true,
   "compilerOptions": {
     "outDir": "../../build",
-    "baseUrl": ".",
+    "rootDir": "..",
     "typeRoots": ["node_modules/@types"],
     "target": "ES2022",
     "allowJs": true,
diff --git a/bun.lock b/bun.lock
index e35202f2..e5e322b1 100644
--- a/bun.lock
+++ b/bun.lock
@@ -281,6 +281,7 @@
     "@types/minimatch": "5.1.2",
     "@types/node": "^22.15.0",
     "effect": "3.22.0",
+    "yargs": "17.7.3",
   },
   "packages": {
     "7zip-bin": ["7zip-bin@5.2.0", "", {}, "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A=="],
@@ -2665,7 +2666,7 @@
 
     "yaml-language-server": ["yaml-language-server@1.20.0", "", { "dependencies": { "@vscode/l10n": "^0.0.18", "ajv": "^8.17.1", "ajv-draft-04": "^1.0.0", "prettier": "^3.5.0", "request-light": "^0.5.7", "vscode-json-languageservice": "4.1.8", "vscode-languageserver": "^9.0.0", "vscode-languageserver-textdocument": "^1.0.1", "vscode-languageserver-types": "^3.16.0", "vscode-uri": "^3.0.2", "yaml": "2.7.1" }, "bin": { "yaml-language-server": "bin/yaml-language-server" } }, "sha512-qhjK/bzSRZ6HtTvgeFvjNPJGWdZ0+x5NREV/9XZWFjIGezew2b4r5JPy66IfOhd5OA7KeFwk1JfmEbnTvev0cA=="],
 
-    "yargs": ["yargs@17.7.2", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w=="],
+    "yargs": ["yargs@17.7.3", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g=="],
 
     "yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="],
 
diff --git a/package.json b/package.json
index 6aa86761..0a65b99d 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,8 @@
   "overrides": {
     "@types/minimatch": "5.1.2",
     "@types/node": "^22.15.0",
-    "effect": "3.22.0"
+    "effect": "3.22.0",
+    "yargs": "17.7.3"
   },
   "trustedDependencies": [
     "electron",

From 54019e43527bc753d20d931ab5ca3025e041b5c8 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:40:24 +0000
Subject: [PATCH 10/16] test(application): alias real modules in handshake test
 instead of stubs

---
 application/tests/download-handshake.test.ts | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/application/tests/download-handshake.test.ts b/application/tests/download-handshake.test.ts
index 3a4027b5..0a74be0d 100644
--- a/application/tests/download-handshake.test.ts
+++ b/application/tests/download-handshake.test.ts
@@ -1,12 +1,12 @@
 import { beforeAll, describe, expect, mock, test } from 'bun:test';
 
-mock.module('@/electron/rpc/router-core.js', () => ({
-  procedure: mock(() => ({})),
-  router: mock(() => ({})),
-}));
-mock.module('@/lib/electron-rpc.js', () => ({
-  ElectronRpc: { download: {} },
-}));
+// src/lib has no tsconfig of its own, so its `@/` imports don't resolve
+// under bun test. Point the aliases at the real modules rather than stubs so
+// suites sharing this process still see the real router and RPC schema.
+mock.module('@/electron/rpc/router-core.js', () =>
+  require('../src/electron/rpc/router-core.js')
+);
+mock.module('@/lib/electron-rpc.js', () => require('../src/lib/electron-rpc.js'));
 
 let handshake: typeof import('../src/lib/download-handshake.js');
 

From a3d43a0f4e02b16f58a6b9810df88e7cb4580eaf Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:43:37 +0000
Subject: [PATCH 11/16] fix(application/frontend): keep checking other addons
 when one update check fails

---
 .../frontend/managers/AppUpdateManager.svelte | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/application/src/frontend/managers/AppUpdateManager.svelte b/application/src/frontend/managers/AppUpdateManager.svelte
index b37f9ba5..abc050af 100644
--- a/application/src/frontend/managers/AppUpdateManager.svelte
+++ b/application/src/frontend/managers/AppUpdateManager.svelte
@@ -96,6 +96,7 @@ function checkForAppUpdates(connectedAddons: AddonInfo[]) {
       checkableApps,
       ({ app, addons }) =>
         Effect.gen(function* () {
+          // One addon failing must not hide updates served by the others.
           for (const addon of addons) {
             const update = yield* Effect.tryPromise({
               try: () =>
@@ -108,8 +109,20 @@ function checkForAppUpdates(connectedAddons: AddonInfo[]) {
                 new UpdateError({
                   message: `Failed to check for updates: ${formatError(cause)}`,
                 }),
-            });
-            if (runId === updateCheckRunId && update.available) {
+            }).pipe(
+              Effect.catchAll((error) =>
+                logger
+                  .error(
+                    'Error checking for updates for app',
+                    app.name,
+                    'via',
+                    addon.name,
+                    error
+                  )
+                  .pipe(Effect.as(undefined))
+              )
+            );
+            if (update?.available && runId === updateCheckRunId) {
               updatesManager.addAppUpdate({
                 appID: app.appID,
                 name: addon.name,
@@ -119,9 +132,6 @@ function checkForAppUpdates(connectedAddons: AddonInfo[]) {
             }
           }
         }).pipe(
-          Effect.catchAll((error) =>
-            logger.error('Error checking for updates for app', app.name, error)
-          ),
           Effect.ensuring(
             Effect.sync(() => {
               if (runId === updateCheckRunId) {

From f71ace66df64e75915ee93a5799a293f7c82bce4 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:43:37 +0000
Subject: [PATCH 12/16] fix(application/frontend): write pending recovery only
 after old_files staging

---
 .../frontend/managers/DownloadManager.svelte  | 52 ++++++++++---------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/application/src/frontend/managers/DownloadManager.svelte b/application/src/frontend/managers/DownloadManager.svelte
index ff555f8a..7b094b0e 100644
--- a/application/src/frontend/managers/DownloadManager.svelte
+++ b/application/src/frontend/managers/DownloadManager.svelte
@@ -135,31 +135,6 @@ async function processDownloadComplete(
 
   let originalOutputDir = outputDir;
 
-  // Persist a recovery file before post-download processing: if the app is
-  // closed mid-processing, the next launch offers a retry from disk instead
-  // of forcing a re-download. Removed once setup completes.
-  const pendingShould =
-    !isTorrent &&
-    (downloadedItem.usedDebridService === 'realdebrid' ||
-      downloadedItem.usedDebridService === 'alldebrid')
-      ? ('call-unrar' as const)
-      : downloadedItem.usedDebridService === 'torbox' ||
-          downloadedItem.usedDebridService === 'premiumize'
-        ? ('call-unzip' as const)
-        : ('call-addon' as const);
-  savePendingRecovery({
-    downloadInfo: downloadedItem,
-    setupData: {
-      ...buildSetupData(downloadedItem),
-      // Extraction retries resolve the archive from downloadPath; a direct
-      // addon retry needs the directory the setup would have received.
-      ...(pendingShould === 'call-addon' && !isTorrent
-        ? { path: outputDir }
-        : {}),
-    },
-    should: pendingShould,
-  });
-
   const shouldStageOldFiles =
     downloadedItem.isUpdate !== true ||
     downloadedItem.clearOldFilesBeforeUpdate !== false;
@@ -217,6 +192,33 @@ async function processDownloadComplete(
     ]);
     logger.sync.info('Skipping old_files staging for update');
   }
+  // Persist a recovery file once staging is done: if the app is closed during
+  // extraction or moving, the next launch offers a retry from disk instead of
+  // forcing a re-download. Written only after staging so a retry never runs
+  // against a directory with old files half-moved into old_files. Removed
+  // once setup completes.
+  const pendingShould =
+    !isTorrent &&
+    (downloadedItem.usedDebridService === 'realdebrid' ||
+      downloadedItem.usedDebridService === 'alldebrid')
+      ? ('call-unrar' as const)
+      : downloadedItem.usedDebridService === 'torbox' ||
+          downloadedItem.usedDebridService === 'premiumize'
+        ? ('call-unzip' as const)
+        : ('call-addon' as const);
+  savePendingRecovery({
+    downloadInfo: downloadedItem,
+    setupData: {
+      ...buildSetupData(downloadedItem),
+      // Extraction retries resolve the archive from downloadPath; a direct
+      // addon retry needs the directory the setup would have received.
+      ...(pendingShould === 'call-addon' && !isTorrent
+        ? { path: outputDir }
+        : {}),
+    },
+    should: pendingShould,
+  });
+
   let additionalData: any = {};
   logger.sync.info('Downloaded Item: ', downloadedItem);
 

From 79494474b2ebfe4144b5a334bb0bc29486093390 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:44:15 +0000
Subject: [PATCH 13/16] docs(application/frontend): sync pending-recovery
 comment with write timing

---
 application/src/frontend/lib/recovery/failedSetups.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/application/src/frontend/lib/recovery/failedSetups.ts b/application/src/frontend/lib/recovery/failedSetups.ts
index 891788c3..9f26ac62 100644
--- a/application/src/frontend/lib/recovery/failedSetups.ts
+++ b/application/src/frontend/lib/recovery/failedSetups.ts
@@ -124,7 +124,7 @@ export function saveFailedSetup(setupInfo: {
 
 /**
  * Writes a recovery file to disk without surfacing it in the failed-setups
- * store. Saved before post-download processing (moving files, extraction) so
+ * store. Saved once old_files staging is done and again after extraction, so
  * closing the app mid-processing leaves a recoverable entry on next launch
  * instead of forcing a re-download. Deleted once setup completes.
  */

From 0dd8b86ab3f576b3cf2de2c665d58a53bd5d31bc Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:58:57 +0000
Subject: [PATCH 14/16] fix(application/frontend): skip pending recovery when
 old_files staging was not clean

---
 .../frontend/managers/DownloadManager.svelte  | 46 +++++++++++--------
 1 file changed, 26 insertions(+), 20 deletions(-)

diff --git a/application/src/frontend/managers/DownloadManager.svelte b/application/src/frontend/managers/DownloadManager.svelte
index 7b094b0e..6e5c0527 100644
--- a/application/src/frontend/managers/DownloadManager.svelte
+++ b/application/src/frontend/managers/DownloadManager.svelte
@@ -139,6 +139,7 @@ async function processDownloadComplete(
     downloadedItem.isUpdate !== true ||
     downloadedItem.clearOldFilesBeforeUpdate !== false;
   let stagedOldFiles = false;
+  let stagedCleanly = true;
 
   // Move existing files into old_files before setup unless this update opted out.
   const currentFiles = await runFrontendEffect(
@@ -178,6 +179,7 @@ async function processDownloadComplete(
       );
       if (result !== 'success') {
         logger.sync.error('Failed to move file: ', file);
+        stagedCleanly = false;
       }
       movedCount++;
       updateDownloadStatus(downloadID, {
@@ -194,9 +196,23 @@ async function processDownloadComplete(
   }
   // Persist a recovery file once staging is done: if the app is closed during
   // extraction or moving, the next launch offers a retry from disk instead of
-  // forcing a re-download. Written only after staging so a retry never runs
-  // against a directory with old files half-moved into old_files. Removed
-  // once setup completes.
+  // forcing a re-download. Written only after a clean staging pass so a retry
+  // never runs against a directory with old files half-moved into old_files.
+  // Removed once setup completes.
+  const persistRecovery = (
+    should: 'call-addon' | 'call-unrar' | 'call-unzip',
+    path?: string
+  ) => {
+    if (!stagedCleanly) return;
+    savePendingRecovery({
+      downloadInfo: downloadedItem,
+      setupData: {
+        ...buildSetupData(downloadedItem),
+        ...(path !== undefined ? { path } : {}),
+      },
+      should,
+    });
+  };
   const pendingShould =
     !isTorrent &&
     (downloadedItem.usedDebridService === 'realdebrid' ||
@@ -206,18 +222,12 @@ async function processDownloadComplete(
           downloadedItem.usedDebridService === 'premiumize'
         ? ('call-unzip' as const)
         : ('call-addon' as const);
-  savePendingRecovery({
-    downloadInfo: downloadedItem,
-    setupData: {
-      ...buildSetupData(downloadedItem),
-      // Extraction retries resolve the archive from downloadPath; a direct
-      // addon retry needs the directory the setup would have received.
-      ...(pendingShould === 'call-addon' && !isTorrent
-        ? { path: outputDir }
-        : {}),
-    },
-    should: pendingShould,
-  });
+  // Extraction retries resolve the archive from downloadPath; a direct addon
+  // retry needs the directory the setup would have received.
+  persistRecovery(
+    pendingShould,
+    pendingShould === 'call-addon' && !isTorrent ? outputDir : undefined
+  );
 
   let additionalData: any = {};
   logger.sync.info('Downloaded Item: ', downloadedItem);
@@ -466,11 +476,7 @@ async function processDownloadComplete(
 
   // Extraction (if any) is done and archives are deleted, so a recovery
   // from this point on should go straight to the addon with the final path.
-  savePendingRecovery({
-    downloadInfo: downloadedItem,
-    setupData: { ...buildSetupData(downloadedItem), path: outputDir },
-    should: 'call-addon',
-  });
+  persistRecovery('call-addon', outputDir);
 
   try {
     // Check if this is an update download and route to appropriate setup function

From f965c5debf227233386cbc40632b01ee79e8cd1b Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 04:58:57 +0000
Subject: [PATCH 15/16] fix(application/frontend): keep the first addon's
 update result per app

---
 application/src/frontend/managers/AppUpdateManager.svelte | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/application/src/frontend/managers/AppUpdateManager.svelte b/application/src/frontend/managers/AppUpdateManager.svelte
index abc050af..1f932054 100644
--- a/application/src/frontend/managers/AppUpdateManager.svelte
+++ b/application/src/frontend/managers/AppUpdateManager.svelte
@@ -129,6 +129,9 @@ function checkForAppUpdates(connectedAddons: AddonInfo[]) {
                 updateAvailable: true,
                 updateVersion: update.version,
               });
+              // The store holds one version per app; keep the first addon's
+              // answer instead of letting later addons silently overwrite it.
+              break;
             }
           }
         }).pipe(

From 8a40143f28cff90f201cd7698a739c82da5727c9 Mon Sep 17 00:00:00 2001
From: shar <66748576+Nat3z@users.noreply.github.com>
Date: Sat, 5 Sep 2026 05:13:34 +0000
Subject: [PATCH 16/16] fix(application/frontend): write first recovery after
 archive classification and clear it on dirty staging

---
 .../frontend/managers/DownloadManager.svelte  | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/application/src/frontend/managers/DownloadManager.svelte b/application/src/frontend/managers/DownloadManager.svelte
index 6e5c0527..af560939 100644
--- a/application/src/frontend/managers/DownloadManager.svelte
+++ b/application/src/frontend/managers/DownloadManager.svelte
@@ -194,16 +194,18 @@ async function processDownloadComplete(
     ]);
     logger.sync.info('Skipping old_files staging for update');
   }
-  // Persist a recovery file once staging is done: if the app is closed during
-  // extraction or moving, the next launch offers a retry from disk instead of
-  // forcing a re-download. Written only after a clean staging pass so a retry
-  // never runs against a directory with old files half-moved into old_files.
-  // Removed once setup completes.
+  // Recovery files let the next launch retry from disk if the app is closed
+  // during extraction or moving, instead of forcing a re-download. Skipped
+  // after a dirty staging pass so a retry never runs against a directory with
+  // old files half-moved into old_files. Removed once setup completes.
   const persistRecovery = (
     should: 'call-addon' | 'call-unrar' | 'call-unzip',
     path?: string
   ) => {
-    if (!stagedCleanly) return;
+    if (!stagedCleanly) {
+      removeFailedSetup(downloadID);
+      return;
+    }
     savePendingRecovery({
       downloadInfo: downloadedItem,
       setupData: {
@@ -213,21 +215,6 @@ async function processDownloadComplete(
       should,
     });
   };
-  const pendingShould =
-    !isTorrent &&
-    (downloadedItem.usedDebridService === 'realdebrid' ||
-      downloadedItem.usedDebridService === 'alldebrid')
-      ? ('call-unrar' as const)
-      : downloadedItem.usedDebridService === 'torbox' ||
-          downloadedItem.usedDebridService === 'premiumize'
-        ? ('call-unzip' as const)
-        : ('call-addon' as const);
-  // Extraction retries resolve the archive from downloadPath; a direct addon
-  // retry needs the directory the setup would have received.
-  persistRecovery(
-    pendingShould,
-    pendingShould === 'call-addon' && !isTorrent ? outputDir : undefined
-  );
 
   let additionalData: any = {};
   logger.sync.info('Downloaded Item: ', downloadedItem);
@@ -309,6 +296,21 @@ async function processDownloadComplete(
     }
   }
 
+  // First recovery write, once the torrent path is normalized and the archive
+  // kind is known so the retry runs the right step against the right path.
+  const pendingShould = rarArchivePath
+    ? ('call-unrar' as const)
+    : downloadedItem.usedDebridService === 'torbox' ||
+        downloadedItem.usedDebridService === 'premiumize'
+      ? ('call-unzip' as const)
+      : ('call-addon' as const);
+  // Extraction retries resolve the archive from downloadPath; a direct addon
+  // retry needs the directory the setup would have received.
+  persistRecovery(
+    pendingShould,
+    pendingShould === 'call-addon' && !isTorrent ? outputDir : undefined
+  );
+
   if (rarArchivePath) {
     // Initialize setup logs for this download
     setupLogs.update((logs) => ({