package.json

@@ -1,6 +1,6 @@
 {
   "name": "real-debrid-downloader",
-  "version": "1.7.232",
+  "version": "1.7.227",
   "description": "Desktop downloader",
   "main": "build/main/main/main.js",
   "author": "Sucukdeluxe",

src/main/app-controller.ts

@@ -180,13 +180,21 @@ export class AppController {
     if (this.settings.autoResumeOnStart) {
       const snapshot = this.manager.getSnapshot();
       const hasPending = Object.values(snapshot.session.items).some((item) => item.status === "queued" || item.status === "reconnect_wait");
-      if (hasPending && this.hasAnyProviderToken(this.settings)) {
-        if (this.onStateHandler) {
-          this.beginAutoResume();
-        } else {
-          this.autoResumePending = true;
-          logger.info("Auto-Resume beim Start vorgemerkt");
-        }
+      if (hasPending) {
+        void this.manager.getStartConflicts().then((conflicts) => {
+          const hasConflicts = conflicts.length > 0;
+          if (this.hasAnyProviderToken(this.settings) && !hasConflicts) {
+            if (this.onStateHandler) {
+              logger.info("Auto-Resume beim Start aktiviert (nach Konflikt-Check)");
+              void this.manager.start().catch((err) => logger.warn(`Auto-Resume Start Fehler: ${String(err)}`));
+            } else {
+              this.autoResumePending = true;
+              logger.info("Auto-Resume beim Start vorgemerkt");
+            }
+          } else if (hasConflicts) {
+            logger.info("Auto-Resume übersprungen: Start-Konflikte erkannt");
+          }
+        }).catch((err) => logger.warn(`getStartConflicts Fehler (constructor): ${String(err)}`));
       }
     }
   }
@@ -243,27 +251,14 @@ export class AppController {
       handler(this.manager.getSnapshot());
       if (this.autoResumePending) {
         this.autoResumePending = false;
-        this.beginAutoResume();
+        void this.manager.start().catch((err) => logger.warn(`Auto-Resume Start Fehler: ${String(err)}`));
+        logger.info("Auto-Resume beim Start aktiviert");
       } else {
         this.manager.triggerIdleExtractions();
       }
     }
   }
 
-  private beginAutoResume(): void {
-    void this.manager.getStartConflicts().then((conflicts) => {
-      const excludePackageIds = new Set(conflicts.map((conflict) => conflict.packageId));
-      if (excludePackageIds.size > 0) {
-        const names = conflicts.map((conflict) => conflict.packageName).join(", ");
-        logger.info(`Auto-Resume: ${excludePackageIds.size} Paket(e) mit Start-Konflikt zurückgehalten (${names}); übrige Pakete starten`);
-      } else {
-        logger.info("Auto-Resume beim Start aktiviert (keine Start-Konflikte)");
-      }
-      void this.manager.start(excludePackageIds.size > 0 ? { excludePackageIds } : undefined)
-        .catch((err) => logger.warn(`Auto-Resume Start Fehler: ${String(err)}`));
-    }).catch((err) => logger.warn(`Auto-Resume Konflikt-Check Fehler: ${String(err)}`));
-  }
-
   public getSnapshot(): UiSnapshot {
     return this.manager.getSnapshot();
   }

src/main/debrid.ts

@@ -302,7 +302,7 @@ function getMegaDebridAbortMinRunMs(): number {
 }
 
 const megaDebridEmptyResponseStreaks = new Map<string, number>();
-export const MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART = 10;
+export const MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART = 3;
 
 let megaDebridRotationCursor = 0;
 let megaDebridStickyCount = 0;
@@ -339,25 +339,6 @@ export function resetMegaDebridRuntimeStateForTests(): void {
   megaDebridInFlight.clear();
 }
 
-export function getMegaDebridInFlightCountForMode(mode: "api" | "web"): number {
-  const suffix = `:${mode}`;
-  let total = 0;
-  for (const [key, count] of megaDebridInFlight) {
-    if (key.endsWith(suffix)) {
-      total += count;
-    }
-  }
-  return total;
-}
-
-export function primeMegaDebridInFlightForTests(key: string, count: number): void {
-  if (count <= 0) {
-    megaDebridInFlight.delete(key);
-    return;
-  }
-  megaDebridInFlight.set(key, count);
-}
-
 export function pruneExpiredMegaDebridRuntimeState(now = Date.now()): number {
   let removed = 0;
   const grace = 60 * 60 * 1000;
@@ -2254,7 +2235,7 @@ class MegaDebridClient {
           const streak = recordMegaDebridEmptyResponseStreak(cooldownKey);
           if (streak >= MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART) {
             parkUntilRestart = true;
-            parkMessage = `Tageslimit erreicht (${streak}x leere Antwort in Folge) — bis zum Tagesreset gesperrt`;
+            parkMessage = `Tageslimit erreicht (${streak}x kein Server/leere Antwort) — bis zum Tagesreset gesperrt`;
           }
         } else {
           clearMegaDebridEmptyResponseStreak(cooldownKey);

src/main/download-manager.ts

@@ -52,7 +52,7 @@ function releaseTlsSkip(): void {
 }
 import { cleanupCancelledPackageArtifactsAsync, removeDownloadLinkArtifacts, removeSampleArtifacts } from "./cleanup";
 import { planDownloadCompletion, reconcileFinalizedSize, validateDownloadedFileCompletion } from "./download-completion";
-import { AllDebridWebUnrestrictor, BestDebridWebUnrestrictor, DebridService, MegaWebUnrestrictor, RealDebridWebUnrestrictor, checkRapidgatorOnline, fetchAllDebridHostInfo, getAvailableDebridLinkApiKeys, getAvailableMegaDebridAccounts, getMegaDebridAccountCooldownState, getMegaDebridInFlightCountForMode, pruneExpiredDebridLinkRuntimeState, pruneExpiredMegaDebridRuntimeState } from "./debrid";
+import { AllDebridWebUnrestrictor, BestDebridWebUnrestrictor, DebridService, MegaWebUnrestrictor, RealDebridWebUnrestrictor, checkRapidgatorOnline, fetchAllDebridHostInfo, getAvailableDebridLinkApiKeys, getAvailableMegaDebridAccounts, getMegaDebridAccountCooldownState, pruneExpiredDebridLinkRuntimeState, pruneExpiredMegaDebridRuntimeState } from "./debrid";
 import { cleanupArchives, clearExtractResumeState, collectArchiveCleanupTargets, detectArchiveSignature, extractPackageArchives, findArchiveCandidates, hasAnyFilesRecursive, removeEmptyDirectoryTree, resetExtractorCachesForPasswordChange, type ExtractArchiveFailureInfo } from "./extractor";
 import { validateFileAgainstManifest } from "./integrity";
 import { classifyDiskError } from "./fs-error";
@@ -131,17 +131,6 @@ const ARCHIVE_SETTLE_MAX_WAIT_MS = 5000;
 
 const MAX_SAME_DIRECT_URL_ATTEMPTS = 3;
 
-const MAX_HTTP416_FRESH_RESTARTS = 2;
-const HTTP416_FRESH_RESTART_DELAY_MS = 8000;
-
-function getHttp416FreshRestartDelayMs(): number {
-  const fromEnv = Number(process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS ?? NaN);
-  if (Number.isFinite(fromEnv) && fromEnv >= 0 && fromEnv <= 600000) {
-    return Math.floor(fromEnv);
-  }
-  return HTTP416_FRESH_RESTART_DELAY_MS;
-}
-
 const RESUME_REWIND_BYTES = 256 * 1024;
 
 const REALDEBRID_TOTAL_MISMATCH_TOLERANCE_BYTES = 64 * 1024;
@@ -1840,8 +1829,6 @@ export class DownloadManager extends EventEmitter {
     unrestrictRetries: number;
   }>();
 
-  private http416FreshRestartByItem = new Map<string, number>();
-
   private providerFailures = new Map<string, { count: number; lastFailAt: number; cooldownUntil: number }>();
 
   private allDebridHostInfoCache = new Map<string, { info: AllDebridHostInfo; cachedAt: number }>();
@@ -3024,14 +3011,6 @@ export class DownloadManager extends EventEmitter {
         continue;
       }
 
-      const hasOwnCompletedOutput = pkg.itemIds.some((itemId) => {
-        const item = this.session.items[itemId];
-        return Boolean(item && item.status === "completed");
-      });
-      if (hasOwnCompletedOutput) {
-        continue;
-      }
-
       if (!this.isPackageSpecificExtractDir(pkg)) {
         continue;
       }
@@ -5583,7 +5562,7 @@ export class DownloadManager extends EventEmitter {
     });
   }
 
-  public async start(options?: { excludePackageIds?: ReadonlySet<string> }): Promise<void> {
+  public async start(): Promise<void> {
     if (this.session.running) {
       return;
     }
@@ -5624,9 +5603,6 @@ export class DownloadManager extends EventEmitter {
         if (item.status !== "queued" && item.status !== "reconnect_wait") {
           return false;
         }
-        if (options?.excludePackageIds?.has(item.packageId)) {
-          return false;
-        }
         const pkg = this.session.packages[item.packageId];
         return Boolean(pkg && !pkg.cancelled && pkg.enabled);
       });
@@ -5691,15 +5667,9 @@ export class DownloadManager extends EventEmitter {
     this.providerStartReservations.clear();
     this.pacedStartReservationByItem.clear();
     this.retryStateByItem.clear();
-    this.http416FreshRestartByItem.clear();
     this.itemContributedBytes.clear();
     this.reservedTargetPaths.clear();
     this.claimedTargetPathByItem.clear();
-    if (options?.excludePackageIds) {
-      for (const excluded of options.excludePackageIds) {
-        this.runPackageIds.delete(excluded);
-      }
-    }
 
     this.session.running = true;
     this.session.paused = false;
@@ -8226,13 +8196,7 @@ export class DownloadManager extends EventEmitter {
     const provider = resolveMegaDebridProvider(this.settings, this.getExpectedProviderForItem(item));
     const serializedValidatingLimit = this.getSerializedValidatingLimit(provider);
     if (provider && Number.isFinite(serializedValidatingLimit) && serializedValidatingLimit < Number.MAX_SAFE_INTEGER) {
-      const validating = this.getProviderValidatingTaskCount(provider, item.id);
-      if (provider === "megadebrid-api") {
-        const webInFlight = getMegaDebridInFlightCountForMode("web");
-        const overlapAllowance = Math.min(serializedValidatingLimit, webInFlight);
-        return validating >= serializedValidatingLimit + overlapAllowance;
-      }
-      return validating >= serializedValidatingLimit;
+      return this.getProviderValidatingTaskCount(provider, item.id) >= serializedValidatingLimit;
     }
     if (provider !== "alldebrid") {
       return false;
@@ -8741,53 +8705,6 @@ export class DownloadManager extends EventEmitter {
     this.queueRetry(item, active, delayMs, `HTTP 416 erkannt, Retry ${active.genericErrorRetries}/${retryDisplayLimit}`);
   }
 
-  private escalateHttp416OrFail(item: DownloadItem, active: ActiveTask, claimedTargetPath: string, errorText: string): void {
-    const freshRestarts = this.http416FreshRestartByItem.get(item.id) || 0;
-    if (freshRestarts < MAX_HTTP416_FRESH_RESTARTS) {
-      this.http416FreshRestartByItem.set(item.id, freshRestarts + 1);
-      const resetTargetPath = claimedTargetPath || String(item.targetPath || "").trim();
-      if (resetTargetPath) {
-        try {
-          fs.rmSync(resetTargetPath, { force: true });
-        } catch {
-        }
-      }
-      this.releaseTargetPath(item.id);
-      this.dropItemContribution(item.id);
-      item.retries += 1;
-      item.downloadedBytes = 0;
-      item.totalBytes = null;
-      item.progressPercent = 0;
-      item.speedBps = 0;
-      item.lastError = "";
-      active.genericErrorRetries = 0;
-      active.freshRetryUsed = false;
-      active.resumeHardResetUsed = false;
-      logger.warn(
-        `HTTP 416 Budget erschöpft: item=${item.fileName || item.id}, ` +
-        `kompletter Neu-Download ${freshRestarts + 1}/${MAX_HTTP416_FRESH_RESTARTS} (Partial verworfen, kein Resume), provider=${item.provider || "?"}`
-      );
-      this.queueRetry(item, active, getHttp416FreshRestartDelayMs(), `Range-Konflikt (HTTP 416): Neu-Download ${freshRestarts + 1}/${MAX_HTTP416_FRESH_RESTARTS}`);
-      this.persistSoon();
-      this.emitState();
-      return;
-    }
-    this.http416FreshRestartByItem.delete(item.id);
-    item.status = "failed";
-    this.recordRunOutcome(item.id, "failed");
-    item.lastError = errorText;
-    item.fullStatus = `Fehler: ${item.lastError}`;
-    item.speedBps = 0;
-    item.updatedAt = nowMs();
-    const failPkg = this.session.packages[item.packageId];
-    if (failPkg) {
-      this.refreshPackageStatus(failPkg);
-    }
-    this.persistSoon();
-    this.emitState();
-    this.retryStateByItem.delete(item.id);
-  }
-
   private startItem(packageId: string, itemId: string): void {
     const item = this.session.items[itemId];
     const pkg = this.session.packages[packageId];
@@ -9378,14 +9295,10 @@ export class DownloadManager extends EventEmitter {
                 return;
               }
             }
-            if (isHttp416Text(exhaustedReason)) {
-              if (active.genericErrorRetries < maxHttp416Retries) {
-                this.scheduleHttp416Retry(item, active, retryDisplayLimit, exhaustedReason, claimedTargetPath);
-                this.persistSoon();
-                this.emitState();
-                return;
-              }
-              this.escalateHttp416OrFail(item, active, claimedTargetPath, exhaustedReason);
+            if (isHttp416Text(exhaustedReason) && active.genericErrorRetries < maxHttp416Retries) {
+              this.scheduleHttp416Retry(item, active, retryDisplayLimit, exhaustedReason, claimedTargetPath);
+              this.persistSoon();
+              this.emitState();
               return;
             }
             if (isResumeHardResetReason(exhaustedReason) && !active.resumeHardResetUsed) {
@@ -9442,7 +9355,17 @@ export class DownloadManager extends EventEmitter {
               this.emitState();
               return;
             }
-            this.escalateHttp416OrFail(item, active, claimedTargetPath, errorText);
+            item.status = "failed";
+            this.recordRunOutcome(item.id, "failed");
+            item.lastError = errorText;
+            item.fullStatus = `Fehler: ${item.lastError}`;
+            item.speedBps = 0;
+            item.updatedAt = nowMs();
+            const failPkg416 = this.session.packages[item.packageId];
+            if (failPkg416) this.refreshPackageStatus(failPkg416);
+            this.persistSoon();
+            this.emitState();
+            this.retryStateByItem.delete(item.id);
             return;
           }
           if (shouldFreshRetry) {

src/main/main.ts

@@ -571,7 +571,7 @@ function registerIpcHandlers(): void {
 
   ipcMain.handle(IPC_CHANNELS.EXPORT_BACKUP, async () => {
     const options = {
-      defaultPath: `${new Date().toISOString().slice(0, 10).split("-").reverse().join("-")}-mdd-backup.mdd`,
+      defaultPath: `mdd-backup-${new Date().toISOString().slice(0, 10)}.mdd`,
       filters: [{ name: "MDD Backup", extensions: ["mdd"] }]
     };
     const result = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);

tests/debrid.test.ts

@@ -2140,7 +2140,7 @@ describe("debrid service", () => {
 
   it("escalates a Mega-Debrid account to 'until restart' after the empty-response streak threshold", () => {
     const key = `${getMegaDebridAccountId("user1")}:web`;
-    expect(MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART).toBe(10);
+    expect(MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART).toBe(3);
     expect(recordMegaDebridEmptyResponseStreak(key)).toBe(1);
     expect(recordMegaDebridEmptyResponseStreak(key)).toBe(2);
     expect(recordMegaDebridEmptyResponseStreak(key)).toBe(3);
@@ -2265,9 +2265,8 @@ describe("debrid service", () => {
     globalThis.fetch = (async () => new Response("error", { status: 500 })) as typeof fetch;
 
     const key = `${getMegaDebridAccountId("user1")}:web`;
-    for (let i = 0; i < MEGA_DEBRID_EMPTY_STREAK_UNTIL_RESTART - 1; i += 1) {
-      recordMegaDebridEmptyResponseStreak(key);
-    }
+    recordMegaDebridEmptyResponseStreak(key);
+    recordMegaDebridEmptyResponseStreak(key);
     expect(getMegaDebridAccountCooldownState(key)?.untilRestart ?? false).toBe(false);
 
     const megaWeb = vi.fn(async () => null);

tests/download-manager.test.ts

@@ -14,7 +14,7 @@ import { getProviderUsageDayKey } from "../src/shared/provider-daily-limits";
 import { getItemLogPath, initItemLogs, shutdownItemLogs } from "../src/main/item-log";
 import { initPackageLogs, shutdownPackageLogs } from "../src/main/package-log";
 import { createStoragePaths, emptySession } from "../src/main/storage";
-import { primeDebridLinkRuntimeCooldownForTests, resetDebridLinkRuntimeStateForTests, primeMegaDebridRuntimeCooldownForTests, resetMegaDebridRuntimeStateForTests, primeMegaDebridInFlightForTests } from "../src/main/debrid";
+import { primeDebridLinkRuntimeCooldownForTests, resetDebridLinkRuntimeStateForTests, primeMegaDebridRuntimeCooldownForTests, resetMegaDebridRuntimeStateForTests } from "../src/main/debrid";
 import { getMegaDebridAccountId } from "../src/shared/mega-debrid-accounts";
 import { getRenameLogPath, initRenameLog, shutdownRenameLog } from "../src/main/rename-log";
 import { UnrestrictedLink } from "../src/main/realdebrid";
@@ -2209,98 +2209,6 @@ describe("download manager", () => {
     expect(fs.statSync(item.targetPath).size).toBe(binary.length);
   });
 
-  it("recovers an HTTP 416 item with a clean fresh restart after the in-budget retries are exhausted", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-416-fresh-"));
-    tempDirs.push(root);
-    const binary = Buffer.alloc(160 * 1024, 19);
-    const prevDelay = process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS;
-    process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS = "0";
-    let downloadCalls = 0;
-
-    globalThis.fetch = async (input: RequestInfo | URL): Promise<Response> => {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      if (url.includes("/unrestrict/link")) {
-        return new Response(JSON.stringify({ download: "https://dummy/direct-416-recover", filename: "fresh-416.mkv", filesize: binary.length }), { status: 200, headers: { "Content-Type": "application/json" } });
-      }
-      throw new Error(`unexpected fetch ${url}`);
-    };
-
-    try {
-      const manager = new DownloadManager(
-        { ...defaultSettings(), token: "rd-token", outputDir: path.join(root, "downloads"), extractDir: path.join(root, "extract"), retryLimit: 2, autoExtract: false, autoReconnect: false },
-        emptySession(),
-        createStoragePaths(path.join(root, "state"))
-      );
-
-      (manager as any).downloadToFile = async (_active: unknown, _directUrl: string, targetPath: string) => {
-        downloadCalls += 1;
-        if (downloadCalls <= 3) {
-          throw new Error("HTTP 416");
-        }
-        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-        fs.writeFileSync(targetPath, binary);
-        const item = Object.values((manager as any).session.items)[0] as { downloadedBytes: number; totalBytes: number; progressPercent: number } | undefined;
-        if (item) {
-          item.downloadedBytes = binary.length;
-          item.totalBytes = binary.length;
-          item.progressPercent = 100;
-        }
-        return { resumable: true };
-      };
-
-      manager.addPackages([{ name: "fresh-416", links: ["https://dummy/fresh-416"] }]);
-      await manager.start();
-      await waitFor(() => !manager.getSnapshot().session.running, 20000);
-
-      const item = Object.values(manager.getSnapshot().session.items)[0];
-      expect(item?.status).toBe("completed");
-      expect(downloadCalls).toBeGreaterThan(3);
-    } finally {
-      if (prevDelay === undefined) { delete process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS; } else { process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS = prevDelay; }
-    }
-  }, 25000);
-
-  it("bounds HTTP 416 clean restarts and finally fails instead of looping forever or stalling permanently", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-416-cap-"));
-    tempDirs.push(root);
-    const prevDelay = process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS;
-    process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS = "0";
-    let downloadCalls = 0;
-
-    globalThis.fetch = async (input: RequestInfo | URL): Promise<Response> => {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      if (url.includes("/unrestrict/link")) {
-        return new Response(JSON.stringify({ download: "https://dummy/direct-416-forever", filename: "always-416.mkv", filesize: 1024 }), { status: 200, headers: { "Content-Type": "application/json" } });
-      }
-      throw new Error(`unexpected fetch ${url}`);
-    };
-
-    try {
-      const manager = new DownloadManager(
-        { ...defaultSettings(), token: "rd-token", outputDir: path.join(root, "downloads"), extractDir: path.join(root, "extract"), retryLimit: 0, autoExtract: false, autoReconnect: false },
-        emptySession(),
-        createStoragePaths(path.join(root, "state"))
-      );
-
-      (manager as any).downloadToFile = async () => {
-        downloadCalls += 1;
-        throw new Error("direct_link_retry_exhausted:HTTP 416");
-      };
-
-      manager.addPackages([{ name: "always-416", links: ["https://dummy/always-416"] }]);
-      await manager.start();
-      await waitFor(() => !manager.getSnapshot().session.running, 20000);
-
-      const item = Object.values(manager.getSnapshot().session.items)[0];
-      expect(item?.status).toBe("failed");
-      expect(downloadCalls).toBeGreaterThan(4);
-      expect(downloadCalls).toBeLessThan(30);
-      expect((manager as any).http416FreshRestartByItem.get(item.id)).toBeUndefined();
-    } finally {
-      if (prevDelay === undefined) { delete process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS; } else { process.env.RD_HTTP416_FRESH_RESTART_DELAY_MS = prevDelay; }
-    }
-  }, 25000);
-
   it("retries HTTP 416 in-session when using Debrid-Link API and then completes", async () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
     tempDirs.push(root);
@@ -12336,200 +12244,3 @@ describe("download manager", () => {
     }
   });
 });
-
-describe("start conflict guard + selective resume", () => {
-  function makeItem(id: string, packageId: string, status: string, fileName: string): any {
-    return {
-      id, packageId, url: `https://hoster.example/${id}`, provider: "realdebrid",
-      status, retries: 0, speedBps: 0, downloadedBytes: status === "completed" ? 100 : 0,
-      totalBytes: status === "completed" ? 100 : null, progressPercent: status === "completed" ? 100 : 0,
-      fileName, targetPath: "", resumable: true, attempts: 0, lastError: "", fullStatus: "",
-      createdAt: Date.now(), updatedAt: Date.now()
-    };
-  }
-
-  it("does not flag a partially-downloaded package whose extract dir holds its own completed output", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-startconflict-own-"));
-    tempDirs.push(root);
-    const storagePaths = createStoragePaths(path.join(root, "state"));
-    initPackageLogs(storagePaths.baseDir);
-    initItemLogs(storagePaths.baseDir);
-
-    const session = emptySession();
-    const packageId = "pkg-own-output";
-    const extractDir = path.join(root, "extract", "OwnOutput");
-    fs.mkdirSync(extractDir, { recursive: true });
-    fs.writeFileSync(path.join(extractDir, "episode01.mkv"), Buffer.alloc(64, 7));
-    session.packageOrder = [packageId];
-    session.packages[packageId] = {
-      id: packageId, name: "OwnOutput",
-      outputDir: path.join(root, "downloads", "OwnOutput"), extractDir,
-      status: "queued", itemIds: ["own-done", "own-pending"], cancelled: false, enabled: true,
-      createdAt: Date.now(), updatedAt: Date.now()
-    } as any;
-    session.items["own-done"] = makeItem("own-done", packageId, "completed", "done.rar");
-    session.items["own-pending"] = makeItem("own-pending", packageId, "queued", "pending.rar");
-
-    const manager = new DownloadManager(
-      { ...defaultSettings(), token: "rd-token", outputDir: path.join(root, "downloads"), extractDir: path.join(root, "extract") },
-      session, storagePaths
-    );
-
-    const conflicts = await manager.getStartConflicts();
-    expect(conflicts.map((c) => c.packageId)).not.toContain(packageId);
-  });
-
-  it("flags a fresh package when its package-specific extract dir already holds files and it has no completed items", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-startconflict-fresh-"));
-    tempDirs.push(root);
-    const storagePaths = createStoragePaths(path.join(root, "state"));
-    initPackageLogs(storagePaths.baseDir);
-    initItemLogs(storagePaths.baseDir);
-
-    const session = emptySession();
-    const packageId = "pkg-fresh-conflict";
-    const extractDir = path.join(root, "extract", "FreshConflict");
-    fs.mkdirSync(extractDir, { recursive: true });
-    fs.writeFileSync(path.join(extractDir, "old-from-previous-run.mkv"), Buffer.alloc(64, 9));
-    session.packageOrder = [packageId];
-    session.packages[packageId] = {
-      id: packageId, name: "FreshConflict",
-      outputDir: path.join(root, "downloads", "FreshConflict"), extractDir,
-      status: "queued", itemIds: ["fresh-pending"], cancelled: false, enabled: true,
-      createdAt: Date.now(), updatedAt: Date.now()
-    } as any;
-    session.items["fresh-pending"] = makeItem("fresh-pending", packageId, "queued", "fresh.rar");
-
-    const manager = new DownloadManager(
-      { ...defaultSettings(), token: "rd-token", outputDir: path.join(root, "downloads"), extractDir: path.join(root, "extract") },
-      session, storagePaths
-    );
-
-    const conflicts = await manager.getStartConflicts();
-    expect(conflicts.map((c) => c.packageId)).toContain(packageId);
-  });
-
-  it("start() holds excluded packages out of the run set and runs the rest", async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-selective-resume-"));
-    tempDirs.push(root);
-    const storagePaths = createStoragePaths(path.join(root, "state"));
-    initPackageLogs(storagePaths.baseDir);
-    initItemLogs(storagePaths.baseDir);
-
-    const session = emptySession();
-    const runId = "pkg-run";
-    const holdId = "pkg-hold";
-    fs.mkdirSync(path.join(root, "downloads", "RunMe"), { recursive: true });
-    fs.mkdirSync(path.join(root, "downloads", "HoldMe"), { recursive: true });
-    session.packageOrder = [runId, holdId];
-    session.packages[runId] = {
-      id: runId, name: "RunMe",
-      outputDir: path.join(root, "downloads", "RunMe"), extractDir: path.join(root, "extract", "RunMe"),
-      status: "queued", itemIds: ["run-item"], cancelled: false, enabled: true,
-      createdAt: Date.now(), updatedAt: Date.now()
-    } as any;
-    session.packages[holdId] = {
-      id: holdId, name: "HoldMe",
-      outputDir: path.join(root, "downloads", "HoldMe"), extractDir: path.join(root, "extract", "HoldMe"),
-      status: "queued", itemIds: ["hold-item"], cancelled: false, enabled: true,
-      createdAt: Date.now(), updatedAt: Date.now()
-    } as any;
-    session.items["run-item"] = makeItem("run-item", runId, "queued", "run.rar");
-    session.items["hold-item"] = makeItem("hold-item", holdId, "queued", "hold.rar");
-
-    const manager = new DownloadManager(
-      { ...defaultSettings(), token: "rd-token", maxParallel: 2, outputDir: path.join(root, "downloads"), extractDir: path.join(root, "extract") },
-      session, storagePaths
-    );
-    (manager as any).debridService.unrestrictLink = () => new Promise(() => {});
-
-    await manager.start({ excludePackageIds: new Set([holdId]) });
-
-    expect((manager as any).runPackageIds.has(runId)).toBe(true);
-    expect((manager as any).runPackageIds.has(holdId)).toBe(false);
-    expect((manager as any).runItemIds.has("run-item")).toBe(true);
-    expect((manager as any).runItemIds.has("hold-item")).toBe(false);
-    expect(session.items["hold-item"].status).toBe("queued");
-
-    manager.stop();
-  });
-});
-
-describe("mega-debrid api/web resolution overlap gate", () => {
-  function megaApiSettings(root: string): any {
-    return {
-      ...defaultSettings(),
-      megaLogin: "u", megaPassword: "p", megaCredentials: "u:p",
-      megaDebridApiEnabled: true, megaDebridWebEnabled: true, megaDebridPreferApi: true,
-      outputDir: path.join(root, "downloads"), extractDir: path.join(root, "extract")
-    };
-  }
-
-  function megaItem(id: string, status: string): any {
-    return {
-      id, packageId: "pkg", url: `https://rapidgator.net/file/${id}`, provider: "megadebrid-api",
-      status, retries: 0, speedBps: 0, downloadedBytes: 0, totalBytes: null, progressPercent: 0,
-      fileName: `${id}.rar`, targetPath: "", resumable: true, attempts: 0, lastError: "", fullStatus: "",
-      createdAt: Date.now(), updatedAt: Date.now()
-    };
-  }
-
-  function addValidating(manager: DownloadManager, session: any, ids: string[]): void {
-    for (const id of ids) {
-      session.items[id] = megaItem(id, "validating");
-      (manager as any).activeTasks.set(id, {
-        itemId: id, packageId: "pkg", abortController: new AbortController(), abortReason: "none",
-        resumable: true, nonResumableCounted: false, blockedOnDiskWrite: false, blockedOnDiskSince: 0
-      });
-    }
-  }
-
-  function buildManager(root: string, session: any): DownloadManager {
-    return new DownloadManager(megaApiSettings(root), session, createStoragePaths(path.join(root, "state")));
-  }
-
-  it("lets the first mega resolve start when nothing is in flight", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-overlap-0-"));
-    tempDirs.push(root);
-    const session = emptySession();
-    const candidate = megaItem("cand", "queued");
-    session.items["cand"] = candidate;
-    const manager = buildManager(root, session);
-    expect((manager as any).shouldDelayStartForItem(candidate)).toBe(false);
-  });
-
-  it("serializes a second API resolve while the first is still in its API phase (no concurrent API)", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-overlap-1-"));
-    tempDirs.push(root);
-    const session = emptySession();
-    const candidate = megaItem("cand", "queued");
-    session.items["cand"] = candidate;
-    const manager = buildManager(root, session);
-    addValidating(manager, session, ["a"]);
-    expect((manager as any).shouldDelayStartForItem(candidate)).toBe(true);
-  });
-
-  it("allows one API resolve to overlap once the first has moved to its web phase", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-overlap-2-"));
-    tempDirs.push(root);
-    const session = emptySession();
-    const candidate = megaItem("cand", "queued");
-    session.items["cand"] = candidate;
-    const manager = buildManager(root, session);
-    addValidating(manager, session, ["a"]);
-    primeMegaDebridInFlightForTests("acc:web", 1);
-    expect((manager as any).shouldDelayStartForItem(candidate)).toBe(false);
-  });
-
-  it("caps the overlap at one API plus one web (no third concurrent resolve)", () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-overlap-3-"));
-    tempDirs.push(root);
-    const session = emptySession();
-    const candidate = megaItem("cand", "queued");
-    session.items["cand"] = candidate;
-    const manager = buildManager(root, session);
-    addValidating(manager, session, ["a", "b"]);
-    primeMegaDebridInFlightForTests("acc:web", 1);
-    expect((manager as any).shouldDelayStartForItem(candidate)).toBe(true);
-  });
-});