lib/upload-manager.js

@@ -132,12 +132,6 @@ class UploadManager extends EventEmitter {
     this.globalSemaphore = null;
     this.globalThrottle = null;
     this.lastStartTime = {};
-    // Reset account-rotation state each batch. Otherwise a previously failed
-    // account (e.g. rate-limited during the last batch) stays permanently
-    // blacklisted until the app restarts — every upload would silently skip
-    // straight to the fallback even after the original recovered.
-    this._failedAccounts.clear();
-    this._accountOverrides.clear();
 
     const { signal } = this.abortController;
     const batchId = `batch-${Date.now()}`;
@@ -467,85 +461,79 @@ class UploadManager extends EventEmitter {
         return;
       }
 
-      // Account rotation: mark the current account failed, wait for main to
-      // resolve the next fallback, then retry. Loop so A → B → C → ... works
-      // for hosters with 3+ accounts (the old code only did one level: A → B
-      // and stopped, even if C would have worked).
-      while (task.accountId && !this._failedAccounts.has(task.hoster + ':' + task.accountId)) {
-        if (signal.aborted || this.stopAfterActive) break;
+      // Account fallback: if this account hasn't failed before, try switching
+      if (task.accountId && !this._failedAccounts.has(task.hoster + ':' + task.accountId)) {
         this._failedAccounts.set(task.hoster + ':' + task.accountId, true);
         this.emit('account-failed', { hoster: task.hoster, accountId: task.accountId });
+        // Wait briefly for switchAccount() to be called from main process
         await this._sleep(800, signal);
         const override = this._accountOverrides.get(task.hoster);
-        if (!override || this._failedAccounts.has(task.hoster + ':' + override.id)) break;
-        // Switch to fallback account and retry this file
-        task.accountId = override.id;
-        task.username = override.username;
-        task.password = override.password;
-        task.apiKey = override.apiKey;
-        this._emitProgress(uploadId, fileName, task.hoster, {
-          jobId, status: 'retrying', progress: 0, bytesUploaded: 0, bytesTotal: fileSize,
-          speedKbs: 0, elapsed: 0, remaining: 0,
-          error: 'Account-Wechsel zu Fallback', result: null, attempt: 1, maxAttempts
-        });
-        // Retry loop with the new account. On exhausted failure, the while
-        // loop iterates: marks this account failed too, asks main for the next
-        // fallback, and so on.
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-          if (signal.aborted || this.stopAfterActive) break;
-          if (attempt > 1) {
-            this._emitProgress(uploadId, fileName, task.hoster, {
-              jobId, status: 'retrying', progress: 0, bytesUploaded: 0, bytesTotal: fileSize,
-              speedKbs: 0, elapsed: 0, remaining: 0,
-              error: lastError ? lastError.message : '', result: null, attempt, maxAttempts
-            });
-            await this._sleep(3000, signal);
-          }
-          try {
-            const jobStart = Date.now();
-            let lastBytes = 0;
-            let lastSpeedTime = jobStart;
-            let currentSpeedKbs = 0;
-            const activeEntry = { jobId, speedKbs: 0, bytesUploaded: 0 };
-            this.activeJobs.set(uploadId, activeEntry);
-
-            const progressCb = (bytesUploaded, bytesTotal) => {
-              const now = Date.now();
-              const timeDelta = (now - lastSpeedTime) / 1000;
-              if (timeDelta >= 1) {
-                currentSpeedKbs = Math.round((bytesUploaded - lastBytes) / timeDelta / 1024);
-                lastBytes = bytesUploaded;
-                lastSpeedTime = now;
-              }
-              activeEntry.speedKbs = currentSpeedKbs;
-              activeEntry.bytesUploaded = bytesUploaded;
-              const elapsed = Math.round((now - jobStart) / 1000);
-              const remaining = currentSpeedKbs > 0 ? Math.round((bytesTotal - bytesUploaded) / (currentSpeedKbs * 1024)) : 0;
-              this._emitProgress(uploadId, fileName, task.hoster, {
-                jobId, status: 'uploading',
-                progress: bytesTotal > 0 ? Math.min(1, bytesUploaded / bytesTotal) : 0,
-                bytesUploaded, bytesTotal, speedKbs: currentSpeedKbs,
-                elapsed, remaining, error: null, result: null, attempt, maxAttempts
-              });
-            };
-
-            const hosterThrottle = settings.maxSpeedKbs > 0 ? new Throttle(settings.maxSpeedKbs * 1024) : null;
-            const globalThrottle = this._getGlobalThrottle();
-            const throttle = hosterThrottle && globalThrottle
-              ? { consume: async (bytes, sig) => { await hosterThrottle.consume(bytes, sig); await globalThrottle.consume(bytes, sig); } }
-              : hosterThrottle || globalThrottle;
-
-            const result = await this._executeUpload(task, progressCb, signal, throttle);
-            this.activeJobs.delete(uploadId);
-            this.sessionBytes += fileSize;
-            emitFinalStatus('done', { result, speedKbs: currentSpeedKbs, elapsed: Math.round((Date.now() - jobStart) / 1000), attempt });
-            recordFinalResult('done', { result });
-            return;
-          } catch (err) {
-            this.activeJobs.delete(uploadId);
-            lastError = err;
+        if (override && !this._failedAccounts.has(task.hoster + ':' + override.id)) {
+          // Switch to fallback account and retry this file
+          task.accountId = override.id;
+          task.username = override.username;
+          task.password = override.password;
+          task.apiKey = override.apiKey;
+          this._emitProgress(uploadId, fileName, task.hoster, {
+            jobId, status: 'retrying', progress: 0, bytesUploaded: 0, bytesTotal: fileSize,
+            speedKbs: 0, elapsed: 0, remaining: 0,
+            error: 'Account-Wechsel zu Fallback', result: null, attempt: 1, maxAttempts
+          });
+          // Re-run retry loop with new account
+          for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             if (signal.aborted || this.stopAfterActive) break;
-            if (attempt >= maxAttempts) break;
+            if (attempt > 1) {
+              this._emitProgress(uploadId, fileName, task.hoster, {
+                jobId, status: 'retrying', progress: 0, bytesUploaded: 0, bytesTotal: fileSize,
+                speedKbs: 0, elapsed: 0, remaining: 0,
+                error: lastError ? lastError.message : '', result: null, attempt, maxAttempts
+              });
+              await this._sleep(3000, signal);
+            }
+            try {
+              const jobStart = Date.now();
+              let lastBytes = 0;
+              let lastSpeedTime = jobStart;
+              let currentSpeedKbs = 0;
+              this.activeJobs.set(uploadId, { jobId, speedKbs: 0, bytesUploaded: 0 });
+
+              const progressCb = (bytesUploaded, bytesTotal) => {
+                const now = Date.now();
+                const timeDelta = (now - lastSpeedTime) / 1000;
+                if (timeDelta >= 1) {
+                  currentSpeedKbs = Math.round((bytesUploaded - lastBytes) / timeDelta / 1024);
+                  lastBytes = bytesUploaded;
+                  lastSpeedTime = now;
+                }
+                this.activeJobs.set(uploadId, { jobId, speedKbs: currentSpeedKbs, bytesUploaded });
+                const elapsed = Math.round((now - jobStart) / 1000);
+                const remaining = currentSpeedKbs > 0 ? Math.round((bytesTotal - bytesUploaded) / (currentSpeedKbs * 1024)) : 0;
+                this._emitProgress(uploadId, fileName, task.hoster, {
+                  jobId, status: 'uploading',
+                  progress: bytesTotal > 0 ? Math.min(1, bytesUploaded / bytesTotal) : 0,
+                  bytesUploaded, bytesTotal, speedKbs: currentSpeedKbs,
+                  elapsed, remaining, error: null, result: null, attempt, maxAttempts
+                });
+              };
+
+              const hosterThrottle = settings.maxSpeedKbs > 0 ? new Throttle(settings.maxSpeedKbs * 1024) : null;
+              const globalThrottle = this._getGlobalThrottle();
+              const throttle = hosterThrottle && globalThrottle
+                ? { consume: async (bytes, sig) => { await hosterThrottle.consume(bytes, sig); await globalThrottle.consume(bytes, sig); } }
+                : hosterThrottle || globalThrottle;
+
+              const result = await this._executeUpload(task, progressCb, signal, throttle);
+              this.activeJobs.delete(uploadId);
+              this.sessionBytes += fileSize;
+              emitFinalStatus('done', { result, speedKbs: currentSpeedKbs, elapsed: Math.round((Date.now() - jobStart) / 1000), attempt });
+              recordFinalResult('done', { result });
+              return;
+            } catch (err) {
+              this.activeJobs.delete(uploadId);
+              lastError = err;
+              if (signal.aborted || this.stopAfterActive) break;
+              if (attempt >= maxAttempts) break;
+            }
           }
         }
       }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-hoster-uploader",
-  "version": "2.9.1",
+  "version": "2.9.0",
   "description": "Upload files to doodstream, voe, vidmoly, byse simultaneously",
   "main": "main.js",
   "scripts": {

renderer/app.js

@@ -1062,13 +1062,13 @@ function _onQueueScroll() {
 const _collatorDE = new Intl.Collator('de', { sensitivity: 'base', numeric: true });
 const _collatorSimple = new Intl.Collator('de');
 
-// Queue sort memoization. Keys that don't change after a job enters the queue
-// (filename, host) reuse the cached result across progress-driven re-renders.
-// Dynamic keys (status/speed/progress) AND size (which goes 0 → actual when
-// previews resolve / upload starts) are recomputed each call — otherwise a
-// queue sorted by size during previews would be stuck in all-zeros order.
+// Queue sort memoization. Keys that don't change during upload (filename, host,
+// size) reuse the cached result across progress-driven re-renders. Dynamic keys
+// (status/speed/progress) are recomputed each call since the sort order itself
+// moves every tick. For a queue of 1000+ jobs sorted by filename, this skips
+// the Collator-based O(n log n) sort on every 200ms progress render.
 let _queueSortCache = { sig: '', result: [] };
-const _STATIC_SORT_KEYS = new Set(['filename', 'host']);
+const _STATIC_SORT_KEYS = new Set(['filename', 'host', 'size']);
 
 function sortQueueJobs(jobs) {
   const { key, direction } = queueSortState;