release: v3.3.54

fix(critical): safeSend infinite recursion + queueMicrotask, plus 6 audit findings
release: v3.3.53
2026-06-08 22:03:41 +02:00 · 2026-06-08 22:03:19 +02:00 · 2026-06-08 21:28:34 +02:00 · 2026-06-08 21:28:12 +02:00 · 2026-06-08 21:19:19 +02:00 · 2026-06-08 21:18:54 +02:00
18 changed files with 1658 additions and 246 deletions
--- a/lib/config-store.js
+++ b/lib/config-store.js
@ -58,6 +58,7 @@ const DEFAULTS = {
    shutdownAfterFinish: 'nothing', // nothing | sleep | shutdown | restart
    logFilePath: '',
    sessionLog: false,                  // legacy boolean (kept for back-compat reads); normalized into logMode on load
    logVerbose: false,                  // when true, [DEBUG] level entries are written to debug.log
    // NOTE: logMode is intentionally NOT in DEFAULTS. If it were, the deep-merge
    // would seed logMode='single' for every load, which would beat (and silently
    // erase) the legacy sessionLog:true → "daily" migration. normalizeLogMode in
@ -276,7 +277,12 @@ class ConfigStore {
            if (fs.existsSync(this.filePath)) {
              const existing = fs.readFileSync(this.filePath, 'utf-8');
              if (existing && existing.trim().length > 2) {
-                fs.writeFileSync(backupPath, existing, 'utf-8');
+                let isValid = false;
                try {
                  const parsed = JSON.parse(existing);
                  isValid = parsed && typeof parsed === 'object' && (parsed.hosters || parsed.hosterSettings || parsed.globalSettings);
                } catch {}
                if (isValid) fs.writeFileSync(backupPath, existing, 'utf-8');
              }
            }
          } catch {}
--- a/lib/file-probe.js
+++ b/lib/file-probe.js
@ -0,0 +1,73 @@
 const fs = require('fs');
 const SIGNATURES = [
  { kind: 'mp4-iso', test: (b) => b.length >= 12 && b.slice(4, 8).toString('ascii') === 'ftyp' },
  { kind: 'matroska', test: (b) => b.length >= 4 && b[0] === 0x1A && b[1] === 0x45 && b[2] === 0xDF && b[3] === 0xA3 },
  { kind: 'avi', test: (b) => b.length >= 12 && b.slice(0, 4).toString('ascii') === 'RIFF' && b.slice(8, 12).toString('ascii') === 'AVI ' },
  { kind: 'wav', test: (b) => b.length >= 12 && b.slice(0, 4).toString('ascii') === 'RIFF' && b.slice(8, 12).toString('ascii') === 'WAVE' },
  { kind: 'flv', test: (b) => b.length >= 3 && b.slice(0, 3).toString('ascii') === 'FLV' },
  { kind: 'asf-wmv', test: (b) => b.length >= 4 && b[0] === 0x30 && b[1] === 0x26 && b[2] === 0xB2 && b[3] === 0x75 },
  { kind: 'mpeg-ps', test: (b) => b.length >= 4 && b[0] === 0x00 && b[1] === 0x00 && b[2] === 0x01 && (b[3] === 0xBA || b[3] === 0xB3) },
  { kind: 'mpeg-ts', test: (b) => b.length >= 1 && b[0] === 0x47 },
  { kind: 'mp3', test: (b) => b.length >= 3 && (b.slice(0, 3).toString('ascii') === 'ID3' || (b[0] === 0xFF && (b[1] & 0xE0) === 0xE0)) },
  { kind: 'ogg', test: (b) => b.length >= 4 && b.slice(0, 4).toString('ascii') === 'OggS' },
  { kind: 'jpeg', test: (b) => b.length >= 3 && b[0] === 0xFF && b[1] === 0xD8 && b[2] === 0xFF },
  { kind: 'png', test: (b) => b.length >= 8 && b[0] === 0x89 && b.slice(1, 4).toString('ascii') === 'PNG' },
  { kind: 'pdf', test: (b) => b.length >= 5 && b.slice(0, 5).toString('ascii') === '%PDF-' },
  { kind: 'zip', test: (b) => b.length >= 4 && b[0] === 0x50 && b[1] === 0x4B && (b[2] === 0x03 || b[2] === 0x05 || b[2] === 0x07) },
  { kind: 'html', test: (b) => {
    const s = b.toString('ascii', 0, Math.min(b.length, 64)).trimStart().toLowerCase();
    return s.startsWith('<!doctype html') || s.startsWith('<html');
  } }
 ];
 const VIDEO_KINDS = new Set(['mp4-iso', 'matroska', 'avi', 'flv', 'asf-wmv', 'mpeg-ps', 'mpeg-ts']);
 function detectKind(buf) {
  if (!buf || buf.length === 0) return 'empty';
  for (const sig of SIGNATURES) {
    try { if (sig.test(buf)) return sig.kind; } catch { /* ignore malformed buffer slice */ }
  }
  return 'unknown';
 }
 function isVideoLikeKind(kind) {
  return VIDEO_KINDS.has(kind);
 }
 function probeFileHead(filePath, bytes) {
  const want = Number.isFinite(bytes) && bytes > 0 ? bytes : 64;
  return new Promise((resolve) => {
    fs.open(filePath, 'r', (err, fd) => {
      if (err) return resolve({ ok: false, error: err.message, kind: 'unreadable' });
      const buf = Buffer.alloc(want);
      fs.read(fd, buf, 0, want, 0, (rerr, bytesRead) => {
        fs.close(fd, () => {});
        if (rerr) return resolve({ ok: false, error: rerr.message, kind: 'unreadable' });
        const slice = buf.slice(0, bytesRead);
        resolve({
          ok: true,
          bytesRead,
          kind: detectKind(slice),
          isVideoLike: isVideoLikeKind(detectKind(slice)),
          headHex: slice.toString('hex')
        });
      });
    });
  });
 }
 function summarizeFileStat(filePath) {
  try {
    const st = fs.statSync(filePath);
    return {
      size: st.size,
      mtime: st.mtime.toISOString(),
      isFile: st.isFile()
    };
  } catch (err) {
    return { error: err.message };
  }
 }
 module.exports = { detectKind, isVideoLikeKind, probeFileHead, summarizeFileStat, VIDEO_KINDS, SIGNATURES };
--- a/lib/hosters.js
+++ b/lib/hosters.js
@ -499,25 +499,28 @@ async function _resolveDoodstreamUploadByName(apiKey, fileName, baselineCodes, s
  return null;
 }
-async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, throttle) {
+async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, throttle, opts) {
  const config = HOSTER_CONFIGS[hosterName];
  if (!config) throw new Error(`Unbekannter Hoster: ${hosterName}`);
  // For byse: snapshot the current file-code list so the post-upload poller
  // can identify new arrivals even when the initial POST response has an
  // empty filecode.
  let byseBaseline = null;
  if (hosterName === 'byse.sx') {
    if (opts && opts.byseBaseline instanceof Set) {
      byseBaseline = opts.byseBaseline;
    } else {
      const baseline = await _fetchByseFileList(apiKey, signal);
      byseBaseline = new Set(baseline.map(f => f.file_code));
    }
-  // Doodstream: same snapshot so a codeless upload response can be recovered by
+  }
  // matching a newly-appeared file in the account by name (see below).
  let doodBaseline = null;
  if (hosterName === 'doodstream.com') {
    if (opts && opts.doodBaseline instanceof Set) {
      doodBaseline = opts.doodBaseline;
    } else {
      const baseline = await _fetchDoodstreamFileList(apiKey, signal);
      doodBaseline = new Set(baseline.map(f => f.file_code));
    }
  }
  // Step 1: Get upload server
  const uploadUrl = await getUploadServer(hosterName, config, apiKey, signal);
@ -580,6 +583,17 @@ async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, thro
  try {
    result = config.parseResult(payload);
  } catch (err) {
    if (err && typeof err === 'object' && !err.diagnostic) {
      try {
        err.diagnostic = {
          hoster: hosterName,
          http: statusCode,
          contentType: (headers && headers['content-type']) || null,
          payloadSnippet: JSON.stringify(payload).slice(0, 1000),
          uploadUrl: targetUrl
        };
      } catch { /* JSON cycle — skip diagnostic */ }
    }
    parseErr = err;
  }
  if (result && (result.file_code || result.download_url || result.embed_url)) {
@ -636,8 +650,23 @@ async function uploadFile(hosterName, filePath, apiKey, onProgress, signal, thro
  throw new Error(msg);
 }
 async function prefetchBaseline(hosterName, apiKey, signal) {
  try {
    if (hosterName === 'byse.sx') {
      const baseline = await _fetchByseFileList(apiKey, signal);
      return new Set(baseline.map(f => f.file_code));
    }
    if (hosterName === 'doodstream.com') {
      const baseline = await _fetchDoodstreamFileList(apiKey, signal);
      return new Set(baseline.map(f => f.file_code));
    }
  } catch { /* leave caller to fall back to per-job fetch */ }
  return null;
 }
 module.exports = {
  uploadFile,
  prefetchBaseline,
  HOSTER_CONFIGS,
  __test: {
    extractUploadServerUrl,
--- a/lib/stats.js
+++ b/lib/stats.js
@ -0,0 +1,142 @@
 (function (root) {
  function summarizePerHoster(history, opts) {
    const out = {};
    if (!Array.isArray(history)) return out;
    const cutoff = opts && Number.isFinite(opts.sinceMs) ? opts.sinceMs : null;
    const limitBatches = opts && Number.isFinite(opts.lastNBatches) && opts.lastNBatches > 0 ? opts.lastNBatches : null;
    const entries = [...history];
    entries.sort((a, b) => {
      const ta = a && a.timestamp ? Date.parse(a.timestamp) : 0;
      const tb = b && b.timestamp ? Date.parse(b.timestamp) : 0;
      return tb - ta;
    });
    const sliced = limitBatches ? entries.slice(0, limitBatches) : entries;
    for (const batch of sliced) {
      if (!batch || !Array.isArray(batch.files)) continue;
      if (cutoff !== null) {
        const ts = batch.timestamp ? Date.parse(batch.timestamp) : 0;
        if (!ts || ts < cutoff) continue;
      }
      for (const file of batch.files) {
        if (!file || !Array.isArray(file.results)) continue;
        for (const r of file.results) {
          if (!r || !r.hoster) continue;
          const bucket = out[r.hoster] || (out[r.hoster] = { ok: 0, fail: 0, total: 0 });
          bucket.total++;
          if (r.status === 'done') bucket.ok++;
          else bucket.fail++;
        }
      }
    }
    for (const h of Object.keys(out)) {
      const b = out[h];
      b.rate = b.total > 0 ? b.ok / b.total : null;
    }
    return out;
  }
  function classifyErrorCategory(err) {
    if (!err || typeof err !== 'string') return 'unknown';
    const s = err.toLowerCase();
    if (/abgebrochen|aborted|cancel/.test(s)) return 'aborted';
    if (/not video file format|kein videoformat|invalid file|wrong format|duplicate|already exists|file too (small|big|large)|datei zu (gro|klein)/.test(s)) return 'file-rejected';
    if (/quota|storage (full|exhausted|voll)|account (full|banned|suspended)|disk (space )?full|insufficient (disk )?space|not enough (disk )?(space|storage)/.test(s)) return 'account-error';
    if (/csrf|kein upload-server|server.*?(busy|unavailable|try again)|no servers available|filecode|kein filecode|empty.*?(form|response)/.test(s)) return 'hoster-transient';
    if (/timeout|econnreset|enotfound|fetch failed|network|socket hang up|abort/.test(s)) return 'network';
    return 'unknown';
  }
  function summarizeBatchErrors(batchSummary) {
    const buckets = {
      'file-rejected': [],
      'account-error': [],
      'hoster-transient': [],
      'network': [],
      'unknown': [],
      'aborted': []
    };
    if (!batchSummary || !Array.isArray(batchSummary.files)) return buckets;
    for (const f of batchSummary.files) {
      if (!f || !Array.isArray(f.results)) continue;
      for (const r of f.results) {
        if (!r || r.status === 'done') continue;
        const cat = classifyErrorCategory(r.error);
        buckets[cat].push({
          fileName: f.name || f.fileName || '',
          hoster: r.hoster || '',
          error: r.error || '',
          jobId: r.jobId || null
        });
      }
    }
    return buckets;
  }
  const RETRYABLE_CATEGORIES = new Set(['hoster-transient', 'network', 'unknown']);
  function isRetryableCategory(cat) {
    return RETRYABLE_CATEGORIES.has(cat);
  }
  const CATEGORY_LABELS = {
    'file-rejected': 'Datei abgelehnt',
    'account-error': 'Account-Problem',
    'hoster-transient': 'Hoster-Flake',
    'network': 'Netzwerk',
    'unknown': 'Unbekannt',
    'aborted': 'Abgebrochen'
  };
  function formatLinks(rows, format) {
    if (!Array.isArray(rows)) return '';
    const safe = rows.filter(r => r && r.url);
    if (safe.length === 0) return '';
    switch (format) {
      case 'plain':
        return safe.map(r => r.url).join('\n');
      case 'bbcode':
        return safe.map(r => {
          const label = r.fileName || r.hoster || r.url;
          return `[url=${r.url}]${label}[/url]`;
        }).join('\n');
      case 'markdown':
        return safe.map(r => {
          const label = r.fileName || r.hoster || r.url;
          return `- [${label}](${r.url})`;
        }).join('\n');
      case 'html':
        return safe.map(r => {
          const label = r.fileName || r.hoster || r.url;
          return `<a href="${r.url}">${label}</a>`;
        }).join('\n');
      case 'csv': {
        const head = 'fileName,hoster,url\n';
        return head + safe.map(r => {
          const esc = (v) => `"${String(v || '').replace(/"/g, '""')}"`;
          return [esc(r.fileName), esc(r.hoster), esc(r.url)].join(',');
        }).join('\n');
      }
      case 'json':
        return JSON.stringify(safe.map(r => ({ fileName: r.fileName || '', hoster: r.hoster || '', url: r.url })), null, 2);
      default:
        return safe.map(r => r.url).join('\n');
    }
  }
  const api = {
    summarizePerHoster,
    classifyErrorCategory,
    summarizeBatchErrors,
    isRetryableCategory,
    RETRYABLE_CATEGORIES,
    CATEGORY_LABELS,
    formatLinks
  };
  if (typeof module !== 'undefined' && module.exports) {
    module.exports = api;
  } else if (root) {
    root.Stats = api;
  }
 })(typeof window !== 'undefined' ? window : this);
--- a/lib/support-bundle.js
+++ b/lib/support-bundle.js
@ -0,0 +1,64 @@
 const fs = require('fs');
 const CRED_KEYS = new Set(['password', 'apiKey', 'token', 'cookie', 'sessionId']);
 const REDACTED = '<redacted>';
 function sanitizeConfig(config) {
  if (!config || typeof config !== 'object') return config;
  const clone = JSON.parse(JSON.stringify(config));
  (function walk(o) {
    if (!o) return;
    if (Array.isArray(o)) { for (const e of o) walk(e); return; }
    if (typeof o !== 'object') return;
    for (const k of Object.keys(o)) {
      if (CRED_KEYS.has(k) && typeof o[k] === 'string' && o[k]) o[k] = REDACTED;
      else walk(o[k]);
    }
  })(clone);
  return clone;
 }
 function collectFile(filePath, label, maxBytes) {
  if (!filePath) return `=== ${label} ===\n<no path configured>\n\n`;
  let stat;
  try { stat = fs.statSync(filePath); }
  catch (err) {
    if (err && err.code === 'ENOENT') return `=== ${label} (${filePath}) ===\n<file does not exist yet>\n\n`;
    return `=== ${label} (${filePath}) ===\n<stat error: ${err.message}>\n\n`;
  }
  const cap = Number.isFinite(maxBytes) && maxBytes > 0 ? maxBytes : 5 * 1024 * 1024;
  let content;
  try {
    if (stat.size > cap) {
      const fd = fs.openSync(filePath, 'r');
      const buf = Buffer.alloc(cap);
      fs.readSync(fd, buf, 0, cap, stat.size - cap);
      fs.closeSync(fd);
      const skipped = stat.size - cap;
      content = `<truncated: skipped first ${skipped} bytes; showing last ${cap} bytes of ${stat.size}>\n` + buf.toString('utf-8');
    } else {
      content = fs.readFileSync(filePath, 'utf-8');
    }
  } catch (err) {
    content = `<read error: ${err.message}>`;
  }
  return `=== ${label} (${filePath}, size=${stat.size} bytes) ===\n${content}\n\n`;
 }
 function buildSupportBundleText({ header, sanitizedConfig, files }) {
  const parts = [];
  parts.push('=== Multi-Hoster-Upload Support Bundle ===\n');
  if (header && typeof header === 'object') {
    for (const [k, v] of Object.entries(header)) parts.push(`${k}: ${v}\n`);
  }
  parts.push('\n');
  parts.push('=== Config (sanitized — password/apiKey/token/cookie/sessionId redacted) ===\n');
  parts.push(JSON.stringify(sanitizedConfig, null, 2));
  parts.push('\n\n');
  for (const f of (files || [])) {
    parts.push(collectFile(f.path, f.label || f.path, f.maxBytes));
  }
  return parts.join('');
 }
 module.exports = { sanitizeConfig, collectFile, buildSupportBundleText, CRED_KEYS, REDACTED };
--- a/lib/updater.js
+++ b/lib/updater.js
@ -233,7 +233,20 @@ async function installUpdate(onProgress) {
    // Stage: done
    if (onProgress) onProgress({ stage: 'done', percent: 100 });
-    setTimeout(() => app.quit(), 900);
+    const _doQuit = () => setTimeout(() => app.quit(), 900);
    const _getActive = () => {
      try { return globalThis._mhuUploadManagerRef && globalThis._mhuUploadManagerRef.getActiveJobCount ? globalThis._mhuUploadManagerRef.getActiveJobCount() : 0; }
      catch { return 0; }
    };
    if (_getActive() > 0) {
      const POLL_MS = 3000;
      const poller = setInterval(() => {
        if (_getActive() === 0) { clearInterval(poller); _doQuit(); }
      }, POLL_MS);
      setTimeout(() => { try { clearInterval(poller); } catch {} _doQuit(); }, 30 * 60 * 1000);
    } else {
      _doQuit();
    }
  } catch (err) {
    if (onProgress) onProgress({ stage: 'error', error: err.message });
--- a/lib/upload-manager.js
+++ b/lib/upload-manager.js
@ -2,13 +2,14 @@ const { EventEmitter } = require('events');
 const path = require('path');
 const fs = require('fs');
 const crypto = require('crypto');
-const { uploadFile } = require('./hosters');
+const { uploadFile, prefetchBaseline } = require('./hosters');
 const VidmolyUploader = require('./vidmoly-upload');
 const VoeUploader = require('./voe-upload');
 const DoodstreamUploader = require('./doodstream-upload');
 const ClouddropUploader = require('./clouddrop-upload');
 const Semaphore = require('./semaphore');
 const Throttle = require('./throttle');
 const { probeFileHead } = require('./file-probe');
 const DEFAULT_SETTINGS = {
  retries: 3,
@ -41,6 +42,7 @@ class UploadManager extends EventEmitter {
    this._failedAccounts = new Map(); // hoster -> Set of failed accountIds
    this._accountOverrides = new Map(); // hoster -> fallback account object
    this._doodApiKeyCache = new Map(); // accountId/username -> derived doodstream API key ('' = tried, none)
    this._baselineCache = new Map(); // hoster:apiKey -> Promise<Set<file_code>> (one fetch shared across all jobs in batch)
  }
  switchAccount(hoster, fallbackAccount) {
@ -65,6 +67,20 @@ class UploadManager extends EventEmitter {
    return this._accountOverrides.get(hoster) || null;
  }
  getActiveJobCount() {
    return this.activeJobs.size;
  }
  clearFailedAccount(hoster, accountId) {
    return this._failedAccounts.delete(`${hoster}:${accountId}`);
  }
  clearAllFailedAccounts() {
    const n = this._failedAccounts.size;
    this._failedAccounts.clear();
    return n;
  }
  // True if the hoster has a usable override stored that differs from the
  // account currently in the task and isn't itself already marked failed.
  // Used by the retry loop to decide "retry on same account vs break to
@ -267,6 +283,7 @@ class UploadManager extends EventEmitter {
    this.jobAbortControllers.clear();
    this.cancelledJobIds.clear();
    this._doodApiKeyCache.clear(); // re-derive doodstream keys fresh each batch
    this._baselineCache.clear(); // re-fetch baselines per batch (a long batch could outlast remote-side relevance)
    this.semaphores = {};
    this.globalSemaphore = null;
    this.globalThrottle = null;
@ -297,18 +314,32 @@ class UploadManager extends EventEmitter {
    this._batchResults = results;
    this._additionalPromises = []; // Track jobs added mid-batch via addJobs()
-    for (const task of tasks) {
+    const DEDUP_CHUNK = 200;
-      const fileName = path.basename(task.file);
+    for (let i = 0; i < tasks.length; i += DEDUP_CHUNK) {
      if (signal.aborted) break;
      const end = Math.min(i + DEDUP_CHUNK, tasks.length);
      for (let j = i; j < end; j++) {
        const task = tasks[j];
        if (!results.has(task.file)) {
          const fileName = path.basename(task.file);
          let size = 0;
          try { size = fs.statSync(task.file).size; } catch {}
          results.set(task.file, { name: fileName, size, results: [] });
        }
      }
      if (end < tasks.length) await new Promise(setImmediate);
    }
    this._startStatsTimer();
-    const promises = tasks.map((task) => this._runJob(task, results, signal));
+    const SPAWN_CHUNK = 100;
    const promises = [];
    for (let i = 0; i < tasks.length; i += SPAWN_CHUNK) {
      if (signal.aborted) break;
      const end = Math.min(i + SPAWN_CHUNK, tasks.length);
      for (let j = i; j < end; j++) promises.push(this._runJob(tasks[j], results, signal));
      if (end < tasks.length) await new Promise(setImmediate);
    }
    await Promise.allSettled(promises);
    // Wait for any jobs added mid-batch via addJobs()
    while (this._additionalPromises.length > 0) {
@ -344,7 +375,12 @@ class UploadManager extends EventEmitter {
    const fileName = path.basename(task.file);
    let fileSize = 0;
    let fileNotFound = false;
    const cachedResult = results && results.get(task.file);
    if (cachedResult && typeof cachedResult.size === 'number' && cachedResult.size > 0) {
      fileSize = cachedResult.size;
    } else {
      try { fileSize = fs.statSync(task.file).size; } catch { fileNotFound = true; }
    }
    const maxAttempts = Math.max(1, (settings.retries || 0) + 1);
    const jobAbortController = new AbortController();
@ -409,26 +445,30 @@ class UploadManager extends EventEmitter {
        return;
      }
-      this._emitProgress(uploadId, fileName, task.hoster, { accountId: task.accountId,
+      // The initial 'queued' emit per job is suppressed: with N=2000+ tasks
-        jobId,
+      // it produces 2000+ main→renderer IPCs back-to-back at startBatch and
-        status: 'queued',
+      // freezes the renderer event loop for tens of seconds. The renderer
-        progress: 0,
+      // already holds each job in 'queued'/'preview' state from its own
-        bytesUploaded: 0,
+      // queueJobs array; the first event it actually needs from main is the
-        bytesTotal: fileSize,
+      // 'getting-server' / 'uploading' transition for the jobs that the
-        speedKbs: 0,
+      // semaphore lets through.
        elapsed: 0,
        remaining: 0,
        error: null,
        result: null,
        attempt: 0,
        maxAttempts
      });
      // Acquire hoster semaphore first so jobs waiting for a hoster slot
      // don't waste global slots (prevents underutilization)
      await hosterSemaphore.acquire(signal);
      hosterSlotAcquired = true;
      let fileProbe = null;
      try {
        fileProbe = await probeFileHead(task.file, 64);
      } catch (err) {
        fileProbe = { ok: false, error: err && err.message, kind: 'unreadable' };
      }
      this._rotLog('upload-start', {
        jobId, hoster: task.hoster, accountId: task.accountId, fileName,
        fileSize,
        detectedKind: fileProbe && fileProbe.kind ? fileProbe.kind : 'unknown',
        isVideoLike: !!(fileProbe && fileProbe.isVideoLike),
        headHex: fileProbe && fileProbe.headHex ? fileProbe.headHex.slice(0, 32) : null
      });
      if (globalSemaphore) {
        await globalSemaphore.acquire(signal);
        globalSlotAcquired = true;
@ -520,6 +560,7 @@ class UploadManager extends EventEmitter {
            speedAbort = new AbortController();
            uploadSignalBundle = this._combineManySignals([signal, speedAbort.signal]);
            speedMonitor = setInterval(() => {
              try {
                if (currentSpeedKbs > 0 && currentSpeedKbs < settings.restartBelowKbs) {
                  if (!lowSpeedSince) lowSpeedSince = Date.now();
                  if (Date.now() - lowSpeedSince > 6000) {
@ -528,6 +569,7 @@ class UploadManager extends EventEmitter {
                } else {
                  lowSpeedSince = 0;
                }
              } catch (e) { this._rotLog('speed-monitor-error', { jobId, error: e && e.message }); }
            }, 2000);
          }
@ -541,10 +583,11 @@ class UploadManager extends EventEmitter {
          const PROGRESS_EMIT_INTERVAL = 250; // ms – throttle UI updates
          const progressCb = (bytesUploaded, bytesTotal) => {
            try {
              const now = Date.now();
              const elapsed = Math.round((now - jobStart) / 1000);
              const timeDelta = (now - lastSpeedTime) / 1000;
-            if (timeDelta >= 1) {
+              if (Number.isFinite(timeDelta) && timeDelta >= 1) {
                const bytesDelta = bytesUploaded - lastBytes;
                currentSpeedKbs = Math.round(bytesDelta / timeDelta / 1024);
                lastBytes = bytesUploaded;
@ -554,7 +597,6 @@ class UploadManager extends EventEmitter {
              activeEntry.speedKbs = currentSpeedKbs;
              activeEntry.bytesUploaded = bytesUploaded;
            // Throttle progress emissions to reduce IPC + rendering overhead
              if (now - lastEmitTime < PROGRESS_EMIT_INTERVAL) return;
              lastEmitTime = now;
@ -576,6 +618,7 @@ class UploadManager extends EventEmitter {
                attempt,
                maxAttempts
              });
            } catch { /* progress callbacks must never throw — swallowing is correct, the stream keeps going */ }
          };
          const result = await this._executeUpload(task, progressCb, uploadSignalBundle.signal, throttle);
@ -596,6 +639,23 @@ class UploadManager extends EventEmitter {
          this.activeJobs.delete(uploadId);
          const isSpeedRestart = speedAbort && speedAbort.signal.aborted && !signal.aborted;
          if (!signal.aborted && !isSpeedRestart) {
            const diag = (err && typeof err === 'object' && err.diagnostic) || {};
            this._rotLog('upload-failure', {
              jobId, hoster: task.hoster, accountId: task.accountId, fileName,
              attempt,
              error: err && err.message ? err.message : String(err),
              fileRejected: !!(err && err.fileRejected),
              accountError: !!(err && err.accountError),
              hosterTransient: !!(err && err.hosterTransient),
              http: diag.http || null,
              contentType: diag.contentType || null,
              detectedKind: (typeof fileProbe !== 'undefined' && fileProbe && fileProbe.kind) ? fileProbe.kind : null,
              isVideoLike: !!(typeof fileProbe !== 'undefined' && fileProbe && fileProbe.isVideoLike),
              headHex: (typeof fileProbe !== 'undefined' && fileProbe && fileProbe.headHex) ? fileProbe.headHex.slice(0, 32) : null,
              payloadSnippet: diag.payloadSnippet || null
            });
          }
          if (signal.aborted) {
            lastError = new Error('Abgebrochen');
            break;
@ -882,7 +942,9 @@ class UploadManager extends EventEmitter {
      const apiKey = await this._resolveDoodstreamApiKey(task);
      if (apiKey) {
        this._rotLog('doodstream-via-api', { accountId: task.accountId, fileName: path.basename(task.file) });
-        return uploadFile('doodstream.com', task.file, apiKey, progressCb, signal, throttle);
+        return uploadFile('doodstream.com', task.file, apiKey, progressCb, signal, throttle, {
          doodBaseline: await this._getBaseline('doodstream.com', apiKey, signal)
        });
      }
      this._rotLog('doodstream-via-web', { accountId: task.accountId, fileName: path.basename(task.file) });
      const dood = new DoodstreamUploader();
@ -892,10 +954,23 @@ class UploadManager extends EventEmitter {
      const clouddrop = new ClouddropUploader(task.apiKey);
      return clouddrop.upload(task.file, progressCb, signal, throttle);
    } else {
-      return uploadFile(task.hoster, task.file, task.apiKey, progressCb, signal, throttle);
+      const baselineOpts = {};
      if (task.hoster === 'byse.sx') baselineOpts.byseBaseline = await this._getBaseline('byse.sx', task.apiKey, signal);
      if (task.hoster === 'doodstream.com') baselineOpts.doodBaseline = await this._getBaseline('doodstream.com', task.apiKey, signal);
      return uploadFile(task.hoster, task.file, task.apiKey, progressCb, signal, throttle, baselineOpts);
    }
  }
  _getBaseline(hosterName, apiKey, signal) {
    if (!apiKey) return Promise.resolve(null);
    const key = `${hosterName}:${apiKey}`;
    let pending = this._baselineCache.get(key);
    if (pending) return pending;
    pending = prefetchBaseline(hosterName, apiKey, signal);
    this._baselineCache.set(key, pending);
    return pending;
  }
  // Resolve (and cache per batch) the doodstream API key for a login-only
  // account by logging in once and scraping+validating it from the session.
  // Returns the key string, or '' when none could be derived (cached either way
@ -925,7 +1000,7 @@ class UploadManager extends EventEmitter {
  _startStatsTimer() {
    if (this.statsInterval) clearInterval(this.statsInterval);
    this.statsInterval = setInterval(() => {
-      // Single pass over active jobs instead of two.
+      try {
      let globalSpeedKbs = 0;
      let activeCount = 0;
      let inProgressBytes = 0;
@ -945,6 +1020,7 @@ class UploadManager extends EventEmitter {
        activeJobs: activeCount,
        pendingJobs: Object.values(this.semaphores).reduce((sum, semaphore) => sum + semaphore.pending, 0)
      });
      } catch { /* never let a stats tick crash the timer + caller */ }
    }, 1000);
  }
--- a/lib/vidmoly-upload.js
+++ b/lib/vidmoly-upload.js
@ -382,7 +382,7 @@ class VidmolyUploader {
          }
        }
-        if (best && (bestScore > 0 || newFiles.length === 1)) {
+        if (best && bestScore > 0) {
          return this._buildUrlsFromCode(best.file_code);
        }
      }
--- a/main.js
+++ b/main.js
@ -16,6 +16,7 @@ const FolderMonitor = require('./lib/folder-monitor');
 const RemoteServer = require('./lib/remote-server');
 const { maybeRotateLogFile } = require('./lib/log-rotation');
 const { hosterLogToFileEnabled } = require('./lib/log-policy');
 const { sanitizeConfig, buildSupportBundleText } = require('./lib/support-bundle');
 let mainWindow;
 let _lastImportPath = null;
@ -115,6 +116,49 @@ function debugLog(msg) {
  } catch {}
 }
 let _logVerbose = false;
 function setLogVerbose(v) { _logVerbose = !!v; }
 function _ctxTag(ctx) {
  if (!ctx || typeof ctx !== 'object') return '';
  const tags = [];
  if (ctx.batch) tags.push(`b:${String(ctx.batch).slice(0, 8)}`);
  if (ctx.job) tags.push(`j:${String(ctx.job).slice(-8)}`);
  if (ctx.hoster) tags.push(ctx.hoster);
  if (ctx.attempt !== undefined && ctx.attempt !== null) tags.push(`a:${ctx.attempt}`);
  return tags.length ? `[${tags.join(' ')}] ` : '';
 }
 function _split(a, b) {
  if (typeof a === 'string') return { ctx: null, msg: a, extra: b };
  return { ctx: a, msg: b, extra: arguments[2] };
 }
 function logDebug(a, b) {
  if (!_logVerbose) return;
  const s = _split(a, b);
  debugLog(`[DEBUG] ${_ctxTag(s.ctx)}${s.msg}`);
 }
 function logInfo(a, b) {
  const s = _split(a, b);
  debugLog(`[INFO ] ${_ctxTag(s.ctx)}${s.msg}`);
 }
 function logWarn(a, b) {
  const s = _split(a, b);
  debugLog(`[WARN ] ${_ctxTag(s.ctx)}${s.msg}`);
 }
 function logError(a, b, c) {
  let ctx, msg, err;
  if (typeof a === 'string') { ctx = null; msg = a; err = b; }
  else { ctx = a; msg = b; err = c; }
  const errStr = err ? ` :: ${err.stack || err.message || err}` : '';
  debugLog(`[ERROR] ${_ctxTag(ctx)}${msg}${errStr}`);
 }
 function logMarker(label, fields) {
  let extra = '';
  if (fields && typeof fields === 'object') {
    extra = ' ' + Object.entries(fields).map(([k, v]) => `${k}=${v}`).join(' ');
  }
  debugLog(`────── ${label}${extra} ──────`);
 }
 // Dedicated account-rotation log so users can trace fallback decisions
 // without wading through general debug output. Writes to account-rotation.log
 // in the same directory as fileuploader.log (honors user's configured path).
@ -154,27 +198,29 @@ function _flushRotLog() {
  write(0);
 }
 function getAllLogPaths() {
  const upload = getLogFilePath();
  const debugPath = getDebugLogPath();
  const rot = getRotLogPath();
  const dir = path.dirname(debugPath);
  return {
    fileuploader: upload,
    debug: debugPath,
    accountRotation: rot,
    doodstreamDebug: path.join(dir, 'doodstream-debug.log'),
    crashLog: path.join(dir, 'crash.log'),
    logDir: dir
  };
 }
 function rotLog(msg, ts) {
  try {
    const iso = new Date(ts || Date.now()).toISOString();
    const line = `[${iso}] ${msg}\n`;
-    // Write synchronously. Rotation events are rare (a handful per batch) so
+    _rotLogBuffer.push(line);
-    // the batching optimization from debugLog doesn't buy us anything, and
+    if (!_rotLogFlushTimer) {
-    // syncing guarantees the user can refresh the file and see fresh entries
+      _rotLogFlushTimer = setTimeout(() => { _rotLogFlushTimer = null; _flushRotLog(); }, 500);
    // without waiting on a flush timer.
    const candidates = [
      getRotLogPath(),
      path.join(app.getPath('desktop') || app.getPath('userData'), 'account-rotation.log'),
      path.join(app.getPath('userData'), 'account-rotation.log')
    ];
    for (const target of candidates) {
      try {
        fs.mkdirSync(path.dirname(target), { recursive: true });
        fs.appendFileSync(target, line, 'utf-8');
        break;
      } catch {}
    }
    // Mirror into the main debug log for single-file-grep convenience.
    _debugLogBuffer.push(`[${iso}] [ROT] ${msg}\n`);
    if (!_debugLogFlushTimer) {
      _debugLogFlushTimer = setTimeout(() => { _debugLogFlushTimer = null; _flushDebugLog(); }, 500);
@ -182,11 +228,62 @@ function rotLog(msg, ts) {
  } catch {}
 }
-// Catch unhandled rejections from fire-and-forget async calls
+function safeSend(channel, data) {
  if (!mainWindow || mainWindow.isDestroyed()) return false;
  try {
    mainWindow.webContents.send(channel, data);
    return true;
  } catch (err) {
    debugLog(`safeSend(${channel}) failed: ${err && err.message ? err.message : err}`);
    return false;
  }
 }
 function _writeCrashLog(prefix, err, extra) {
  try {
    const ts = new Date().toISOString();
    const line = `[${ts}] ${prefix} ${err && err.stack ? err.stack : (err && err.message) || String(err)}${extra ? ' :: ' + JSON.stringify(extra) : ''}\n`;
    try {
      const target = getDebugLogPath();
      fs.appendFileSync(target, line, 'utf-8');
    } catch {}
    try {
      const crashDir = path.dirname(getDebugLogPath());
      fs.appendFileSync(path.join(crashDir, 'crash.log'), line, 'utf-8');
    } catch {}
  } catch {}
 }
 process.on('unhandledRejection', (reason) => {
  debugLog(`UNHANDLED REJECTION: ${reason && reason.stack ? reason.stack : reason}`);
  _writeCrashLog('UNHANDLED REJECTION', reason);
 });
 process.on('uncaughtException', (err, origin) => {
  _writeCrashLog('UNCAUGHT EXCEPTION (' + origin + ')', err);
  debugLog(`UNCAUGHT EXCEPTION (${origin}): ${err && err.stack ? err.stack : err}`);
 });
 process.on('exit', (code) => {
  try { _writeCrashLog('PROCESS EXIT', new Error('code=' + code)); } catch {}
 });
 process.on('warning', (warning) => {
  debugLog(`PROCESS WARNING: ${warning.name} ${warning.message}`);
 });
 for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGBREAK']) {
  try {
    process.on(sig, () => {
      _writeCrashLog('SIGNAL ' + sig, new Error('process received ' + sig));
      try {
        if (_debugLogBuffer.length) fs.appendFileSync(getDebugLogPath(), _debugLogBuffer.join(''), 'utf-8');
      } catch {}
      process.exit(0);
    });
  } catch {}
 }
 function withTimeout(promise, timeoutMs, label) {
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
@ -386,9 +483,7 @@ function _flushUploadLog() {
      // next session writes here directly (no more fallback ladder) and
      // the Settings input reflects reality.
      _persistFallbackLogPath(target.path);
-      if (mainWindow && !mainWindow.isDestroyed()) {
+      safeSend('upload-log-fallback', { fallbackPath: target.path });
        mainWindow.webContents.send('upload-log-fallback', { fallbackPath: target.path });
      }
    }
    if (_uploadLogBuffer.length && !_uploadLogFlushTimer) setImmediate(_flushUploadLog);
  });
@ -416,9 +511,7 @@ function _persistFallbackLogPath(workingPath) {
    cfg.globalSettings = gs;
    configStore.save({ globalSettings: gs }).catch(() => {});
    _invalidateUploadLogTargetCache();
-    if (mainWindow && !mainWindow.isDestroyed()) {
+    safeSend('log-path-auto-updated', { logFilePath: toSave });
      mainWindow.webContents.send('log-path-auto-updated', { logFilePath: toSave });
    }
  } catch (err) {
    debugLog(`persist fallback logpath failed: ${err.message}`);
  }
@ -902,6 +995,51 @@ function createWindow() {
  });
  mainWindow.webContents.setBackgroundThrottling(false);
  mainWindow.webContents.on('render-process-gone', (_event, details) => {
    _writeCrashLog('RENDER PROCESS GONE', new Error(details.reason || 'unknown'), details);
    debugLog(`RENDER PROCESS GONE: reason=${details.reason} exitCode=${details.exitCode}`);
    if (mainWindow && !mainWindow.isDestroyed()) {
      try {
        const choice = dialog.showMessageBoxSync(mainWindow, {
          type: 'error',
          title: 'Renderer abgestürzt',
          message: `Der Renderer-Prozess ist abgestürzt (${details.reason}).`,
          detail: 'Bitte Diagnose-Paket exportieren und einsenden. Klick "Neu laden" um die UI wiederherzustellen — laufende Uploads im Main-Process bleiben aktiv.',
          buttons: ['Neu laden', 'Beenden'],
          defaultId: 0,
          cancelId: 1
        });
        if (choice === 0) {
          mainWindow.webContents.reload();
        } else {
          app.exit(1);
        }
      } catch {
        try { mainWindow.webContents.reload(); } catch {}
      }
    }
  });
  mainWindow.webContents.on('unresponsive', () => {
    _writeCrashLog('RENDERER UNRESPONSIVE', new Error('webContents unresponsive'));
    debugLog('RENDERER UNRESPONSIVE');
  });
  mainWindow.webContents.on('responsive', () => {
    debugLog('RENDERER RESPONSIVE AGAIN');
  });
  mainWindow.webContents.on('did-fail-load', (_event, errorCode, errorDescription, validatedURL) => {
    _writeCrashLog('DID-FAIL-LOAD', new Error(errorDescription), { errorCode, validatedURL });
    debugLog(`DID-FAIL-LOAD: ${errorCode} ${errorDescription} url=${validatedURL}`);
  });
  app.on('child-process-gone', (_event, details) => {
    _writeCrashLog('CHILD PROCESS GONE', new Error(details.reason || 'unknown'), details);
    debugLog(`CHILD PROCESS GONE: type=${details.type} reason=${details.reason} exitCode=${details.exitCode}`);
  });
  mainWindow.loadFile(path.join(__dirname, 'renderer', 'index.html'));
 }
@ -927,6 +1065,19 @@ function updateTrayTooltip(text) {
 }
 app.whenReady().then(() => {
  try {
    const _bootCfg = configStore.load();
    setLogVerbose(!!(_bootCfg.globalSettings && _bootCfg.globalSettings.logVerbose));
  } catch {}
  logMarker('APP START', {
    version: app.getVersion(),
    electron: process.versions.electron,
    node: process.versions.node,
    platform: process.platform,
    arch: process.arch,
    verbose: _logVerbose,
    pid: process.pid
  });
  createWindow();
  createTray();
@ -943,7 +1094,7 @@ app.whenReady().then(() => {
      if (fs.existsSync(fm.folderPath)) {
        startFolderMonitor(fm);
      } else {
-        debugLog(`folder-monitor auto-start skipped: path not found (${fm.folderPath})`);
+        logWarn(`folder-monitor auto-start skipped: path not found (${fm.folderPath})`);
        // Persist the disable so the user gets a clean state on next launch
        const gs = { ...launchConfig.globalSettings, folderMonitor: { ...fm, enabled: false } };
        configStore.save({ globalSettings: gs }).catch(() => {});
@ -977,19 +1128,23 @@ app.whenReady().then(() => {
  // Auto-check for updates after 3 seconds
  setTimeout(async () => {
    try {
-      debugLog('update-check: starting');
+      logInfo('update-check: starting');
      const result = await checkForUpdate();
-      debugLog(`update-check: available=${result && result.available}, remote=${result && result.remoteVersion}`);
+      logInfo(`update-check: available=${result && result.available}, remote=${result && result.remoteVersion}`);
      logDebug(`update-check result: ${JSON.stringify(result)}`);
      if (result && result.available && mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.send('app:update-available', result);
+        safeSend('app:update-available', result);
      }
    } catch (err) {
-      debugLog(`update-check failed: ${err && err.message || err}`);
+      logError('update-check failed', err);
    }
  }, 3000);
 });
 app.on('window-all-closed', () => {
  const activeJobs = uploadManager && typeof uploadManager.getActiveJobCount === 'function' ? uploadManager.getActiveJobCount() : 0;
  debugLog(`window-all-closed: activeJobs=${activeJobs}, uploadManager=${!!uploadManager}`);
  _writeCrashLog('WINDOW-ALL-CLOSED', new Error('all windows closed'), { activeJobs, uploadManager: !!uploadManager });
  app.quit();
 });
@ -1000,7 +1155,8 @@ app.on('before-quit', () => {
    if (remoteServer) { remoteServer.stop(); remoteServer = null; }
    destroyCaptureWindow();
  } catch {}
-  destroyDropTargetWindow();
+  try { destroyDropTargetWindow(); } catch {}
  try { if (tray && !tray.isDestroyed()) { tray.destroy(); tray = null; } } catch {}
  // Flush pending log buffers synchronously so no lines are lost.
  try {
    if (_debugLogBuffer.length) {
@ -1037,6 +1193,11 @@ ipcMain.handle('get-config', () => {
 ipcMain.handle('save-config', async (_event, config) => {
  await configStore.save(config);
  try {
    if (config && config.globalSettings && Object.prototype.hasOwnProperty.call(config.globalSettings, 'logVerbose')) {
      setLogVerbose(!!config.globalSettings.logVerbose);
    }
  } catch {}
  // If a batch is running and some accounts got marked failed before any
  // fallback existed, re-resolve now — the user may have just added one.
  // Without this re-probe, those accounts stay stuck with no override until
@ -1056,13 +1217,11 @@ ipcMain.handle('save-config', async (_event, config) => {
          rotLog(`main: config-updated → late fallback ${fallback.id} for ${hoster} (was stuck on ${failedAccountId})`);
          uploadManager.switchAccount(hoster, fallback);
          _sessionAccountOverrides.set(hoster, fallback);
-          if (mainWindow && !mainWindow.isDestroyed()) {
+          safeSend('account-switched', {
            mainWindow.webContents.send('account-switched', {
              hoster, fromAccountId: failedAccountId, toAccountId: fallback.id
            });
        }
      }
      }
    } catch (err) {
      debugLog(`save-config re-resolve failed: ${err && err.message ? err.message : err}`);
    }
@ -1220,33 +1379,32 @@ ipcMain.handle('select-folder', async () => {
  });
  if (result.canceled || !result.filePaths.length) return null;
  // Recursively collect all files from selected folders
  const files = [];
-  const walk = (dir) => {
+  for (const folder of result.filePaths) await walkFolderAsync(folder, files);
    try {
      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
        const full = path.join(dir, entry.name);
        if (entry.isDirectory()) walk(full);
        else if (entry.isFile()) files.push(full);
      }
    } catch {}
  };
  for (const folder of result.filePaths) walk(folder);
  return files.length > 0 ? files : null;
 });
 async function walkFolderAsync(rootDir, outFiles) {
  const fsp = fs.promises;
  const stack = [rootDir];
  let scanned = 0;
  while (stack.length > 0) {
    const dir = stack.pop();
    let entries;
    try { entries = await fsp.readdir(dir, { withFileTypes: true }); }
    catch { continue; }
    for (const entry of entries) {
      const full = path.join(dir, entry.name);
      if (entry.isDirectory()) stack.push(full);
      else if (entry.isFile()) outFiles.push(full);
    }
    if ((++scanned % 8) === 0) await new Promise(setImmediate);
  }
 }
 ipcMain.handle('resolve-folder-files', async (_event, folderPath) => {
  const files = [];
-  const walk = (dir) => {
+  await walkFolderAsync(folderPath, files);
    try {
      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
        const full = path.join(dir, entry.name);
        if (entry.isDirectory()) walk(full);
        else if (entry.isFile()) files.push(full);
      }
    } catch {}
  };
  walk(folderPath);
  return files;
 });
@ -1258,6 +1416,7 @@ ipcMain.handle('start-upload', (_event, payload) => {
  // At 500+ jobs JSON.stringify blew up the debug log with MB-sized lines
  // per start-upload and added noticeable delay — log counts only.
  logMarker('BATCH START', { files: files.length, hosters: hosters.length, jobs: jobs.length });
  debugLog(`start-upload: files=${files.length}, hosters=${hosters.length}, jobs=${jobs.length}`);
  const tasks = jobs.length > 0
@ -1304,9 +1463,29 @@ ipcMain.handle('start-upload', (_event, payload) => {
  // Pass hoster settings to the upload manager
  uploadManager = new UploadManager(config.hosterSettings || {}, config.globalSettings || {});
  globalThis._mhuUploadManagerRef = uploadManager;
  const _progressByJob = new Map();
  const _progressTerminalQueue = [];
  let _progressFlushTimer = null;
  const PROGRESS_BATCH_INTERVAL_MS = 100;
  function _scheduleProgressFlush() {
    if (_progressFlushTimer) return;
    _progressFlushTimer = setTimeout(() => {
      _progressFlushTimer = null;
      if (!mainWindow || mainWindow.isDestroyed()) {
        _progressByJob.clear();
        _progressTerminalQueue.length = 0;
        return;
      }
      const batch = _progressTerminalQueue.splice(0);
      for (const v of _progressByJob.values()) batch.push(v);
      _progressByJob.clear();
      if (batch.length) safeSend('upload-progress-batch', batch);
    }, PROGRESS_BATCH_INTERVAL_MS);
  }
  uploadManager.on('progress', (data) => {
    // Only log state changes, not continuous progress updates
    if (data.status !== 'uploading') {
      debugLog(`progress: ${data.fileName} ${data.hoster} ${data.status} ${data.error || ''}`);
      _appendJobLog(data.jobId, {
@ -1315,10 +1494,6 @@ ipcMain.handle('start-upload', (_event, payload) => {
        error: data.error || null, attempt: data.attempt || 0, maxAttempts: data.maxAttempts || 0
      });
    }
    // Write to fileuploader.log immediately when a single upload finishes —
    // unless the user disabled logging for this hoster (per-hoster toggle).
    // Read from the live uploadManager.hosterSettings so a mid-batch toggle
    // (which calls updateSettings) takes effect immediately.
    if (data.status === 'done' && data.result) {
      const link = data.result.download_url || data.result.embed_url || data.result.file_code || '';
      if (link) {
@ -1331,22 +1506,29 @@ ipcMain.handle('start-upload', (_event, payload) => {
        debugLog(`WARNING: done but no link for ${data.fileName} @ ${data.hoster}: ${JSON.stringify(data.result)}`);
      }
    }
-    if (mainWindow && !mainWindow.isDestroyed()) {
+    const isTerminal = data.status === 'done' || data.status === 'error' || data.status === 'aborted' || data.status === 'skipped';
-      mainWindow.webContents.send('upload-progress', data);
+    if (isTerminal) {
      if (data.jobId) _progressByJob.delete(data.jobId);
      _progressTerminalQueue.push(data);
    } else if (data.jobId) {
      _progressByJob.set(data.jobId, data);
    } else {
      _progressTerminalQueue.push(data);
    }
    _scheduleProgressFlush();
  });
  uploadManager.on('stats', (data) => {
-    if (mainWindow && !mainWindow.isDestroyed()) {
+    try {
-      mainWindow.webContents.send('upload-stats', data);
+      if (!data || typeof data !== 'object') return;
-    }
+      safeSend('upload-stats', data);
    // Update tray tooltip with upload progress
      if (data.state === 'uploading' && data.activeJobs > 0) {
-      const speedMb = ((data.globalSpeedKbs || 0) / 1024).toFixed(1);
+        const speedMb = ((Number(data.globalSpeedKbs) || 0) / 1024).toFixed(1);
        updateTrayTooltip(`Upload: ${data.activeJobs} aktiv - ${speedMb} MB/s`);
      } else {
        updateTrayTooltip('Multi-Hoster-Upload');
      }
    } catch (e) { debugLog(`stats listener error: ${e && e.message}`); }
  });
  uploadManager.on('account-failed', ({ hoster, accountId }) => {
@ -1359,26 +1541,41 @@ ipcMain.handle('start-upload', (_event, payload) => {
      rotLog(`main: account-failed ${hoster} ${accountId} → resolved fallback ${fallback.id}`);
      uploadManager.switchAccount(hoster, fallback);
      _sessionAccountOverrides.set(hoster, fallback);
-      if (mainWindow && !mainWindow.isDestroyed()) {
+      safeSend('account-switched', { hoster, fromAccountId: accountId, toAccountId: fallback.id });
        mainWindow.webContents.send('account-switched', { hoster, fromAccountId: accountId, toAccountId: fallback.id });
      }
    } else {
      rotLog(`main: account-failed ${hoster} ${accountId} → NO fallback available (end of chain)`);
    }
  });
  const ROT_LOG_RENDERER_EVENTS = new Set([
    'switchAccount',
    'pre-job-swap',
    'try-alternate-after-fail',
    'mark-failed',
    'rotation-end',
    'doodstream-via-api',
    'doodstream-via-web'
  ]);
  uploadManager.on('rot-log', (entry) => {
    try {
      if (!entry || typeof entry !== 'object') return;
      const { ts, event, ...rest } = entry;
      const pairs = Object.entries(rest)
-      .map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`)
+        .map(([k, v]) => {
          let sv;
          try { sv = typeof v === 'string' ? v : JSON.stringify(v); }
          catch { sv = '<unserializable>'; }
          return `${k}=${sv}`;
        })
        .join(' ');
      rotLog(`[${event}] ${pairs}`, ts);
      if (entry.jobId) {
        _appendJobLog(entry.jobId, { ts: ts || Date.now(), kind: 'rot', event, ...rest });
      }
-    if (mainWindow && !mainWindow.isDestroyed()) {
+      if (ROT_LOG_RENDERER_EVENTS.has(event)) {
-      mainWindow.webContents.send('account-rotation-log', entry);
+        safeSend('account-rotation-log', entry);
      }
    } catch (e) { debugLog(`rot-log listener error: ${e && e.message}`); }
  });
  // Capture the manager identity at listener-registration time so the post-
@ -1390,17 +1587,16 @@ ipcMain.handle('start-upload', (_event, payload) => {
  const _thisManager = uploadManager;
  uploadManager.on('batch-done', async (summary) => {
    debugLog(`batch-done: total=${summary.total} ok=${summary.succeeded} fail=${summary.failed}`);
    logMarker('BATCH END', { total: summary.total, ok: summary.succeeded, fail: summary.failed });
    logMemorySnapshot('batch-done');
    try { await configStore.appendHistory(summary); } catch (err) {
      debugLog(`appendHistory failed: ${err.message}`);
    }
-    if (mainWindow && !mainWindow.isDestroyed()) {
+    safeSend('upload-batch-done', summary);
      mainWindow.webContents.send('upload-batch-done', summary);
    }
    // Shutdown after finish
    handleShutdownAfterFinish();
-    if (uploadManager === _thisManager) uploadManager = null;
+    if (uploadManager === _thisManager) { uploadManager = null; globalThis._mhuUploadManagerRef = null; }
    else debugLog('batch-done: skipping uploadManager null-out — a newer manager replaced this one mid-await');
  });
@ -1416,8 +1612,7 @@ ipcMain.handle('start-upload', (_event, payload) => {
    }).catch((err) => {
      debugLog(`startBatch REJECTED: ${err && err.stack ? err.stack : err}`);
      // Forward error to renderer as batch-done with failure
-      if (mainWindow && !mainWindow.isDestroyed()) {
+      safeSend('upload-batch-done', {
        mainWindow.webContents.send('upload-batch-done', {
          id: 'error',
          timestamp: new Date().toISOString(),
          total: tasks.length,
@ -1426,7 +1621,6 @@ ipcMain.handle('start-upload', (_event, payload) => {
          files: [],
          error: err ? err.message : 'Unbekannter Fehler'
        });
      }
    });
  });
@ -1496,12 +1690,136 @@ ipcMain.handle('finish-after-active', () => {
  return true;
 });
 ipcMain.handle('get-session-failed-accounts', () => {
  return Array.from(_sessionFailedAccounts.keys());
 });
 ipcMain.handle('reset-session-failed-account', (_event, payload) => {
  if (!payload || typeof payload !== 'object') return { ok: false };
  const { hoster, accountId } = payload;
  if (!hoster || !accountId) return { ok: false };
  const key = `${hoster}:${accountId}`;
  const removed = _sessionFailedAccounts.delete(key);
  if (uploadManager && typeof uploadManager.clearFailedAccount === 'function') {
    try { uploadManager.clearFailedAccount(hoster, accountId); } catch {}
  }
  rotLog(`session-failed: manual reset ${key} (was set: ${removed})`);
  return { ok: true, removed };
 });
 ipcMain.handle('reset-all-session-failed-accounts', () => {
  const count = _sessionFailedAccounts.size;
  _sessionFailedAccounts.clear();
  if (uploadManager && typeof uploadManager.clearAllFailedAccounts === 'function') {
    try { uploadManager.clearAllFailedAccounts(); } catch {}
  }
  rotLog(`session-failed: cleared all (${count})`);
  return { ok: true, count };
 });
 ipcMain.handle('get-job-log', (_event, jobId) => {
  if (!jobId || typeof jobId !== 'string') return [];
  const arr = _jobLogCollector.get(jobId);
  return Array.isArray(arr) ? arr.slice() : [];
 });
 ipcMain.handle('get-log-paths', () => {
  return getAllLogPaths();
 });
 ipcMain.handle('get-app-info', () => {
  return {
    name: app.getName(),
    version: app.getVersion(),
    electron: process.versions.electron,
    node: process.versions.node,
    chrome: process.versions.chrome,
    platform: process.platform,
    arch: process.arch,
    osRelease: require('os').release(),
    pid: process.pid,
    isPackaged: app.isPackaged,
    logVerbose: _logVerbose
  };
 });
 ipcMain.handle('reveal-log-file', async (_event, target) => {
  const { shell } = require('electron');
  const paths = getAllLogPaths();
  const file = (target && typeof target === 'string' && paths[target]) || null;
  try {
    if (file && fs.existsSync(file)) {
      shell.showItemInFolder(file);
      return { ok: true, path: file };
    }
    const dir = paths.logDir;
    if (dir) {
      fs.mkdirSync(dir, { recursive: true });
      shell.openPath(dir);
      return { ok: true, path: dir };
    }
    return { ok: false, error: 'Kein Log-Pfad gefunden' };
  } catch (err) {
    return { ok: false, error: err.message };
  }
 });
 ipcMain.handle('set-log-verbose', (_event, enabled) => {
  setLogVerbose(enabled);
  logMarker('VERBOSE TOGGLE', { enabled: _logVerbose });
  return { ok: true, verbose: _logVerbose };
 });
 ipcMain.handle('create-support-bundle', async () => {
  const { dialog } = require('electron');
  try {
    if (_debugLogBuffer.length) {
      try { fs.appendFileSync(getDebugLogPath(), _debugLogBuffer.join(''), 'utf-8'); _debugLogBuffer.length = 0; } catch {}
    }
    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
    const defaultName = `multi-hoster-support-${stamp}.txt`;
    const desktop = (() => { try { return app.getPath('desktop'); } catch { return app.getPath('userData'); } })();
    const res = await dialog.showSaveDialog(mainWindow || undefined, {
      title: 'Diagnose-Paket speichern',
      defaultPath: path.join(desktop, defaultName),
      filters: [{ name: 'Text', extensions: ['txt'] }]
    });
    if (res.canceled || !res.filePath) return { ok: false, canceled: true };
    const paths = getAllLogPaths();
    const cfg = configStore.load();
    const text = buildSupportBundleText({
      header: {
        App: app.getName(),
        Version: app.getVersion(),
        Electron: process.versions.electron,
        Node: process.versions.node,
        Chrome: process.versions.chrome,
        Platform: process.platform,
        Arch: process.arch,
        OS: `${require('os').type()} ${require('os').release()}`,
        Packaged: app.isPackaged,
        Verbose: _logVerbose,
        PID: process.pid,
        CreatedAt: new Date().toISOString()
      },
      sanitizedConfig: sanitizeConfig(cfg),
      files: [
        { label: 'debug.log (last 5 MB)', path: paths.debug, maxBytes: 5 * 1024 * 1024 },
        { label: 'account-rotation.log (last 2 MB)', path: paths.accountRotation, maxBytes: 2 * 1024 * 1024 },
        { label: 'doodstream-debug.log (last 2 MB)', path: paths.doodstreamDebug, maxBytes: 2 * 1024 * 1024 },
        { label: 'crash.log', path: path.join(paths.logDir || path.dirname(paths.debug), 'crash.log'), maxBytes: 1 * 1024 * 1024 },
        { label: 'fileuploader.log (last 1 MB)', path: paths.fileuploader, maxBytes: 1 * 1024 * 1024 }
      ]
    });
    fs.writeFileSync(res.filePath, text, 'utf-8');
    logMarker('SUPPORT BUNDLE', { path: res.filePath, bytes: text.length });
    return { ok: true, path: res.filePath, bytes: text.length };
  } catch (err) {
    debugLog(`create-support-bundle failed: ${err.message}`);
    return { ok: false, error: err.message };
  }
 });
 ipcMain.handle('open-log-folder', async () => {
  // Reveal the active log file (or its directory) in the OS file manager.
  // Prefers the configured log path, then the rotation log, then just the
@ -1531,12 +1849,19 @@ ipcMain.handle('export-backup', async () => {
  const { canceled, filePath } = await dialog.showSaveDialog(mainWindow, {
    title: 'Backup exportieren',
    defaultPath: `multi-hoster-backup-${new Date().toISOString().slice(0, 10)}.mhu`,
-    filters: [{ name: 'Multi-Hoster Backup', extensions: ['mhu'] }]
+    filters: [
      { name: 'Multi-Hoster Backup (verschlüsselt)', extensions: ['mhu'] },
      { name: 'Multi-Hoster Backup (Klartext JSON)', extensions: ['json'] }
    ]
  });
  if (canceled || !filePath) return { ok: false, canceled: true };
  const config = configStore.load();
  if (filePath.toLowerCase().endsWith('.json')) {
    fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
  } else {
    const encrypted = backupCrypto.encrypt(config);
    fs.writeFileSync(filePath, encrypted);
  }
  return { ok: true, path: filePath };
 });
@ -1548,7 +1873,11 @@ ipcMain.handle('import-backup', async (_event, legacyPassword) => {
  } else {
    const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
      title: 'Backup importieren',
-      filters: [{ name: 'Multi-Hoster Backup', extensions: ['mhu'] }],
+      filters: [
        { name: 'Multi-Hoster Backup', extensions: ['mhu', 'json'] },
        { name: 'Verschlüsselt (.mhu)', extensions: ['mhu'] },
        { name: 'Klartext (.json)', extensions: ['json'] }
      ],
      properties: ['openFile']
    });
    if (canceled || !filePaths.length) return { ok: false, canceled: true };
@ -1557,15 +1886,26 @@ ipcMain.handle('import-backup', async (_event, legacyPassword) => {
    _lastImportPath = sourcePath;
  }
  let imported;
  const looksLikeJson = buffer.length >= 1 && (buffer[0] === 0x7B || buffer[0] === 0x20 || buffer[0] === 0x0A || buffer[0] === 0x0D || buffer[0] === 0x09 || buffer[0] === 0xEF);
  if (looksLikeJson) {
    try {
      const text = buffer.toString('utf-8').replace(/^\uFEFF/, '');
      imported = JSON.parse(text);
    } catch (err) {
      _lastImportPath = null;
      return { ok: false, error: 'Klartext-Backup ist kein gültiges JSON: ' + (err.message || err) };
    }
  } else {
    try {
      imported = backupCrypto.decrypt(buffer, legacyPassword);
    } catch (err) {
      if (err && err.needsPassword) {
-      return { ok: false, needsPassword: true };
+        return { ok: false, needsPassword: true, hint: 'Falls dieses Backup mit der aktuellen Version erzeugt wurde, ist die Datei vermutlich beim Transfer beschädigt worden (z. B. FTP-Text-Modus). Versuch es mit einem Klartext-JSON-Export.' };
      }
      _lastImportPath = null;
      throw err;
    }
  }
  _lastImportPath = null;
  // Validate imported data has required structure
  if (!imported || typeof imported !== 'object' || !imported.hosters || !imported.hosterSettings || !imported.globalSettings) {
@ -1682,13 +2022,9 @@ ipcMain.handle('app:check-updates', async () => {
 ipcMain.handle('app:install-update', () => {
  installUpdate((progress) => {
-    if (mainWindow && !mainWindow.isDestroyed()) {
+    safeSend('app:update-progress', progress);
      mainWindow.webContents.send('app:update-progress', progress);
    }
  }).catch((err) => {
-    if (mainWindow && !mainWindow.isDestroyed()) {
+    safeSend('app:update-progress', { stage: 'error', error: err.message });
      mainWindow.webContents.send('app:update-progress', { stage: 'error', error: err.message });
    }
  });
  return { started: true };
 });
@ -1767,9 +2103,7 @@ function startFolderMonitor(settings) {
    folderMonitor.removeAllListeners();
    folderMonitor.on('new-files', (files) => {
      debugLog(`folder-monitor: ${files.length} new file(s)`);
-      if (mainWindow && !mainWindow.isDestroyed()) {
+      safeSend('folder-monitor:new-files', files);
        mainWindow.webContents.send('folder-monitor:new-files', files);
      }
    });
    folderMonitor.on('error', (err) => {
      debugLog(`folder-monitor error: ${err.message}`);
@ -2013,9 +2347,7 @@ ipcMain.handle('remote:get-capture-source-id', async () => {
 // IPC: Client count updates from capture window
 ipcMain.on('remote:client-count', (_event, count) => {
-  if (mainWindow && !mainWindow.isDestroyed()) {
+  safeSend('remote:client-count', count);
    mainWindow.webContents.send('remote:client-count', count);
  }
 });
 // IPC: Remote settings
@ -2120,7 +2452,7 @@ ipcMain.on('drop-target:files', (_event, paths) => {
      mainWindow.show();
      mainWindow.focus();
    }
-    mainWindow.webContents.send('drop-target:files', paths);
+    safeSend('drop-target:files', paths);
  }
 });
@ -2157,9 +2489,7 @@ function handleShutdownAfterFinish() {
  const { exec } = require('child_process');
  // Notify renderer
-  if (mainWindow && !mainWindow.isDestroyed()) {
+  safeSend('shutdown-countdown', { mode: shutdownMode, seconds: 60 });
    mainWindow.webContents.send('shutdown-countdown', { mode: shutdownMode, seconds: 60 });
  }
  // Clear any previous countdown to prevent orphaned timers
  if (shutdownTimer) clearTimeout(shutdownTimer);
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "multi-hoster-uploader",
-  "version": "3.3.40",
+  "version": "3.3.54",
  "description": "Upload files to doodstream, voe, vidmoly, byse simultaneously",
  "main": "main.js",
  "scripts": {
--- a/preload.js
+++ b/preload.js
@ -93,6 +93,9 @@ contextBridge.exposeInMainWorld('api', {
  onUploadProgress: (callback) => {
    ipcRenderer.on('upload-progress', (_event, data) => callback(data));
  },
  onUploadProgressBatch: (callback) => {
    ipcRenderer.on('upload-progress-batch', (_event, batch) => callback(batch));
  },
  onUploadBatchDone: (callback) => {
    ipcRenderer.on('upload-batch-done', (_event, data) => callback(data));
  },
@ -110,6 +113,14 @@ contextBridge.exposeInMainWorld('api', {
  },
  openLogFolder: () => ipcRenderer.invoke('open-log-folder'),
  getJobLog: (jobId) => ipcRenderer.invoke('get-job-log', jobId),
  getSessionFailedAccounts: () => ipcRenderer.invoke('get-session-failed-accounts'),
  resetSessionFailedAccount: (payload) => ipcRenderer.invoke('reset-session-failed-account', payload),
  resetAllSessionFailedAccounts: () => ipcRenderer.invoke('reset-all-session-failed-accounts'),
  getLogPaths: () => ipcRenderer.invoke('get-log-paths'),
  revealLogFile: (target) => ipcRenderer.invoke('reveal-log-file', target),
  setLogVerbose: (enabled) => ipcRenderer.invoke('set-log-verbose', enabled),
  createSupportBundle: () => ipcRenderer.invoke('create-support-bundle'),
  getAppInfo: () => ipcRenderer.invoke('get-app-info'),
  onLogPathAutoUpdated: (callback) => {
    ipcRenderer.on('log-path-auto-updated', (_event, data) => callback(data));
  },
--- a/renderer/app.js
+++ b/renderer/app.js
@ -63,10 +63,12 @@ const queueSortState = { key: 'filename', direction: 'asc' };
 // History state
 let historyRowsData = [];
 let historySortState = { key: 'date', direction: 'desc' };
 let _historySortClicked = false;
 // Session-specific files for the "Files" panel (resets each session)
 let sessionFilesData = [];
 const recentSortState = { key: 'date', direction: 'desc' };
 let _recentSortClicked = false;
 const selectedRecentIds = new Set();
 // Maintained incrementally — avoids O(n) filter() scans every 250ms in the status bar.
 let _sessionDoneCount = 0;
@ -75,6 +77,19 @@ let _sessionErrorCount = 0;
 // Huge with thousands of rows × thousands of incoming results.
 const _sessionFileKeys = new Set();
 window.addEventListener('error', (e) => {
  try {
    const msg = `RENDERER ERROR: ${e.message} at ${e.filename}:${e.lineno}:${e.colno}${e.error && e.error.stack ? '\n' + e.error.stack : ''}`;
    if (window.api && window.api.debugLog) window.api.debugLog(msg);
  } catch {}
 });
 window.addEventListener('unhandledrejection', (e) => {
  try {
    const reason = e.reason && e.reason.stack ? e.reason.stack : (e.reason && e.reason.message) || String(e.reason);
    if (window.api && window.api.debugLog) window.api.debugLog(`RENDERER UNHANDLED REJECTION: ${reason}`);
  } catch {}
 });
 // --- Init ---
 async function init() {
  config = await window.api.getConfig();
@ -92,6 +107,7 @@ async function init() {
  setupDragDrop();
  restoreQueueColumnWidths();
  loadHistory();
  _refreshSessionFailedSnapshot();
  renderRecentUploadsPanel();
  updateUploadView();
  updateStatusBar();
@ -107,24 +123,19 @@ async function init() {
  window.api.onUpdateAvailable(showUpdateBanner);
  window.api.onUpdateProgress(handleUpdateProgress);
  // Upload event listeners — debug log only on state transitions; the 'uploading'
  // tick fires 4×/sec per active job and an IPC roundtrip per event would
  // backlog the renderer↔main channel with hundreds of messages/sec.
  window.api.onUploadProgress((data) => {
    if (data.status !== 'uploading') {
      window.api.debugLog('RX upload-progress: ' + data.status + ' ' + data.hoster + ' ' + (data.fileName || ''));
    }
    handleProgress(data);
  });
  if (window.api.onUploadProgressBatch) {
    window.api.onUploadProgressBatch((batch) => {
      if (!Array.isArray(batch)) return;
      for (let i = 0; i < batch.length; i++) handleProgress(batch[i]);
    });
  }
  window.api.onUploadBatchDone((data) => {
    window.api.debugLog('RX upload-batch-done');
    handleBatchDone(data);
  });
  window.api.onUploadStats((data) => {
    // Stats fire every second per upload session — skip while uploading.
    if (data.state !== 'uploading') {
      window.api.debugLog('RX upload-stats: state=' + data.state + ' active=' + data.activeJobs);
    }
    handleStats(data);
  });
  window.api.onShutdownCountdown(handleShutdownCountdown);
@ -1447,7 +1458,7 @@ async function doBackupExport() {
  }
 }
-function askLegacyBackupPassword() {
+function askLegacyBackupPassword(hint) {
  return new Promise((resolve) => {
    const overlay = document.createElement('div');
    overlay.className = 'modal-overlay';
@ -1460,7 +1471,7 @@ function askLegacyBackupPassword() {
    const header = document.createElement('div');
    header.className = 'modal-header';
    const h3 = document.createElement('h3');
-    h3.textContent = 'Passwort erforderlich';
+    h3.textContent = 'Backup nicht entschlüsselbar';
    header.appendChild(h3);
    const body = document.createElement('div');
@ -1468,7 +1479,15 @@ function askLegacyBackupPassword() {
    const p = document.createElement('p');
    p.style.margin = '0 0 10px';
    p.style.fontSize = '13px';
-    p.textContent = 'Dieses Backup wurde mit einem Passwort verschlüsselt.';
+    p.textContent = 'Wenn das Backup mit der alten Passwort-Option (vor v3.0) erstellt wurde, hier eingeben.';
    if (hint) {
      const p2 = document.createElement('p');
      p2.style.margin = '0 0 10px';
      p2.style.fontSize = '12px';
      p2.style.color = 'var(--text-dim)';
      p2.textContent = hint;
      body.appendChild(p2);
    }
    const input = document.createElement('input');
    input.type = 'password';
    input.className = 'key-input';
@ -1512,7 +1531,7 @@ async function doBackupImport(legacyPassword) {
    const result = await window.api.importBackup(pw);
    if (!result || result.canceled) return;
    if (result.needsPassword) {
-      const entered = await askLegacyBackupPassword();
+      const entered = await askLegacyBackupPassword(result.hint);
      if (entered) doBackupImport(entered);
      return;
    }
@ -1877,6 +1896,14 @@ async function cancelUpload() {
 // --- Progress handling ---
 function handleProgress(data) {
  try {
    if (!data || typeof data !== 'object') return;
    _handleProgressImpl(data);
  } catch (err) {
    if (window.api && window.api.debugLog) window.api.debugLog(`handleProgress error: ${err && err.stack ? err.stack : err}`);
  }
 }
 function _handleProgressImpl(data) {
  let job = data.jobId ? _jobIndexById.get(data.jobId) : null;
  if (!job && data.uploadId) job = _jobIndexByUploadId.get(data.uploadId);
  if (!job) {
@ -2056,9 +2083,96 @@ function handleBatchDone(summary) {
  lastUploadStats = { state: 'idle', globalSpeedKbs: 0, totalBytes: lastUploadStats.totalBytes, elapsed: lastUploadStats.elapsed, activeJobs: 0 };
  updateStatusBar();
  _maybeShowBatchSummary(summary);
  _refreshSessionFailedSnapshot();
 }
 let _sessionFailedKeys = new Set();
 async function _refreshSessionFailedSnapshot() {
  if (!window.api || !window.api.getSessionFailedAccounts) return;
  try {
    const keys = await window.api.getSessionFailedAccounts();
    _sessionFailedKeys = new Set(Array.isArray(keys) ? keys : []);
    renderAccounts();
  } catch { /* ignore */ }
 }
 function _maybeShowBatchSummary(summary) {
  if (!window.Stats || !summary) return;
  const buckets = window.Stats.summarizeBatchErrors(summary);
  const total = Object.values(buckets).reduce((n, arr) => n + arr.length, 0);
  if (total === 0) return;
  const modal = document.getElementById('batchSummaryModal');
  if (!modal) return;
  const list = modal.querySelector('#batchSummaryList');
  const retryAllBtn = modal.querySelector('#batchSummaryRetryAll');
  const retryTransientBtn = modal.querySelector('#batchSummaryRetryTransient');
  const closeBtn = modal.querySelector('#batchSummaryClose');
  const order = ['hoster-transient', 'network', 'unknown', 'file-rejected', 'account-error', 'aborted'];
  list.innerHTML = order
    .filter(cat => buckets[cat].length > 0)
    .map(cat => {
      const items = buckets[cat];
      const sample = items.slice(0, 3).map(i => `<li>${escapeHtml(i.fileName)} → ${escapeHtml(i.hoster)}: <em>${escapeHtml(i.error)}</em></li>`).join('');
      const more = items.length > 3 ? `<li><em>… +${items.length - 3} weitere</em></li>` : '';
      const retryable = window.Stats.isRetryableCategory(cat);
      const tag = retryable ? '<span class="batch-cat-tag retryable">erneut versuchbar</span>' : '<span class="batch-cat-tag">manuell</span>';
      return `<div class="batch-cat" data-category="${escapeAttr(cat)}">
        <div class="batch-cat-head"><strong>${escapeHtml(window.Stats.CATEGORY_LABELS[cat] || cat)}</strong> <span class="batch-cat-count">${items.length}</span> ${tag}</div>
        <ul class="batch-cat-list">${sample}${more}</ul>
      </div>`;
    }).join('');
  const transientCount = ['hoster-transient', 'network', 'unknown'].reduce((n, c) => n + buckets[c].length, 0);
  retryTransientBtn.textContent = transientCount > 0 ? `Transiente erneut hochladen (${transientCount})` : 'Keine transienten Fehler';
  retryTransientBtn.disabled = transientCount === 0;
  const allRetryable = total - buckets['aborted'].length;
  retryAllBtn.textContent = `Alle Fehler erneut versuchen (${allRetryable})`;
  retryAllBtn.disabled = allRetryable === 0;
  const close = () => { modal.style.display = 'none'; };
  closeBtn.onclick = close;
  retryAllBtn.onclick = () => { _retryFailedFromBuckets(buckets, false); close(); };
  retryTransientBtn.onclick = () => { _retryFailedFromBuckets(buckets, true); close(); };
  modal.style.display = 'flex';
 }
 function _retryFailedFromBuckets(buckets, transientOnly) {
  const cats = transientOnly ? ['hoster-transient', 'network', 'unknown'] : ['hoster-transient', 'network', 'unknown', 'file-rejected', 'account-error'];
  const toRetry = [];
  for (const cat of cats) {
    for (const item of (buckets[cat] || [])) toRetry.push(item);
  }
  if (toRetry.length === 0) return;
  const jobsToRetry = [];
  for (const item of toRetry) {
    const job = queueJobs.find(j => (j.fileName === item.fileName) && (j.hoster === item.hoster) && (j.status === 'error' || j.status === 'skipped'));
    if (job) {
      job.status = 'queued';
      job.progress = 0;
      job.bytesUploaded = 0;
      job.error = null;
      job.result = null;
      jobsToRetry.push(job);
    }
  }
  if (jobsToRetry.length === 0) { showCopyToast('Keine passenden Jobs für Retry gefunden.'); return; }
  renderQueueTable();
  showCopyToast(`${jobsToRetry.length} Job(s) zum erneuten Upload zurückgesetzt`);
  if (typeof startUpload === 'function') startUpload();
 }
 function handleStats(data) {
  try {
    if (!data || typeof data !== 'object') return;
    _handleStatsImpl(data);
  } catch (err) {
    if (window.api && window.api.debugLog) window.api.debugLog(`handleStats error: ${err && err.stack ? err.stack : err}`);
  }
 }
 function _handleStatsImpl(data) {
  lastUploadStats = {
    state: data.state || 'idle',
    globalSpeedKbs: data.globalSpeedKbs || 0,
@ -2386,7 +2500,7 @@ function _computeQueueStats() {
  }
  _queueStatsCache = { total, remaining, inProgress, done, errors, bytesRemaining, totalSize, remainingSize, inProgressBytes };
-  queueMicrotask(() => { _queueStatsCache = null; });
+  (typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn))(() => { _queueStatsCache = null; });
  return _queueStatsCache;
 }
@ -2447,8 +2561,10 @@ async function executeHealthCheck(hosters, _mode) {
 }
 async function runHealthCheck(mode = 'manual', requestedHosters = null) {
-  if (healthCheckRunning || (uploading && mode === 'manual')) return [];
+  if (healthCheckRunning) {
-  // Build check list: all enabled accounts with creds
+    if (mode === 'manual') showCopyToast('Account-Check läuft bereits.');
    return [];
  }
  let hosters;
  if (Array.isArray(requestedHosters) && requestedHosters.length > 0) {
    hosters = requestedHosters;
@ -2480,6 +2596,36 @@ async function runHealthCheck(mode = 'manual', requestedHosters = null) {
 }
 // --- Settings ---
 async function _renderLogPathsList(el) {
  if (!el || !window.api || !window.api.getLogPaths) return;
  try {
    const paths = await window.api.getLogPaths();
    if (!paths || typeof paths !== 'object') { el.innerHTML = '<span class="hint">Pfade nicht verfügbar.</span>'; return; }
    const entries = [
      ['fileuploader', 'fileuploader.log'],
      ['debug', 'debug.log'],
      ['accountRotation', 'account-rotation.log'],
      ['doodstreamDebug', 'doodstream-debug.log']
    ];
    el.innerHTML = entries.map(([key, label]) => {
      const p = paths[key] || '';
      return `<div style="display:flex;gap:6px;align-items:center;font-size:11px">
        <span style="min-width:160px;color:var(--text-dim)">${escapeHtml(label)}</span>
        <code style="flex:1;font-size:10px;opacity:0.85;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="${escapeAttr(p)}">${escapeHtml(p) || '<nicht gesetzt>'}</code>
        <button class="btn btn-xs btn-secondary" data-reveal-log="${escapeAttr(key)}" title="Im Explorer zeigen">Zeigen</button>
      </div>`;
    }).join('');
    el.querySelectorAll('[data-reveal-log]').forEach(btn => {
      btn.addEventListener('click', () => {
        const target = btn.getAttribute('data-reveal-log');
        if (window.api && window.api.revealLogFile) window.api.revealLogFile(target).catch(() => {});
      });
    });
  } catch (err) {
    el.innerHTML = `<span class="hint">Fehler: ${escapeHtml(err.message || String(err))}</span>`;
  }
 }
 function renderSettings() {
  const container = document.getElementById('settingsHosters');
  container.innerHTML = '';
@ -2550,9 +2696,59 @@ function renderSettings() {
        </select>
        <span class="hint">Pro Session = neue Datei bei jedem App-Start; nach komplettem Schließen + erneutem Öffnen beginnt eine neue Session.</span>
      </div>
      <div class="settings-row">
        <label>Verbose Logging</label>
        <label class="checkbox-row" style="margin:0">
          <input type="checkbox" class="settings-autosave" id="logVerboseInput" ${globalSettings.logVerbose ? 'checked' : ''}>
          <span>DEBUG-Einträge in debug.log schreiben (Performance ↓, Diagnostik ↑)</span>
        </label>
      </div>
      <div class="settings-section-label">Diagnose</div>
      <div class="settings-row" id="logPathsBlock">
        <label>Log-Dateien</label>
        <div class="log-paths-list" id="logPathsList" style="flex:1;display:flex;flex-direction:column;gap:4px">
          <span class="hint">Wird geladen…</span>
        </div>
      </div>
      <div class="settings-row">
        <label>Support-Paket</label>
        <button class="btn btn-xs btn-secondary" id="createSupportBundleBtn" title="Sammelt alle Logs + sanitierte Config (Credentials maskiert) + App-Versionen in eine einzelne .txt-Datei zum Teilen.">Diagnose-Paket exportieren</button>
        <span class="hint" id="supportBundleHint">Eine .txt mit Logs + sanitierter Config; Passwörter/API-Keys werden vor dem Speichern maskiert.</span>
      </div>
    </div>
  `;
  container.appendChild(generalPanel);
  _renderLogPathsList(generalPanel.querySelector('#logPathsList'));
  const verboseInput = generalPanel.querySelector('#logVerboseInput');
  if (verboseInput) {
    verboseInput.addEventListener('change', () => {
      if (window.api && window.api.setLogVerbose) window.api.setLogVerbose(verboseInput.checked).catch(() => {});
    });
  }
  const sbBtn = generalPanel.querySelector('#createSupportBundleBtn');
  if (sbBtn) {
    sbBtn.addEventListener('click', async () => {
      const hint = generalPanel.querySelector('#supportBundleHint');
      sbBtn.disabled = true;
      const prevText = sbBtn.textContent;
      sbBtn.textContent = 'Exportiere…';
      try {
        const res = await window.api.createSupportBundle();
        if (res && res.ok) {
          if (hint) hint.textContent = `Gespeichert: ${res.path} (${(res.bytes/1024).toFixed(1)} KB)`;
        } else if (res && res.canceled) {
          if (hint) hint.textContent = 'Abgebrochen.';
        } else {
          if (hint) hint.textContent = `Fehler: ${(res && res.error) || 'unbekannt'}`;
        }
      } catch (err) {
        if (hint) hint.textContent = `Fehler: ${err.message || err}`;
      } finally {
        sbBtn.disabled = false;
        sbBtn.textContent = prevText;
      }
    });
  }
  // Toggle general panel
  generalPanel.querySelector('.hoster-panel-header').addEventListener('click', () => {
@ -3038,11 +3234,16 @@ function _buildAccountCardHtml(name, account, idx) {
  const toggleLabel = isDisabled ? 'Aktivieren' : 'Deaktivieren';
  const priorityLabel = idx === 0 ? 'Primär' : `Fallback #${idx}`;
  const isSessionPaused = _sessionFailedKeys.has(`${name}:${account.id}`);
  const sessionPausedBadge = isSessionPaused
    ? `<span class="account-session-paused" title="Account wurde diese Session als fehlerhaft markiert. Klick = Wieder als aktiv markieren.">Pausiert (Session) <button class="account-session-reactivate" data-account-reactivate="${account.id}" data-account-reactivate-hoster="${name}" title="Wieder aktivieren">↻</button></span>`
    : '';
  return `
-    <div class="account-card${isDisabled ? ' account-disabled' : ''}" data-account-id="${account.id}" data-account-hoster="${name}" draggable="true">
+    <div class="account-card${isDisabled ? ' account-disabled' : ''}${isSessionPaused ? ' account-session-paused-card' : ''}" data-account-id="${account.id}" data-account-hoster="${name}" draggable="true">
      <div class="account-card-drag-handle" title="Ziehen zum Sortieren">&#9776;</div>
      <div class="account-card-info">
-        <div class="account-card-title">${escapeHtml(getAccountDisplayName(name, account))} <span class="account-priority-badge">${priorityLabel}</span></div>
+        <div class="account-card-title">${escapeHtml(getAccountDisplayName(name, account))} <span class="account-priority-badge">${priorityLabel}</span> ${sessionPausedBadge}</div>
        <div class="account-card-subtitle" title="${escapeAttr(subtitleText)}">${escapeHtml(subtitleText)}${st.message && !isDisabled ? ` • ${escapeHtml(st.message)}` : ''}</div>
      </div>
      <span class="account-status status-${statusClass}">
@ -3187,6 +3388,10 @@ function _buildAccountHosterGroupHtml(name, accounts) {
  let cardsHtml = '';
  accounts.forEach((account, idx) => { cardsHtml += _buildAccountCardHtml(name, account, idx); });
  const bodyStyle = isOpen ? '' : 'style="display:none"';
  const lifeStat = _hosterLifetimeStat(name);
  const lifeMeta = lifeStat && lifeStat.total > 0
    ? `<span class="account-hoster-group-meta" title="Erfolgsrate aus den letzten ${lifeStat.total} Uploads dieses Hosters">${Math.round(lifeStat.rate * 100)}% ok (${lifeStat.total})</span>`
    : '';
  return `<div class="account-hoster-group" data-hoster-group="${name}">
    <div class="account-hoster-group-header" data-hoster-toggle="${name}">
      <span class="panel-arrow">${arrow}</span>
@ -3195,11 +3400,21 @@ function _buildAccountHosterGroupHtml(name, accounts) {
      <span class="account-hoster-group-count">${countLabel}</span>
      ${summary.disabled ? `<span class="account-hoster-group-meta">${summary.disabled} deaktiviert</span>` : ''}
      ${summary.error ? `<span class="account-hoster-group-meta error">${summary.error} Fehler</span>` : ''}
      ${lifeMeta}
    </div>
    <div class="account-hoster-group-body" ${bodyStyle}>${cardsHtml}</div>
  </div>`;
 }
 let _hosterLifetimeCache = null;
 function _hosterLifetimeStat(name) {
  if (!_hosterLifetimeCache && window.Stats && Array.isArray(window._historyForStats)) {
    _hosterLifetimeCache = window.Stats.summarizePerHoster(window._historyForStats, { lastNBatches: 50 });
  }
  return _hosterLifetimeCache ? _hosterLifetimeCache[name] : null;
 }
 function _invalidateHosterLifetimeCache() { _hosterLifetimeCache = null; }
 // Single set of delegated listeners on the accounts container. Bound once on
 // the first render and reused for every subsequent in-place update / card
 // swap. Previously we rebound 4 × N button listeners + 5 × N drag listeners
@ -3229,6 +3444,18 @@ function bindAccountListeners(container) {
    if (btn.dataset.accountEdit) return openAccountModal(btn.dataset.accountEdit);
    if (btn.dataset.accountDelete) return openDeleteAccountModal(btn.dataset.accountDelete);
    if (btn.dataset.accountCheck) return checkSingleAccount(btn.dataset.accountCheck);
    if (btn.dataset.accountReactivate) {
      const accountId = btn.dataset.accountReactivate;
      const hoster = btn.dataset.accountReactivateHoster;
      if (!hoster || !accountId) return;
      e.stopPropagation();
      window.api.resetSessionFailedAccount({ hoster, accountId }).then(() => {
        _sessionFailedKeys.delete(`${hoster}:${accountId}`);
        renderAccounts();
        showCopyToast(`${getHosterLabel(hoster)} Account wieder aktiv — nächste Batch verwendet ihn`);
      }).catch(() => {});
      return;
    }
  });
  let draggedCard = null;
@ -3464,7 +3691,10 @@ async function deleteAccount(accountId) {
  // Fire-and-forget the persist. The earlier `await getConfig()` round-trip
  // was redundant (we already have the truth in memory) and was the main
  // source of perceived lag on add/delete.
-  window.api.saveConfig({ hosters: config.hosters }).catch(() => {});
+  window.api.saveConfig({ hosters: config.hosters }).catch((err) => {
    if (window.api && window.api.debugLog) window.api.debugLog(`deleteAccount saveConfig failed: ${err && err.message ? err.message : err}`);
    showCopyToast('Account-Löschung konnte nicht persistiert werden — bitte erneut versuchen.');
  });
 }
 function readAccountCredsFromModal(authType) {
@ -3670,6 +3900,15 @@ async function _commitAccount(ctx, creds, validatedStatus, validatedMessage) {
    const idx = config.hosters[ctx.hosterName].findIndex(a => a.id === accountId);
    if (idx >= 0) {
      config.hosters[ctx.hosterName][idx] = { ...config.hosters[ctx.hosterName][idx], ...creds };
    } else {
      _accountModalBusy = false;
      const _sb = document.getElementById('saveAccountBtn'); if (_sb) _sb.disabled = false;
      const _st = document.getElementById('accountModalStatus');
      if (_st) {
        _st.textContent = 'Account nicht mehr in der Config — wurde extern gelöscht. Modal schließen und neu anlegen.';
        _st.className = 'account-modal-status error';
      }
      return;
    }
  } else {
    accountId = `${ctx.hosterName}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@ -3718,6 +3957,8 @@ function _hideOtpField() {
 // --- History ---
 async function loadHistory() {
  const history = await window.api.getHistory();
  window._historyForStats = history || [];
  _invalidateHosterLifetimeCache();
  const container = document.getElementById('historyContainer');
  if (!history || history.length === 0) {
@ -3915,17 +4156,32 @@ function renderHistoryTable(container) {
    ${headerCell('date', 'Date')}${headerCell('filename', 'Filename')}${headerCell('host', 'Host')}${headerCell('link', 'Link')}
  </tr></thead><tbody>`;
-  rows.forEach(row => {
+  const parts = [html];
-    html += `<tr class="history-row${row.isError ? ' error' : ''}" data-link="${escapeAttr(row.link)}">
+  const len = rows.length;
-      <td class="col-date">${escapeHtml(row.date)}</td>
+  for (let i = 0; i < len; i++) {
-      <td class="col-filename">${escapeHtml(row.filename)}</td>
+    const row = rows[i];
-      <td class="col-host">${escapeHtml(row.host)}</td>
+    const link = row.link || '';
-      <td class="col-link">${escapeHtml(row.link)}</td>
+    const date = escapeHtml(row.date);
-    </tr>`;
+    const filename = escapeHtml(row.filename);
-  });
+    const host = escapeHtml(row.host);
-
+    const linkHtml = escapeHtml(link);
-  html += '</tbody></table>';
+    const linkAttr = escapeAttr(link);
-  container.innerHTML = html;
+    parts.push('<tr class="history-row');
    if (row.isError) parts.push(' error');
    parts.push('" data-link="');
    parts.push(linkAttr);
    parts.push('"><td class="col-date">');
    parts.push(date);
    parts.push('</td><td class="col-filename">');
    parts.push(filename);
    parts.push('</td><td class="col-host">');
    parts.push(host);
    parts.push('</td><td class="col-link">');
    parts.push(linkHtml);
    parts.push('</td></tr>');
  }
  parts.push('</tbody></table>');
  container.innerHTML = parts.join('');
  // Delegated listeners: bind once per render-target instead of once per
  // row/header. With a 5000-row history the per-row bind path was a
@ -3937,8 +4193,14 @@ function renderHistoryTable(container) {
      const th = e.target.closest('th.sortable');
      if (th && container.contains(th)) {
        const key = th.dataset.historySort;
-        if (historySortState.key === key) historySortState.direction = historySortState.direction === 'asc' ? 'desc' : 'asc';
+        const defaultDir = key === 'date' ? 'desc' : 'asc';
-        else { historySortState.key = key; historySortState.direction = key === 'date' ? 'desc' : 'asc'; }
+        if (!_historySortClicked || historySortState.key !== key) {
          _historySortClicked = true;
          historySortState.key = key;
          historySortState.direction = defaultDir;
        } else {
          historySortState.direction = historySortState.direction === 'asc' ? 'desc' : 'asc';
        }
        renderHistoryTable(container);
        return;
      }
@ -3994,11 +4256,13 @@ function setupListeners() {
    const th = e.target.closest('th[data-recent-sort]');
    if (!th) return;
    const key = th.dataset.recentSort;
-    if (recentSortState.key === key) {
+    const defaultDir = key === 'date' ? 'desc' : 'asc';
-      recentSortState.direction = recentSortState.direction === 'desc' ? 'asc' : 'desc';
+    if (!_recentSortClicked || recentSortState.key !== key) {
-    } else {
+      _recentSortClicked = true;
      recentSortState.key = key;
-      recentSortState.direction = key === 'date' ? 'desc' : 'asc';
+      recentSortState.direction = defaultDir;
    } else {
      recentSortState.direction = recentSortState.direction === 'desc' ? 'asc' : 'desc';
    }
    renderRecentUploadsPanel();
  });
@ -4305,14 +4569,20 @@ async function importUploadLog() {
 // --- Link operations ---
 function copyAllLinks() {
-  const links = queueJobs
+  const rows = queueJobs
    .filter(j => j.status === 'done' && j.result)
-    .map(j => j.result.download_url || j.result.embed_url || '')
+    .map(j => ({
-    .filter(Boolean);
+      fileName: j.fileName || '',
-  if (links.length > 0) {
+      hoster: j.hoster || '',
-    window.api.copyToClipboard(links.join('\n'));
+      url: j.result.download_url || j.result.embed_url || ''
-    showCopyToast(`${links.length} Links kopiert`);
+    }))
-  }
+    .filter(r => r.url);
  if (rows.length === 0) return;
  const formatEl = document.getElementById('linkExportFormat');
  const fmt = (formatEl && formatEl.value) || 'plain';
  const text = window.Stats ? window.Stats.formatLinks(rows, fmt) : rows.map(r => r.url).join('\n');
  window.api.copyToClipboard(text);
  showCopyToast(`${rows.length} Link${rows.length === 1 ? '' : 's'} als ${fmt.toUpperCase()} kopiert`);
 }
 // --- Utilities ---
@ -4586,4 +4856,15 @@ function updateStatsPanel() {
 }
 // --- Start ---
-init();
+init().catch((err) => {
  try {
    if (window.api && window.api.debugLog) window.api.debugLog(`init failed: ${err && err.stack ? err.stack : err}`);
    const root = document.getElementById('app') || document.body;
    if (root) {
      const banner = document.createElement('div');
      banner.style.cssText = 'position:fixed;top:0;left:0;right:0;background:#5a1e1e;color:#fff;padding:8px;z-index:99999;font-family:sans-serif;font-size:13px';
      banner.textContent = 'Initialisierung fehlgeschlagen: ' + (err && err.message ? err.message : err) + ' — bitte Diagnose-Paket exportieren oder Programm neu starten.';
      root.appendChild(banner);
    }
  } catch {}
 });
--- a/renderer/index.html
+++ b/renderer/index.html
@ -93,6 +93,14 @@
        <div class="queue-actions" id="queueActions" style="display:none">
          <button class="btn btn-xs btn-primary" id="copyAllLinksBtn">Alle Links kopieren</button>
          <select class="hs-input" id="linkExportFormat" title="Ausgabe-Format der kopierten Links" style="max-width:none;width:auto;min-width:130px">
            <option value="plain">Plaintext</option>
            <option value="bbcode">BBCode</option>
            <option value="markdown">Markdown</option>
            <option value="html">HTML</option>
            <option value="csv">CSV</option>
            <option value="json">JSON</option>
          </select>
          <button class="btn btn-xs btn-secondary" id="retryFailedBtn" style="display:none">Fehlgeschlagene erneut</button>
          <button class="btn btn-xs btn-secondary" id="importLogBtn" title="Log importieren — bereits hochgeladene aus Queue entfernen">Log importieren</button>
        </div>
@ -334,9 +342,26 @@
    </div>
  </div>
  <div class="modal" id="batchSummaryModal" style="display:none">
    <div class="modal-content" style="max-width:680px">
      <div class="modal-header">
        <h2>Batch-Zusammenfassung</h2>
        <button class="icon-btn" id="batchSummaryClose" aria-label="Schließen">&times;</button>
      </div>
      <div class="modal-body">
        <div id="batchSummaryList"></div>
      </div>
      <div class="modal-footer">
        <button class="btn btn-secondary" id="batchSummaryRetryTransient">Transiente erneut hochladen</button>
        <button class="btn btn-primary" id="batchSummaryRetryAll">Alle Fehler erneut versuchen</button>
      </div>
    </div>
  </div>
  <script src="../lib/queue-prune.js"></script>
  <script src="../lib/queue-dedup.js"></script>
  <script src="../lib/log-mode.js"></script>
  <script src="../lib/stats.js"></script>
  <script src="../lib/throttled-cache.js"></script>
  <script src="../lib/coalesced-set.js"></script>
  <script src="app.js"></script>
--- a/renderer/styles.css
+++ b/renderer/styles.css
@ -727,6 +727,7 @@ body.col-resizing, body.col-resizing * { cursor: col-resize !important; user-sel
 }
 .key-input:focus, .hs-input:focus { border-color: var(--accent); outline: none; }
 .hs-input { max-width: 100px; }
 select.hs-input { max-width: none; width: auto; min-width: 140px; }
 .hint { font-size: 10px; color: var(--text-dim); }
 .settings-section-label {
  font-size: 10px;
@ -915,6 +916,40 @@ body.col-resizing, body.col-resizing * { cursor: col-resize !important; user-sel
  color: var(--danger, #e57373);
  background: rgba(229, 115, 115, 0.12);
 }
 .account-session-paused {
  display: inline-flex;
  align-items: center;
  gap: 4px;
  font-size: 10px;
  color: #f0c36c;
  background: rgba(240, 195, 108, 0.12);
  padding: 1px 6px;
  border-radius: 4px;
  margin-left: 6px;
 }
 .account-session-reactivate {
  background: none;
  border: none;
  color: inherit;
  cursor: pointer;
  font-size: 12px;
  line-height: 1;
  padding: 0 2px;
 }
 .account-session-reactivate:hover { color: #fff; }
 .account-session-paused-card { opacity: 0.85; }
 .batch-cat {
  margin-bottom: 10px;
  padding: 6px 8px;
  border-radius: 6px;
  background: rgba(255,255,255,0.03);
 }
 .batch-cat-head { display: flex; align-items: center; gap: 8px; margin-bottom: 4px; font-size: 13px; }
 .batch-cat-count { color: var(--text-muted); font-variant-numeric: tabular-nums; }
 .batch-cat-tag { font-size: 10px; padding: 1px 6px; border-radius: 4px; background: rgba(255,255,255,0.06); color: var(--text-muted); }
 .batch-cat-tag.retryable { background: rgba(76, 175, 80, 0.18); color: #a5d6a7; }
 .batch-cat-list { margin: 0; padding-left: 18px; font-size: 11px; color: var(--text-muted); }
 .batch-cat-list em { color: var(--text-muted); font-style: italic; }
 .account-hoster-group-body {
  padding: 8px;
  border-top: 1px solid var(--border);
--- a/tests/file-probe.test.js
+++ b/tests/file-probe.test.js
@ -0,0 +1,100 @@
 const test = require('node:test');
 const assert = require('node:assert');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { detectKind, isVideoLikeKind, probeFileHead, summarizeFileStat } = require('../lib/file-probe');
 function tmpWrite(name, buf) {
  const p = path.join(os.tmpdir(), `mhu-probe-${Date.now()}-${name}`);
  fs.writeFileSync(p, buf);
  return p;
 }
 test('detectKind recognizes ISO-MP4 (ftyp box at offset 4)', () => {
  const buf = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x20]), Buffer.from('ftypisom', 'ascii'), Buffer.alloc(8, 0)]);
  assert.strictEqual(detectKind(buf), 'mp4-iso');
  assert.strictEqual(isVideoLikeKind('mp4-iso'), true);
 });
 test('detectKind recognizes Matroska / WebM EBML header', () => {
  const buf = Buffer.from([0x1A, 0x45, 0xDF, 0xA3, 0x01, 0x00]);
  assert.strictEqual(detectKind(buf), 'matroska');
  assert.strictEqual(isVideoLikeKind('matroska'), true);
 });
 test('detectKind recognizes AVI (RIFF...AVI )', () => {
  const buf = Buffer.concat([Buffer.from('RIFF', 'ascii'), Buffer.from([0x00, 0x00, 0x00, 0x00]), Buffer.from('AVI ', 'ascii')]);
  assert.strictEqual(detectKind(buf), 'avi');
 });
 test('detectKind recognizes FLV', () => {
  const buf = Buffer.concat([Buffer.from('FLV', 'ascii'), Buffer.from([0x01])]);
  assert.strictEqual(detectKind(buf), 'flv');
 });
 test('detectKind recognizes ASF (WMV)', () => {
  const buf = Buffer.from([0x30, 0x26, 0xB2, 0x75, 0x00, 0x00]);
  assert.strictEqual(detectKind(buf), 'asf-wmv');
 });
 test('detectKind recognizes MPEG-PS (00 00 01 BA)', () => {
  const buf = Buffer.from([0x00, 0x00, 0x01, 0xBA, 0x00]);
  assert.strictEqual(detectKind(buf), 'mpeg-ps');
 });
 test('detectKind recognizes JPEG (non-video)', () => {
  const buf = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]);
  assert.strictEqual(detectKind(buf), 'jpeg');
  assert.strictEqual(isVideoLikeKind('jpeg'), false);
 });
 test('detectKind recognizes HTML response (non-video)', () => {
  const buf = Buffer.from('<!DOCTYPE html><html><head>', 'ascii');
  assert.strictEqual(detectKind(buf), 'html');
  assert.strictEqual(isVideoLikeKind('html'), false);
 });
 test('detectKind returns empty for zero-length and unknown for noise', () => {
  assert.strictEqual(detectKind(Buffer.alloc(0)), 'empty');
  assert.strictEqual(detectKind(Buffer.from([0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF])), 'unknown');
 });
 test('probeFileHead reads first bytes and returns hex + kind for an MP4-like file', async () => {
  const mp4Head = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x20]), Buffer.from('ftypisom', 'ascii'), Buffer.alloc(16, 0xAA)]);
  const p = tmpWrite('fake.mp4', mp4Head);
  try {
    const res = await probeFileHead(p, 64);
    assert.strictEqual(res.ok, true);
    assert.strictEqual(res.kind, 'mp4-iso');
    assert.strictEqual(res.isVideoLike, true);
    assert.ok(res.headHex.startsWith('0000002066747970'));
    assert.strictEqual(res.bytesRead, mp4Head.length);
  } finally {
    fs.unlinkSync(p);
  }
 });
 test('probeFileHead returns ok:false with kind=unreadable for missing file', async () => {
  const res = await probeFileHead(path.join(os.tmpdir(), `does-not-exist-${Date.now()}.mp4`), 32);
  assert.strictEqual(res.ok, false);
  assert.strictEqual(res.kind, 'unreadable');
  assert.ok(res.error);
 });
 test('summarizeFileStat returns size + mtime for a real file', () => {
  const p = tmpWrite('stat.bin', Buffer.alloc(123, 0xCC));
  try {
    const stat = summarizeFileStat(p);
    assert.strictEqual(stat.size, 123);
    assert.strictEqual(stat.isFile, true);
    assert.ok(stat.mtime);
  } finally {
    fs.unlinkSync(p);
  }
 });
 test('summarizeFileStat returns error for missing file', () => {
  const stat = summarizeFileStat(path.join(os.tmpdir(), `does-not-exist-${Date.now()}.bin`));
  assert.ok(stat.error);
 });
--- a/tests/stats.test.js
+++ b/tests/stats.test.js
@ -0,0 +1,132 @@
 const test = require('node:test');
 const assert = require('node:assert');
 const {
  summarizePerHoster,
  classifyErrorCategory,
  summarizeBatchErrors,
  isRetryableCategory
 } = require('../lib/stats');
 function makeBatch(timestamp, results) {
  return {
    id: 'b-' + timestamp,
    timestamp: new Date(timestamp).toISOString(),
    files: [{ name: 'foo.mp4', size: 1, results }]
  };
 }
 test('summarizePerHoster counts ok and fail per hoster across all batches', () => {
  const history = [
    makeBatch(1, [
      { hoster: 'voe.sx', status: 'done' },
      { hoster: 'byse.sx', status: 'error', error: 'Not video file format' }
    ]),
    makeBatch(2, [
      { hoster: 'voe.sx', status: 'done' },
      { hoster: 'voe.sx', status: 'error', error: 'CSRF' },
      { hoster: 'byse.sx', status: 'done' }
    ])
  ];
  const s = summarizePerHoster(history);
  assert.strictEqual(s['voe.sx'].ok, 2);
  assert.strictEqual(s['voe.sx'].fail, 1);
  assert.strictEqual(s['voe.sx'].total, 3);
  assert.strictEqual(Math.round(s['voe.sx'].rate * 100), 67);
  assert.strictEqual(s['byse.sx'].ok, 1);
  assert.strictEqual(s['byse.sx'].fail, 1);
  assert.strictEqual(s['byse.sx'].rate, 0.5);
 });
 test('summarizePerHoster honors sinceMs cutoff', () => {
  const history = [
    makeBatch(1000, [{ hoster: 'voe.sx', status: 'done' }]),
    makeBatch(5000, [{ hoster: 'voe.sx', status: 'error', error: 'x' }])
  ];
  const s = summarizePerHoster(history, { sinceMs: 3000 });
  assert.strictEqual(s['voe.sx'].ok, 0);
  assert.strictEqual(s['voe.sx'].fail, 1);
 });
 test('summarizePerHoster honors lastNBatches (newest first)', () => {
  const history = [
    makeBatch(1000, [{ hoster: 'voe.sx', status: 'done' }]),
    makeBatch(2000, [{ hoster: 'voe.sx', status: 'done' }]),
    makeBatch(3000, [{ hoster: 'voe.sx', status: 'error', error: 'x' }])
  ];
  const s = summarizePerHoster(history, { lastNBatches: 1 });
  assert.strictEqual(s['voe.sx'].ok, 0);
  assert.strictEqual(s['voe.sx'].fail, 1);
 });
 test('summarizePerHoster handles empty / malformed input', () => {
  assert.deepStrictEqual(summarizePerHoster(null), {});
  assert.deepStrictEqual(summarizePerHoster([]), {});
  assert.deepStrictEqual(summarizePerHoster([{ id: 'x', files: null }]), {});
 });
 test('classifyErrorCategory: file-rejected phrases', () => {
  assert.strictEqual(classifyErrorCategory('Byse lehnte Datei ab: Not video file format'), 'file-rejected');
  assert.strictEqual(classifyErrorCategory('Duplicate file already exists'), 'file-rejected');
  assert.strictEqual(classifyErrorCategory('Datei zu groß (Max: 5 GB)'), 'file-rejected');
 });
 test('classifyErrorCategory: account-error phrases', () => {
  assert.strictEqual(classifyErrorCategory('Quota exceeded'), 'account-error');
  assert.strictEqual(classifyErrorCategory('account banned'), 'account-error');
  assert.strictEqual(classifyErrorCategory('not enough disk space'), 'account-error');
 });
 test('classifyErrorCategory: hoster-transient phrases', () => {
  assert.strictEqual(classifyErrorCategory('CSRF-Token nicht gefunden'), 'hoster-transient');
  assert.strictEqual(classifyErrorCategory('Kein Upload-Server erhalten: server busy'), 'hoster-transient');
  assert.strictEqual(classifyErrorCategory('Kein Filecode'), 'hoster-transient');
 });
 test('classifyErrorCategory: network phrases', () => {
  assert.strictEqual(classifyErrorCategory('socket hang up'), 'network');
  assert.strictEqual(classifyErrorCategory('fetch failed'), 'network');
  assert.strictEqual(classifyErrorCategory('Timeout while reading'), 'network');
 });
 test('classifyErrorCategory: aborted is its own bucket (not retryable)', () => {
  assert.strictEqual(classifyErrorCategory('Abgebrochen'), 'aborted');
  assert.strictEqual(isRetryableCategory('aborted'), false);
 });
 test('classifyErrorCategory: unknown for everything else', () => {
  assert.strictEqual(classifyErrorCategory(''), 'unknown');
  assert.strictEqual(classifyErrorCategory(null), 'unknown');
  assert.strictEqual(classifyErrorCategory('Some weird thing'), 'unknown');
 });
 test('summarizeBatchErrors buckets results by category', () => {
  const summary = {
    files: [
      { name: 'a.mp4', results: [
        { hoster: 'voe.sx', status: 'done' },
        { hoster: 'byse.sx', status: 'error', error: 'Not video file format' }
      ] },
      { name: 'b.mp4', results: [
        { hoster: 'voe.sx', status: 'error', error: 'CSRF' },
        { hoster: 'doodstream.com', status: 'error', error: 'socket hang up' }
      ] }
    ]
  };
  const buckets = summarizeBatchErrors(summary);
  assert.strictEqual(buckets['file-rejected'].length, 1);
  assert.strictEqual(buckets['file-rejected'][0].hoster, 'byse.sx');
  assert.strictEqual(buckets['hoster-transient'].length, 1);
  assert.strictEqual(buckets['hoster-transient'][0].hoster, 'voe.sx');
  assert.strictEqual(buckets['network'].length, 1);
  assert.strictEqual(buckets['network'][0].hoster, 'doodstream.com');
  assert.strictEqual(buckets['account-error'].length, 0);
 });
 test('isRetryableCategory: only transient + network + unknown retry-worthy', () => {
  assert.strictEqual(isRetryableCategory('hoster-transient'), true);
  assert.strictEqual(isRetryableCategory('network'), true);
  assert.strictEqual(isRetryableCategory('unknown'), true);
  assert.strictEqual(isRetryableCategory('file-rejected'), false);
  assert.strictEqual(isRetryableCategory('account-error'), false);
  assert.strictEqual(isRetryableCategory('aborted'), false);
 });
--- a/tests/support-bundle.test.js
+++ b/tests/support-bundle.test.js
@ -0,0 +1,94 @@
 const test = require('node:test');
 const assert = require('node:assert');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { sanitizeConfig, collectFile, buildSupportBundleText, REDACTED } = require('../lib/support-bundle');
 test('sanitizeConfig redacts known credential keys at any nesting depth', () => {
  const input = {
    hosters: {
      'voe.sx': [{ username: 'u', password: 'p1', apiKey: 'k1', enabled: true }],
      'byse.sx': [{ apiKey: 'k2' }, { apiKey: 'k3', token: 't1', label: 'main' }]
    },
    globalSettings: { remote: { token: 'remT' }, scramble: { active: false } }
  };
  const out = sanitizeConfig(input);
  assert.strictEqual(out.hosters['voe.sx'][0].password, REDACTED);
  assert.strictEqual(out.hosters['voe.sx'][0].apiKey, REDACTED);
  assert.strictEqual(out.hosters['voe.sx'][0].username, 'u');
  assert.strictEqual(out.hosters['voe.sx'][0].enabled, true);
  assert.strictEqual(out.hosters['byse.sx'][1].apiKey, REDACTED);
  assert.strictEqual(out.hosters['byse.sx'][1].token, REDACTED);
  assert.strictEqual(out.hosters['byse.sx'][1].label, 'main');
  assert.strictEqual(out.globalSettings.remote.token, REDACTED);
 });
 test('sanitizeConfig does not mutate input', () => {
  const input = { hosters: { 'voe.sx': [{ password: 'secret' }] } };
  const clone = JSON.parse(JSON.stringify(input));
  sanitizeConfig(input);
  assert.deepStrictEqual(input, clone);
 });
 test('sanitizeConfig leaves empty/missing credentials alone', () => {
  const input = { hosters: { 'voe.sx': [{ password: '', apiKey: null }] } };
  const out = sanitizeConfig(input);
  assert.strictEqual(out.hosters['voe.sx'][0].password, '');
  assert.strictEqual(out.hosters['voe.sx'][0].apiKey, null);
 });
 test('sanitizeConfig handles null/undefined input', () => {
  assert.strictEqual(sanitizeConfig(null), null);
  assert.strictEqual(sanitizeConfig(undefined), undefined);
 });
 test('collectFile tails when file exceeds maxBytes', () => {
  const tmp = path.join(os.tmpdir(), `mhu-bundle-${Date.now()}.log`);
  const bigLine = 'x'.repeat(1000) + '\n';
  fs.writeFileSync(tmp, bigLine.repeat(100));
  try {
    const section = collectFile(tmp, 'big.log', 5000);
    assert.match(section, /truncated: skipped first \d+ bytes/);
    assert.ok(section.length < bigLine.length * 100, 'section should be truncated');
  } finally {
    fs.unlinkSync(tmp);
  }
 });
 test('collectFile returns placeholder for missing file', () => {
  const section = collectFile(path.join(os.tmpdir(), `does-not-exist-${Date.now()}.log`), 'missing');
  assert.match(section, /<file does not exist yet>/);
 });
 test('collectFile returns placeholder for null path', () => {
  const section = collectFile(null, 'no-path');
  assert.match(section, /<no path configured>/);
 });
 test('buildSupportBundleText produces structured output with header + config + file sections', () => {
  const tmp = path.join(os.tmpdir(), `mhu-bundle-text-${Date.now()}.log`);
  fs.writeFileSync(tmp, 'line one\nline two\n');
  try {
    const text = buildSupportBundleText({
      header: { Version: '3.3.41', Platform: 'win32' },
      sanitizedConfig: { hosters: { 'voe.sx': [{ apiKey: '<redacted>' }] } },
      files: [{ label: 'debug.log', path: tmp }]
    });
    assert.match(text, /^=== Multi-Hoster-Upload Support Bundle ===/);
    assert.match(text, /Version: 3\.3\.41/);
    assert.match(text, /Platform: win32/);
    assert.match(text, /=== Config \(sanitized/);
    assert.match(text, /"apiKey": "<redacted>"/);
    assert.match(text, /=== debug\.log/);
    assert.match(text, /line one\nline two/);
  } finally {
    fs.unlinkSync(tmp);
  }
 });
 test('buildSupportBundleText handles empty file list and missing header', () => {
  const text = buildSupportBundleText({ sanitizedConfig: {}, files: [] });
  assert.match(text, /=== Multi-Hoster-Upload Support Bundle ===/);
  assert.match(text, /=== Config/);
 });
--- a/tests/upload-manager.test.js
+++ b/tests/upload-manager.test.js
@ -31,6 +31,7 @@ describe('UploadManager', () => {
    const origRequire = module.constructor.prototype.require;
    const hosters = require('../lib/hosters');
    hosters.uploadFile = mockUploadFile;
    hosters.prefetchBaseline = async () => null;
    // Mock fs.statSync for test file paths
    const fs = require('fs');
@ -55,8 +56,8 @@ describe('UploadManager', () => {
    ]);
    const statuses = events.map(e => e.status);
    assert.ok(statuses.includes('queued'), 'should have queued status');
    assert.ok(statuses.includes('done'), 'should have done status');
    assert.ok(events.length > 0, 'should emit at least one progress event');
  });
  it('emits batch-done with correct summary', async () => {
Author	SHA1	Message	Date
Administrator	127807d62a	release: v3.3.54	2026-06-08 22:03:41 +02:00
Administrator	6cd7498f70	fix(critical): safeSend infinite recursion + queueMicrotask, plus 6 audit findings	2026-06-08 22:03:19 +02:00
Administrator	ddf2710fc6	release: v3.3.53	2026-06-08 21:28:34 +02:00
Administrator	0f57aef7c7	fix(stability): wrap hot timers/callbacks in try/catch, safeSend, updater waits for batch	2026-06-08 21:28:12 +02:00
Administrator	f0608dcda1	release: v3.3.52	2026-06-08 21:19:19 +02:00
Administrator	9b10a4356f	feat(diagnostics): full crash instrumentation — never silently die again	2026-06-08 21:18:54 +02:00
Administrator	d159ac484a	release: v3.3.51	2026-06-08 19:22:54 +02:00
Administrator	f4b5fadc5f	fix(ui): first click on sort header sets default direction instead of toggling	2026-06-08 19:22:29 +02:00
Administrator	169817f707	release: v3.3.50	2026-06-08 14:20:16 +02:00
Administrator	1418c2bc17	feat(backup): plain JSON export/import + clearer error when decrypt fails	2026-06-08 14:19:47 +02:00
Administrator	8d33141294	release: v3.3.49	2026-06-08 03:04:25 +02:00
Administrator	35341b522a	fix(accounts): allow health check during active uploads + toast when already running	2026-06-08 03:04:00 +02:00
Administrator	f9aa7f4168	release: v3.3.48	2026-06-08 01:30:19 +02:00
Administrator	d9199f8aaf	fix(perf): chunked startBatch + async rotLog — kill remaining 30s freeze on 5k+ jobs	2026-06-08 01:29:31 +02:00
Administrator	ba4642e09a	release: v3.3.47	2026-06-07 21:11:53 +02:00
Administrator	d59c5c1df8	perf: per-batch baseline cache, async folder walk, history-table fast path, progress IPC batching	2026-06-07 21:11:04 +02:00
Administrator	4bb18f7abc	release: v3.3.46	2026-06-07 20:59:34 +02:00
Administrator	125e5f55ea	fix(perf): kill per-progress renderer-to-main IPC + drop redundant queued emit + cache fileSize	2026-06-07 20:59:07 +02:00
Administrator	79fe3037eb	release: v3.3.45	2026-06-07 20:41:25 +02:00
Administrator	d280765feb	fix(perf): freeze on Start with 2000+ jobs — gate probe + rot-log behind semaphore	2026-06-07 20:40:55 +02:00
Administrator	b0b86e5016	release: v3.3.44	2026-06-07 20:33:07 +02:00
Administrator	cf35f4401d	feat(ui): per-hoster success rate, session-paused badge, post-batch retry, link export formats	2026-06-07 20:32:35 +02:00
Administrator	98eba0447d	release: v3.3.43	2026-06-07 18:50:24 +02:00
Administrator	5fb313273d	feat(diagnostics): file-format probe + structured upload-start/failure rot-log	2026-06-07 18:49:54 +02:00
Administrator	c44dde5396	release: v3.3.42	2026-06-07 16:35:19 +02:00
Administrator	f42c55c521	feat(diagnostics): log levels, support bundle export, verbose toggle, log paths panel	2026-06-07 16:34:51 +02:00
Administrator	9af65ce2a9	release: v3.3.41	2026-06-07 04:49:43 +02:00
Administrator	4f41218a92	fix(ui): log mode select no longer truncates 'Pro Session'	2026-06-07 04:49:16 +02:00