// ==UserScript==
// @name         Telegram 电报媒体下载器增强版
// @name:zh-CN   Telegram 电报媒体下载器增强版
// @namespace    https://github.com/Neet-Nestor/Telegram-Media-Downloader
// @version      2.0.28
// @description  Telegram 电报媒体下载器增强版：任务队列、并发分片、自动重试、点选批量下载、速度显示、历史记录、设置与桌面通知。
// @description:zh-CN Telegram 电报媒体下载器增强版：任务队列、并发分片、自动重试、点选批量下载、速度显示、历史记录、设置与桌面通知。
// @author       Enhanced by Claude (based on Nestor Qin's work)
// @license      GNU GPLv3
// @match        https://web.telegram.org/*
// @match        https://webk.telegram.org/*
// @match        https://webz.telegram.org/*
// @icon         https://img.icons8.com/color/452/telegram-app--v5.png
// @grant        unsafeWindow
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_listValues
// @grant        GM_notification
// @grant        GM_registerMenuCommand
// @run-at       document-idle
// @downloadURL https://update.greasyfork.icu/scripts/576114/Telegram%20%E7%94%B5%E6%8A%A5%E5%AA%92%E4%BD%93%E4%B8%8B%E8%BD%BD%E5%99%A8%E5%A2%9E%E5%BC%BA%E7%89%88.user.js
// @updateURL https://update.greasyfork.icu/scripts/576114/Telegram%20%E7%94%B5%E6%8A%A5%E5%AA%92%E4%BD%93%E4%B8%8B%E8%BD%BD%E5%99%A8%E5%A2%9E%E5%BC%BA%E7%89%88.meta.js
// ==/UserScript==

(function () {
  "use strict";

  // ============================================================
  // 0. 工具函数 & 存储适配（兼容非 GM 环境）
  // ============================================================
  const GM = {
    get(key, def) {
      try {
        if (typeof GM_getValue === "function") return GM_getValue(key, def);
      } catch (_) {}
      const v = localStorage.getItem("tmd_" + key);
      if (v === null) return def;
      try { return JSON.parse(v); } catch { return def; }
    },
    set(key, val) {
      try {
        if (typeof GM_setValue === "function") return GM_setValue(key, val);
      } catch (_) {}
      localStorage.setItem("tmd_" + key, JSON.stringify(val));
    },
    notify(opts) {
      try {
        if (typeof GM_notification === "function") return GM_notification(opts);
      } catch (_) {}
      if ("Notification" in window && Notification.permission === "granted") {
        new Notification(opts.title || "Telegram 电报媒体下载器增强版", { body: opts.text });
      }
    },
    menu(label, fn) {
      try {
        if (typeof GM_registerMenuCommand === "function") GM_registerMenuCommand(label, fn);
      } catch (_) {}
    },
  };

  const DEFAULTS = {
    chunkConcurrency: 4,
    maxChunkConcurrency: 18,
    maxRetries: 3,
    retryDelayMs: 1500,
    queueConcurrency: 5,
    nameWithDate: true,
    nameWithChannel: true,
    notifyOnComplete: true,
    historyDedup: false,
    panelCollapsed: false,
    rowSweepSelect: true,
    useFileSystemAccess: false, // false: 下载完成后弹一次浏览器保存框；true: 开始前选位置，流式写入磁盘
  };

  const settings = Object.assign({}, DEFAULTS, GM.get("settings", {}));
  const saveSettings = () => GM.set("settings", settings);

  const logger = {
    info: (m, tag) => console.log(`[TMD]${tag ? ` ${tag}:` : ""} ${m}`),
    warn: (m, tag) => console.warn(`[TMD]${tag ? ` ${tag}:` : ""} ${m}`),
    error: (m, tag) => console.error(`[TMD]${tag ? ` ${tag}:` : ""} ${m}`),
  };

  const REFRESH_DELAY = 500;
  const DOWNLOAD_ICON = "\ue979";
  const contentRangeRegex = /^bytes (\d+)-(\d+)\/(\d+)$/;
  const WIN = typeof unsafeWindow !== "undefined" ? unsafeWindow : window;

  const uid = () =>
    (Math.random() + 1).toString(36).slice(2, 10) + "_" + Date.now().toString(36);

  const hashCode = (s) => {
    let h = 0;
    for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
    return (h >>> 0).toString(36);
  };

  const formatBytes = (n) => {
    if (!n || n < 0) return "0 B";
    const u = ["B", "KB", "MB", "GB", "TB"];
    let i = 0;
    while (n >= 1024 && i < u.length - 1) { n /= 1024; i++; }
    return `${n.toFixed(n >= 10 || i === 0 ? 0 : 1)} ${u[i]}`;
  };

  const formatDuration = (s) => {
    if (!isFinite(s) || s < 0) return "--";
    if (s < 60) return `${s | 0}s`;
    if (s < 3600) return `${(s / 60) | 0}m${(s % 60) | 0}s`;
    return `${(s / 3600) | 0}h${((s % 3600) / 60) | 0}m`;
  };

  const sanitizeFilename = (name) =>
    name.replace(/[\\/:*?"<>|]/g, "_").replace(/\s+/g, " ").slice(0, 180);

  const defaultExtForKind = (kind) =>
    kind === "audio" ? "ogg" : kind === "image" ? "jpeg" : "mp4";

  const normalizeOriginalFileName = (name, kind) => {
    if (!name || typeof name !== "string") return "";
    let safe = name.trim().replace(/[?#].*$/, "").split(/[\\/]/).pop();
    if (!safe || /^\(?unknown(?: file)?\)?$/i.test(safe)) return "";
    safe = sanitizeFilename(safe).replace(/^\.+/, "").trim();
    if (!safe) return "";
    if (!/\.[A-Za-z0-9]{1,8}$/.test(safe)) safe += "." + defaultExtForKind(kind);
    return safe;
  };

  const isDarkMode = () => {
    const html = document.querySelector("html");
    return html.classList.contains("night") || html.classList.contains("theme-dark");
  };

  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  const videoSrcOf = (video) =>
    video ? (video.currentSrc || video.src || video.querySelector("source")?.src || "") : "";

  const pickWritableDirectory = async () => {
    const pickFn = WIN.showDirectoryPicker || window.showDirectoryPicker;
    if (!pickFn) throw new Error("当前浏览器不支持目录选择器（需要 Chrome / Edge / Safari 新版）");
    const handle = await pickFn.call(WIN, { mode: "readwrite" });
    if (handle.requestPermission) {
      const p = await handle.requestPermission({ mode: "readwrite" });
      if (p !== "granted") throw new Error("写权限被拒绝（请重新选择目录并点「允许」）");
    }
    const probe = "_tmd_probe_" + Date.now() + ".tmp";
    const fh = await handle.getFileHandle(probe, { create: true });
    const w = await fh.createWritable();
    await w.write(new Blob(["ok"]));
    await w.close();
    try { await handle.removeEntry(probe); } catch {}
    return handle;
  };

  const makeDownloadButton = ({ className, html, onClick, ariaLabel }) => {
    const b = document.createElement("button");
    b.className = className;
    b.type = "button";
    b.title = "Download";
    if (ariaLabel) b.setAttribute("aria-label", ariaLabel);
    b.innerHTML = html;
    if (onClick) b.onclick = onClick;
    return b;
  };

  const hideNativeDownloadButtons = (root, isDownload) => {
    root.querySelectorAll("button:not(.tel-download)").forEach((btn) => {
      if (isDownload(btn) && btn.style.display !== "none") btn.style.display = "none";
    });
  };

  const removeAll = (root, selector) =>
    root && root.querySelectorAll(selector).forEach((el) => el.remove());

  // ============================================================
  // 1. 下载历史（用于去重）
  // ============================================================
  const history = {
    _set: new Set(GM.get("history", [])),
    has(key) { return this._set.has(key); },
    add(key) {
      this._set.add(key);
      if (this._set.size > 2000) {
        const arr = Array.from(this._set);
        this._set = new Set(arr.slice(-1500));
      }
      GM.set("history", Array.from(this._set));
    },
    clear() { this._set.clear(); GM.set("history", []); },
  };

  // ============================================================
  // 2. 下载任务
  // ============================================================
  const TaskState = {
    PENDING: "pending",
    RUNNING: "running",
    PAUSED: "paused",
    COMPLETED: "completed",
    FAILED: "failed",
    CANCELLED: "cancelled",
  };

  class DownloadTask {
    constructor({ url, kind, fileName, context }) {
      this.id = uid();
      this.url = url;
      this.kind = kind; // 'video' | 'audio' | 'image'
      this.context = context || {};
      const originalName = normalizeOriginalFileName(
        fileName || this.context.originalName || this.context.fileName,
        this.kind
      );
      this._preserveFileName = !!originalName;
      this.fileName = originalName || this._deriveFileName();
      this.state = TaskState.PENDING;
      this.totalSize = 0;
      this.downloaded = 0;
      this.retries = 0;
      this.error = null;
      this.startedAt = 0;
      this.finishedAt = 0;
      this._blobs = []; // offset -> blob
      this._writable = null;
      this._aborter = new AbortController();
      this._paused = false;
      this._samples = []; // [{t, bytes}]
      this._listeners = new Set();
    }

    _deriveFileName() {
      const ext = defaultExtForKind(this.kind);
      let base = hashCode(this.url);
      try {
        const last = decodeURIComponent(this.url.split("/").pop());
        const meta = JSON.parse(last);
        const originalName = normalizeOriginalFileName(meta.fileName, this.kind);
        if (originalName) {
          this._preserveFileName = true;
          return originalName;
        }
      } catch {}
      const parts = [];
      if (settings.nameWithDate) {
        const d = new Date();
        const pad = (n) => String(n).padStart(2, "0");
        parts.push(`${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`);
      }
      if (settings.nameWithChannel && this.context.channel) {
        parts.push(this.context.channel);
      }
      parts.push(base);
      return sanitizeFilename(parts.join("_")) + "." + ext;
    }

    on(fn) { this._listeners.add(fn); return () => this._listeners.delete(fn); }
    _emit() { this._listeners.forEach((fn) => { try { fn(this); } catch {} }); }

    get progress() {
      return this.totalSize ? Math.min(100, (this.downloaded * 100) / this.totalSize) : 0;
    }

    get speed() {
      const now = Date.now();
      this._samples = this._samples.filter((s) => now - s.t < 4000);
      if (this._samples.length < 2) return 0;
      const first = this._samples[0];
      const last = this._samples[this._samples.length - 1];
      const dt = (last.t - first.t) / 1000;
      return dt > 0 ? (last.bytes - first.bytes) / dt : 0;
    }

    get eta() {
      const s = this.speed;
      if (!s || !this.totalSize) return Infinity;
      return Math.max(0, (this.totalSize - this.downloaded) / s);
    }

    pause() {
      if (this.state !== TaskState.RUNNING) return;
      this._paused = true;
      this.state = TaskState.PAUSED;
      this._emit();
    }

    resume() {
      if (this.state !== TaskState.PAUSED) return;
      this._paused = false;
      this.state = TaskState.RUNNING;
      this._emit();
      queue._kick();
    }

    cancel() {
      if ([TaskState.COMPLETED, TaskState.CANCELLED].includes(this.state)) return;
      this.state = TaskState.CANCELLED;
      this._aborter.abort();
      this._blobs = [];
      this._emit();
    }

    _recordBytes(delta) {
      this.downloaded += delta;
      this._samples.push({ t: Date.now(), bytes: this.downloaded });
    }

    async _fetchRange(startOffset, endOffset) {
      const rangeHdr =
        endOffset !== undefined && endOffset !== null
          ? `bytes=${startOffset}-${endOffset}`
          : `bytes=${startOffset}-`;
      const res = await fetch(this.url, {
        method: "GET",
        headers: { Range: rangeHdr },
        signal: this._aborter.signal,
      });
      if (![200, 206].includes(res.status)) {
        throw new Error(`HTTP ${res.status}`);
      }
      const mime = (res.headers.get("Content-Type") || "").split(";")[0];
      if (this.kind === "video" && !mime.startsWith("video/") && !mime.startsWith("application/"))
        throw new Error("Unexpected MIME: " + mime);
      if (this.kind === "audio" && !mime.startsWith("audio/"))
        throw new Error("Unexpected MIME: " + mime);

      if (!this._preserveFileName && this.kind === "video" && mime.startsWith("video/")) {
        const ext = mime.split("/")[1] || "mp4";
        this.fileName = this.fileName.replace(/\.[^.]+$/, "." + ext);
      }
      const rangeHeader = res.headers.get("Content-Range");
      const match = rangeHeader && rangeHeader.match(contentRangeRegex);
      if (!match) {
        const blob = await res.blob();
        this.totalSize = blob.size;
        return { blob, startOffset: 0, endOffset: blob.size - 1, totalSize: blob.size };
      }
      const startO = parseInt(match[1]);
      const endO = parseInt(match[2]);
      const total = parseInt(match[3]);
      const blob = await res.blob();
      return { blob, startOffset: startO, endOffset: endO, totalSize: total };
    }

    async start() {
      // 防止 _kick 重入导致同一任务被启动多次。
      if (this._starting) return;
      this._starting = true;
      try {
        this.state = TaskState.RUNNING;
        this.startedAt = this.startedAt || Date.now();
        this._emit();

        // 批量目录模式：把 writable 直接接到用户选的目录下的新文件
        if (!this._writable && this.context && this.context.dirHandle) {
          try {
            const unique = await this._uniqueFileNameIn(
              this.context.dirHandle,
              this.fileName
            );
            this.fileName = unique;
            const fh = await this.context.dirHandle.getFileHandle(unique, { create: true });
            this._writable = await fh.createWritable();
          } catch (err) {
            logger.warn("Batch dir write failed: " + err.message, this.fileName);
            this.error = "目录写入失败: " + err.message;
            this.state = TaskState.FAILED;
            this._emit();
            return;
          }
        }

        if (this.kind === "image") {
          return this._simpleDownload();
        }

        // 单文件可选 picker（仅无 dirHandle 时）
        if (settings.useFileSystemAccess && !this._writable) {
          const picked = await this._trySaveFilePicker();
          if (picked === "cancelled") {
            this.state = TaskState.CANCELLED;
            this._emit();
            return;
          }
        }

        try {
          await this._runStreamed();
          this._finalize();
        } catch (err) {
          if (this.state === TaskState.CANCELLED) return;
          if (err.name === "AbortError" && this._paused) return; // paused; queue will resume
          this.error = err.message || String(err);
          if (this.retries < settings.maxRetries) {
            this.retries++;
            logger.warn(`Retry ${this.retries}/${settings.maxRetries}: ${this.error}`, this.fileName);
            await sleep(settings.retryDelayMs * Math.pow(2, this.retries - 1));
            this._aborter = new AbortController();
            this._blobs = [];
            this.downloaded = 0;
            this._samples = [];
            if (this._writable) {
              try { await this._writable.close(); } catch {}
              this._writable = null;
            }
            // 释放锁让递归 start() 可重入（retry 是合法重入）
            this._starting = false;
            return this.start();
          }
          this.state = TaskState.FAILED;
          this._emit();
          if (settings.notifyOnComplete) {
            GM.notify({ title: "Download failed", text: this.fileName + "\n" + this.error, timeout: 6000 });
          }
        }
      } finally {
        this._starting = false;
      }
    }

    async _simpleDownload() {
      const usingDirHandle = !!this._writable; // 已由 start() 基于 dirHandle 准备好
      try {
        const res = await fetch(this.url, { signal: this._aborter.signal });
        if (!res.ok) throw new Error("HTTP " + res.status);
        const blob = await res.blob();
        this.totalSize = blob.size;
        this.downloaded = blob.size;
        this._samples.push({ t: Date.now(), bytes: 0 });
        this._samples.push({ t: Date.now() + 1, bytes: blob.size });
        if (this._writable) {
          await this._writable.write(blob);
          try { await this._writable.close(); } catch {}
          this._writable = null;
        } else {
          this._saveBlob(blob);
        }
        await this._finalize();
      } catch (err) {
        if (this.state === TaskState.CANCELLED) return;
        if (usingDirHandle || (this.context && this.context.dirHandle)) {
          this.error = err.message || String(err);
          this.state = TaskState.FAILED;
          this._emit();
          return;
        }
        // 单文件模式才允许降级到浏览器下载。
        try {
          const a = document.createElement("a");
          a.href = this.url;
          a.download = this.fileName;
          document.body.appendChild(a);
          a.click();
          document.body.removeChild(a);
          this.totalSize = this.totalSize || 1;
          this.downloaded = this.totalSize;
          await this._finalize();
        } catch (e2) {
          this.error = e2.message || String(e2);
          this.state = TaskState.FAILED;
          this._emit();
        }
      }
    }

    // 在目录句柄下为 fileName 找一个不冲突的名字（首选原名，冲突则追加 _1 / _2 ...）
    // 策略：能 getFileHandle 到就是"存在"需换名；任何错误（NotFoundError / TypeError / 权限等）都当"不存在"直接用
    async _uniqueFileNameIn(dirHandle, baseName) {
      const safe = sanitizeFilename(baseName);
      const dotIdx = safe.lastIndexOf(".");
      const stem = dotIdx > 0 ? safe.slice(0, dotIdx) : safe;
      const ext = dotIdx > 0 ? safe.slice(dotIdx) : "";
      let candidate = safe;
      for (let i = 0; i < 10000; i++) {
        let exists = false;
        try {
          await dirHandle.getFileHandle(candidate);
          exists = true;
        } catch {
          exists = false;
        }
        if (!exists) return candidate;
        candidate = `${stem}_${i + 1}${ext}`;
      }
      return candidate;
    }

    async _trySaveFilePicker() {
      const supported =
        "showSaveFilePicker" in WIN &&
        (() => { try { return WIN.self === WIN.top; } catch { return false; } })();
      if (!supported) return "unsupported";
      try {
        const handle = await WIN.showSaveFilePicker({ suggestedName: this.fileName });
        this._writable = await handle.createWritable();
        return "ok";
      } catch (err) {
        if (err.name === "AbortError") return "cancelled";
        logger.warn(err.message, this.fileName);
        return "error";
      }
    }

    _baseChunkConcurrency() {
      return Math.max(1, Math.min(parseInt(settings.chunkConcurrency) || 1, 16));
    }

    _effectiveChunkConcurrency() {
      const base = this._baseChunkConcurrency();
      const maxBoost = Math.max(base, Math.min(parseInt(settings.maxChunkConcurrency) || 18, 32));
      const queueSlots = Math.max(1, Math.min(parseInt(settings.queueConcurrency) || 1, 8));
      let runningStreams = 1;
      try {
        runningStreams = Math.max(1, queue.streamRunning || queue.running || 1);
      } catch {}
      const totalBudget = Math.max(base * queueSlots, maxBoost);
      const dynamic = Math.ceil(totalBudget / runningStreams);
      const next = Math.max(base, Math.min(maxBoost, dynamic));
      this._chunkConcurrency = next;
      return next;
    }

    async _runStreamed() {
      // Probe: first request learns total size and server chunk size
      const first = await this._fetchRange(0);
      this.totalSize = first.totalSize;
      await this._commitChunk(first.startOffset, first.blob);
      let offset = first.endOffset + 1;
      this._recordBytes(first.blob.size);
      this._emit();
      if (offset >= this.totalSize) return;

      const serverChunkSize = first.blob.size || 1024 * 1024;
      const chunkSize = Math.max(serverChunkSize, 512 * 1024);
      this._chunkConcurrency = this._effectiveChunkConcurrency();
      const preserveOrder = !!this._writable;

      // Helper: fetch the exact [start, end] range, possibly via multiple requests
      const fetchExactRange = async (start, end) => {
        const parts = [];
        let cur = start;
        while (cur <= end) {
          await this._pauseGate();
          const p = await this._fetchRange(cur, end);
          parts.push(p.blob);
          cur = p.endOffset + 1;
          this._recordBytes(p.blob.size);
          this._emit();
        }
        return parts.length === 1 ? parts[0] : new Blob(parts);
      };

      // Build chunk plan [offset..totalSize-1]
      const chunks = [];
      for (let s = offset; s < this.totalSize; s += chunkSize) {
        chunks.push({ start: s, end: Math.min(s + chunkSize - 1, this.totalSize - 1) });
      }

      if (preserveOrder) {
        // Fetch in parallel but commit in order to the writable stream
        const inflight = new Map(); // idx -> Promise<Blob>
        let nextCommit = 0;
        let nextFetch = 0;
        const scheduleMore = () => {
          const targetConcurrency = this._effectiveChunkConcurrency();
          while (inflight.size < targetConcurrency && nextFetch < chunks.length) {
            const idx = nextFetch++;
            const { start, end } = chunks[idx];
            inflight.set(idx, fetchExactRange(start, end));
          }
        };
        scheduleMore();
        while (nextCommit < chunks.length) {
          await this._pauseGate();
          const blob = await inflight.get(nextCommit);
          inflight.delete(nextCommit);
          await this._commitChunk(chunks[nextCommit].start, blob);
          nextCommit++;
          scheduleMore();
        }
        return;
      }

      // In-memory fully parallel
      const results = new Array(chunks.length);
      let cursor = 0;
      const worker = async () => {
        while (cursor < chunks.length) {
          const idx = cursor++;
          const { start, end } = chunks[idx];
          results[idx] = await fetchExactRange(start, end);
        }
      };
      await Promise.all(Array.from({ length: this._effectiveChunkConcurrency() }, worker));
      for (const b of results) if (b) this._blobs.push(b);
    }

    async _pauseGate() {
      while (this._paused) {
        if (this.state === TaskState.CANCELLED) throw new Error("Cancelled");
        await sleep(200);
      }
    }

    async _commitChunk(startOffset, blob) {
      if (this._writable) {
        await this._writable.write(blob);
      } else {
        this._blobs.push(blob);
      }
    }

    async _finalize() {
      if (this._writable) {
        try { await this._writable.close(); } catch (e) { logger.warn(e.message); }
      } else if (this._blobs.length && this.kind !== "image") {
        const mime = this.kind === "audio" ? "audio/ogg" : "video/mp4";
        const merged = new Blob(this._blobs, { type: mime });
        this._saveBlob(merged);
      }
      this._blobs = [];
      this.state = TaskState.COMPLETED;
      this.finishedAt = Date.now();
      if (this.totalSize) this.downloaded = this.totalSize;
      this._emit();
      if (settings.historyDedup) history.add(this.url);
      if (settings.notifyOnComplete) {
        GM.notify({ title: "Download complete", text: this.fileName, timeout: 4000 });
      }
    }

    _saveBlob(blob) {
      // 硬保险：用户选了批量目录时，绝不降级为浏览器保存框（防止代码里任何路径漏过来）
      if (this.context && this.context.dirHandle) {
        logger.error(
          "[safety] _saveBlob called while a dirHandle is set — refusing to show browser save dialog.",
          this.fileName
        );
        this.error = "目录写入路径失效，已阻止降级到浏览器保存框";
        this.state = TaskState.FAILED;
        this._emit();
        return;
      }
      const url = URL.createObjectURL(blob);
      const a = document.createElement("a");
      a.href = url;
      a.download = this.fileName;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      setTimeout(() => URL.revokeObjectURL(url), 60_000);
    }
  }

  class RecordedDownloadTask {
    constructor({ fileName, kind, size, startedAt, finishedAt }) {
      this.id = uid();
      this.url = "recorded:" + this.id;
      this.kind = kind || "image";
      this.fileName = normalizeOriginalFileName(fileName, this.kind) || sanitizeFilename(fileName || ("saved_" + this.id));
      this.state = TaskState.COMPLETED;
      this.totalSize = size || 0;
      this.downloaded = this.totalSize;
      this.retries = 0;
      this.error = null;
      this.startedAt = startedAt || Date.now();
      this.finishedAt = finishedAt || Date.now();
      this._listeners = new Set();
    }

    get progress() { return 100; }
    get speed() { return 0; }
    get eta() { return 0; }
    on(fn) { this._listeners.add(fn); return () => this._listeners.delete(fn); }
    _emit() { this._listeners.forEach((fn) => { try { fn(this); } catch {} }); }
    pause() {}
    resume() {}
    start() {}
    cancel() { this.state = TaskState.CANCELLED; this._emit(); }
  }

  // ============================================================
  // 3. 任务队列
  // ============================================================
  const queue = {
    tasks: new Map(),
    _onChange: new Set(),

    add(task) {
      if (settings.historyDedup && history.has(task.url)) {
        logger.info("Skipped (already downloaded)", task.fileName);
        return null;
      }
      this.tasks.set(task.id, task);
      task.on((t) => {
        this._fire();
        if ([TaskState.COMPLETED, TaskState.FAILED, TaskState.CANCELLED, TaskState.PAUSED].includes(t.state)) {
          this._kick();
        }
      });
      this._fire();
      this._kick();
      return task;
    },

    remove(id) {
      const t = this.tasks.get(id);
      if (t) t.cancel();
      this.tasks.delete(id);
      this._fire();
    },

    clearCompleted() {
      for (const [id, t] of this.tasks) {
        if ([TaskState.COMPLETED, TaskState.CANCELLED, TaskState.FAILED].includes(t.state)) {
          this.tasks.delete(id);
        }
      }
      this._fire();
    },

    pauseAll() { this.tasks.forEach((t) => t.pause()); },
    resumeAll() { this.tasks.forEach((t) => t.resume()); },

    onChange(fn) { this._onChange.add(fn); return () => this._onChange.delete(fn); },
    _fire() { this._onChange.forEach((fn) => { try { fn(); } catch {} }); },

    get running() {
      return Array.from(this.tasks.values()).filter((t) => t.state === TaskState.RUNNING).length;
    },

    get streamRunning() {
      return Array.from(this.tasks.values()).filter((t) =>
        t.state === TaskState.RUNNING && t instanceof DownloadTask && t.kind !== "image"
      ).length;
    },

    _kick() {
      const slots = settings.queueConcurrency - this.running;
      if (slots <= 0) return;
      const pending = Array.from(this.tasks.values()).filter(
        (t) => t.state === TaskState.PENDING
      );
      const toStart = pending.slice(0, slots);
      // 同步先把选中的任务标记为 RUNNING，确保后续在同一事件循环里发生的 _kick
      // 不会把它们再次当作 PENDING 重新选中。再异步调用 start()。
      for (const t of toStart) t.state = TaskState.RUNNING;
      for (const t of toStart) t.start();
    },
  };

  const recordSavedFileInPanel = ({ fileName, kind = "image", size = 0, startedAt, finishedAt } = {}) => {
    const task = new RecordedDownloadTask({ fileName, kind, size, startedAt, finishedAt });
    queue.add(task);
    return task;
  };

  const batchPanelNotices = [];
  const refreshPanelSoon = () => {
    try { panel && panel.render && panel.render(); } catch {}
  };
  const clearBatchPanelNotices = () => {
    if (!batchPanelNotices.length) return;
    batchPanelNotices.length = 0;
    refreshPanelSoon();
  };
  const createBatchPanelNotice = ({ total, dirName }) => {
    const notice = {
      id: uid(),
      state: "running",
      total: total || 0,
      ok: 0,
      bad: 0,
      dirName: dirName || "",
      startedAt: Date.now(),
      finishedAt: 0,
    };
    batchPanelNotices.unshift(notice);
    if (batchPanelNotices.length > 5) batchPanelNotices.length = 5;
    refreshPanelSoon();
    return notice;
  };
  const updateBatchPanelNotice = (notice, patch = {}) => {
    if (!notice) return;
    Object.assign(notice, patch);
    refreshPanelSoon();
  };

  // ============================================================
  // 4. 管理面板 UI
  // ============================================================
  const panel = (() => {
    let root, listEl, toggleBtn, summaryEl;

    const build = () => {
      root = document.createElement("div");
      root.id = "tmd-panel";
      Object.assign(root.style, {
        position: "fixed",
        right: "12px",
        bottom: "12px",
        width: "360px",
        maxHeight: "70vh",
        display: "flex",
        flexDirection: "column",
        borderRadius: "10px",
        fontFamily: "system-ui, sans-serif",
        fontSize: "13px",
        boxShadow: "0 8px 30px rgba(0,0,0,0.35)",
        zIndex: location.pathname.startsWith("/k/") ? 4 : 1600,
        overflow: "hidden",
        transition: "transform 0.2s ease",
      });
      applyTheme();

      const header = document.createElement("div");
      Object.assign(header.style, {
        padding: "8px 12px",
        display: "flex",
        alignItems: "center",
        justifyContent: "space-between",
        cursor: "move",
        fontWeight: 600,
        gap: "8px",
      });
      const titleSpan = document.createElement("span");
      titleSpan.textContent = "⬇ Telegram 电报媒体下载器增强版";
      titleSpan.className = "tmd-hide-on-collapse";
      titleSpan.style.whiteSpace = "nowrap";
      header.appendChild(titleSpan);

      const actions = document.createElement("div");
      actions.style.display = "flex";
      actions.style.gap = "6px";
      const mkBtn = (label, title, onClick) => {
        const b = document.createElement("button");
        b.textContent = label;
        b.title = title;
        Object.assign(b.style, {
          background: "transparent",
          border: "1px solid currentColor",
          borderRadius: "4px",
          padding: "2px 6px",
          cursor: "pointer",
          color: "inherit",
          fontSize: "11px",
        });
        b.onclick = onClick;
        return b;
      };
      const hideOnCollapse = (el) => { el.classList.add("tmd-hide-on-collapse"); return el; };

      // Header 只放图标按钮，保持单行紧凑
      actions.appendChild(hideOnCollapse(mkBtn("⏸", "暂停全部", () => queue.pauseAll())));
      actions.appendChild(hideOnCollapse(mkBtn("▶", "继续全部", () => queue.resumeAll())));
      actions.appendChild(hideOnCollapse(mkBtn("🗑", "清空已完成和本批下载", () => {
        queue.clearCompleted();
        clearBatchPanelNotices();
      })));
      actions.appendChild(hideOnCollapse(mkBtn("⚙", "设置", () => openSettings())));
      toggleBtn = mkBtn(settings.panelCollapsed ? "▲" : "▼", "折叠/展开", () => {
        settings.panelCollapsed = !settings.panelCollapsed;
        saveSettings();
        applyCollapsed();
      });
      actions.appendChild(toggleBtn);
      header.appendChild(actions);

      // 主操作工具栏（独立一行，两个按钮 flex:1 均分宽度，不会挤压 header）
      const toolbar = document.createElement("div");
      toolbar.className = "tmd-hide-on-collapse";
      Object.assign(toolbar.style, {
        padding: "0 10px 8px",
        display: "flex",
        gap: "8px",
      });
      const mkMainBtn = (label, title, onClick, bg) => {
        const b = document.createElement("button");
        b.textContent = label;
        b.title = title;
        Object.assign(b.style, {
          flex: "1",
          padding: "7px 10px",
          borderRadius: "6px",
          border: "none",
          background: bg,
          color: "#fff",
          fontWeight: "600",
          fontSize: "12px",
          cursor: "pointer",
          whiteSpace: "nowrap",
          fontFamily: "inherit",
        });
        b.onclick = onClick;
        b.addEventListener("mouseenter", () => { b.style.filter = "brightness(1.1)"; });
        b.addEventListener("mouseleave", () => { b.style.filter = ""; });
        return b;
      };
      toolbar.appendChild(mkMainBtn(
        "☑ 点选下载",
        "进入点选模式：在图片/视频上点圆圈挑一批，再一次性下载到目录",
        () => selectMode.enter(),
        "#2196f3"
      ));

      summaryEl = document.createElement("div");
      Object.assign(summaryEl.style, {
        padding: "4px 12px",
        fontSize: "11px",
        opacity: 0.7,
        borderTop: "1px solid rgba(128,128,128,0.25)",
      });

      listEl = document.createElement("div");
      Object.assign(listEl.style, {
        overflow: "auto",
        flex: 1,
        padding: "4px 8px 8px",
      });

      root.appendChild(header);
      root.appendChild(toolbar);
      root.appendChild(summaryEl);
      root.appendChild(listEl);
      document.body.appendChild(root);
      makeDraggable(root, header);
      applyCollapsed();
    };

    const applyCollapsed = () => {
      const collapsed = settings.panelCollapsed;
      listEl.style.display = collapsed ? "none" : "block";
      summaryEl.style.display = collapsed ? "none" : "block";
      root.querySelectorAll(".tmd-hide-on-collapse").forEach((el) => {
        el.style.display = collapsed ? "none" : "";
      });
      if (collapsed) {
        root.style.width = "auto";
        root.style.minWidth = "auto";
        // Update toggle button to show running task count as a subtle indicator
        const n = queue.running;
        toggleBtn.textContent = n > 0 ? `↓${n}` : "▲";
        toggleBtn.title = `展开 (${queue.tasks.size} 个任务, ${n} 运行中)`;
      } else {
        root.style.width = "360px";
        root.style.minWidth = "";
        toggleBtn.textContent = "▼";
        toggleBtn.title = "折叠";
      }
    };

    const applyTheme = () => {
      if (!root) return;
      const dark = isDarkMode();
      root.style.background = dark ? "rgba(26,32,40,0.96)" : "rgba(255,255,255,0.97)";
      root.style.color = dark ? "#eee" : "#222";
      root.style.border = `1px solid ${dark ? "#333" : "#ddd"}`;
    };

    const render = () => {
      if (!root) return;
      applyTheme();
      const tasks = Array.from(queue.tasks.values()).sort((a, b) => b.id.localeCompare(a.id));
      const running = tasks.filter((t) => t.state === TaskState.RUNNING).length;
      const totalSpeed = tasks.reduce(
        (acc, t) => acc + (t.state === TaskState.RUNNING ? t.speed : 0),
        0
      );
      summaryEl.textContent = `任务: ${tasks.length}  |  运行中: ${running}  |  合计速度: ${formatBytes(
        totalSpeed
      )}/s`;
      if (settings.panelCollapsed) {
        toggleBtn.textContent = running > 0 ? `↓${running}` : "▲";
        toggleBtn.title = `展开 (${tasks.length} 个任务, ${running} 运行中, ${formatBytes(totalSpeed)}/s)`;
      }

      listEl.innerHTML = "";
      batchPanelNotices.forEach((notice) => listEl.appendChild(renderBatchNotice(notice)));
      if (tasks.length === 0 && batchPanelNotices.length === 0) {
        const empty = document.createElement("div");
        empty.style.textAlign = "center";
        empty.style.padding = "20px 8px";
        empty.style.opacity = 0.5;
        empty.textContent = "暂无任务。打开媒体后点击下载按钮。";
        listEl.appendChild(empty);
        return;
      }
      tasks.forEach((t) => listEl.appendChild(renderRow(t)));
    };

    const renderBatchNotice = (notice) => {
      const ok = notice.ok || 0;
      const bad = notice.bad || 0;
      const done = ok + bad;
      const total = notice.total || 0;
      const pct = total ? Math.min(100, Math.round((done * 100) / total)) : 0;
      const isDone = notice.state === "done";
      const isFailed = notice.state === "failed";
      const color = isFailed ? "#ff9800" : isDone ? "#4caf50" : "#2196f3";
      const title = isFailed ? "⚠ 本批下载完成但有失败" : isDone ? "✔ 本批下载完成" : "本批下载中";
      const box = document.createElement("div");
      Object.assign(box.style, {
        padding: "10px 12px",
        margin: "4px 0 8px",
        borderRadius: "8px",
        background: isDone && !isFailed ? "rgba(76,175,80,0.16)" : isFailed ? "rgba(255,152,0,0.16)" : "rgba(33,150,243,0.14)",
        border: `1px solid ${color}`,
        boxShadow: isDone ? `0 0 0 1px ${color}44, 0 8px 22px rgba(0,0,0,0.22)` : "",
      });

      const head = document.createElement("div");
      Object.assign(head.style, { display: "flex", justifyContent: "space-between", gap: "8px", alignItems: "center" });
      const label = document.createElement("div");
      label.textContent = title;
      Object.assign(label.style, { fontWeight: 700, color });
      const close = document.createElement("button");
      close.textContent = "×";
      close.title = "移除此批次提示";
      Object.assign(close.style, {
        cursor: "pointer",
        border: "none",
        background: "transparent",
        color: "inherit",
        fontSize: "18px",
        lineHeight: 1,
      });
      close.onclick = () => {
        const idx = batchPanelNotices.findIndex((n) => n.id === notice.id);
        if (idx >= 0) batchPanelNotices.splice(idx, 1);
        render();
      };
      head.appendChild(label);
      head.appendChild(close);

      const bar = document.createElement("div");
      Object.assign(bar.style, {
        height: "8px",
        marginTop: "8px",
        borderRadius: "999px",
        background: "rgba(128,128,128,0.25)",
        overflow: "hidden",
      });
      const fill = document.createElement("div");
      Object.assign(fill.style, {
        height: "100%",
        width: `${pct}%`,
        background: color,
        transition: "width 0.3s",
      });
      bar.appendChild(fill);

      const meta = document.createElement("div");
      Object.assign(meta.style, {
        marginTop: "7px",
        fontSize: "12px",
        opacity: 0.9,
        lineHeight: 1.45,
      });
      meta.innerHTML =
        `<b>${ok}</b> / ${total} 已成功` +
        (bad ? `，失败 <b>${bad}</b>` : "") +
        (notice.dirName ? `<br/><span style="opacity:0.7">→ ${notice.dirName}</span>` : "");

      box.appendChild(head);
      box.appendChild(bar);
      box.appendChild(meta);
      return box;
    };

    const renderRow = (t) => {
      const row = document.createElement("div");
      Object.assign(row.style, {
        padding: "6px 8px",
        margin: "4px 0",
        borderRadius: "6px",
        background: isDarkMode() ? "rgba(255,255,255,0.04)" : "rgba(0,0,0,0.04)",
      });

      const head = document.createElement("div");
      Object.assign(head.style, {
        display: "flex",
        justifyContent: "space-between",
        gap: "6px",
      });
      const name = document.createElement("div");
      name.textContent = t.fileName;
      name.title = t.fileName;
      Object.assign(name.style, {
        flex: 1,
        whiteSpace: "nowrap",
        overflow: "hidden",
        textOverflow: "ellipsis",
        fontWeight: 500,
      });
      const ctrls = document.createElement("div");
      ctrls.style.display = "flex";
      ctrls.style.gap = "4px";
      const mk = (lbl, title, fn, hidden = false) => {
        const b = document.createElement("button");
        b.textContent = lbl;
        b.title = title;
        Object.assign(b.style, {
          cursor: "pointer",
          border: "none",
          background: "transparent",
          color: "inherit",
          fontSize: "13px",
          padding: "0 4px",
          display: hidden ? "none" : "",
        });
        b.onclick = fn;
        return b;
      };
      if (t.state === TaskState.RUNNING) ctrls.appendChild(mk("⏸", "暂停", () => t.pause()));
      if (t.state === TaskState.PAUSED) ctrls.appendChild(mk("▶", "继续", () => t.resume()));
      if (t.state === TaskState.FAILED) {
        ctrls.appendChild(
          mk("↻", "重试", () => {
            t.state = TaskState.PENDING;
            t.retries = 0;
            t.error = null;
            t._aborter = new AbortController();
            queue._kick();
          })
        );
      }
      ctrls.appendChild(mk("✕", "移除", () => queue.remove(t.id)));
      head.appendChild(name);
      head.appendChild(ctrls);

      const bar = document.createElement("div");
      Object.assign(bar.style, {
        height: "6px",
        marginTop: "4px",
        borderRadius: "3px",
        background: "rgba(128,128,128,0.25)",
        overflow: "hidden",
        position: "relative",
      });
      const fill = document.createElement("div");
      const color = {
        [TaskState.COMPLETED]: "#4caf50",
        [TaskState.FAILED]: "#e53935",
        [TaskState.CANCELLED]: "#9e9e9e",
        [TaskState.PAUSED]: "#ff9800",
        [TaskState.RUNNING]: "#2196f3",
        [TaskState.PENDING]: "#607d8b",
      }[t.state];
      Object.assign(fill.style, {
        height: "100%",
        width: t.state === TaskState.PENDING ? "4%" : t.progress + "%",
        background: color,
        transition: "width 0.3s",
      });
      bar.appendChild(fill);

      const meta = document.createElement("div");
      Object.assign(meta.style, {
        display: "flex",
        justifyContent: "space-between",
        fontSize: "11px",
        opacity: 0.75,
        marginTop: "3px",
      });
      const left = document.createElement("span");
      const right = document.createElement("span");
      if (t.state === TaskState.RUNNING) {
        const chunks = t._chunkConcurrency ? ` · 分片 ${t._chunkConcurrency}` : "";
        left.textContent = `${formatBytes(t.downloaded)}/${formatBytes(t.totalSize)} · ${formatBytes(
          t.speed
        )}/s${chunks}`;
        right.textContent = `ETA ${formatDuration(t.eta)} · ${t.progress.toFixed(0)}%`;
      } else if (t.state === TaskState.COMPLETED) {
        left.textContent = `✔ ${formatBytes(t.totalSize)}`;
        right.textContent = `用时 ${formatDuration((t.finishedAt - t.startedAt) / 1000)}`;
      } else if (t.state === TaskState.FAILED) {
        left.textContent = `✖ ${t.error || "失败"}`;
        right.textContent = `重试 ${t.retries}`;
      } else {
        left.textContent = t.state;
        right.textContent = `${t.progress.toFixed(0)}%`;
      }
      meta.appendChild(left);
      meta.appendChild(right);

      row.appendChild(head);
      row.appendChild(bar);
      row.appendChild(meta);
      return row;
    };

    const makeDraggable = (el, handle) => {
      let sx, sy, ox, oy, dragging = false;
      handle.addEventListener("mousedown", (e) => {
        if (e.target.tagName === "BUTTON") return;
        dragging = true;
        sx = e.clientX; sy = e.clientY;
        const rect = el.getBoundingClientRect();
        ox = rect.left; oy = rect.top;
        e.preventDefault();
      });
      window.addEventListener("mousemove", (e) => {
        if (!dragging) return;
        const nx = ox + (e.clientX - sx);
        const ny = oy + (e.clientY - sy);
        el.style.left = nx + "px";
        el.style.top = ny + "px";
        el.style.right = "auto";
        el.style.bottom = "auto";
      });
      window.addEventListener("mouseup", () => (dragging = false));
    };

    const mount = () => {
      if (root) return;
      build();
      queue.onChange(render);
      render();
      setInterval(render, 700);
    };

    return { mount, render };
  })();

  // ============================================================
  // 5. 设置面板
  // ============================================================
  const openSettings = () => {
    const existing = document.getElementById("tmd-settings");
    if (existing) existing.remove();
    const modal = document.createElement("div");
    modal.id = "tmd-settings";
    Object.assign(modal.style, {
      position: "fixed",
      inset: 0,
      background: "rgba(0,0,0,0.5)",
      zIndex: 99999,
      display: "flex",
      alignItems: "center",
      justifyContent: "center",
      fontFamily: "system-ui, sans-serif",
    });
    const dark = isDarkMode();
    const card = document.createElement("div");
    Object.assign(card.style, {
      background: dark ? "#1f272f" : "#fff",
      color: dark ? "#eee" : "#222",
      borderRadius: "10px",
      padding: "18px 20px",
      width: "380px",
      boxShadow: "0 16px 40px rgba(0,0,0,0.4)",
    });
    card.innerHTML = `<h3 style="margin:0 0 12px">设置</h3>`;

    const addNum = (label, key, min, max) => {
      const row = document.createElement("div");
      row.style.margin = "8px 0";
      row.innerHTML = `<label style="display:flex;justify-content:space-between;align-items:center;gap:8px">
        <span>${label}</span>
        <input type="number" min="${min}" max="${max}" value="${settings[key]}" style="width:70px;padding:3px 6px;border-radius:4px;border:1px solid #888;background:transparent;color:inherit"/>
      </label>`;
      const input = row.querySelector("input");
      input.addEventListener("change", () => {
        const v = Math.max(min, Math.min(max, parseInt(input.value) || min));
        settings[key] = v; input.value = v; saveSettings();
      });
      card.appendChild(row);
    };

    const addBool = (label, key) => {
      const row = document.createElement("div");
      row.style.margin = "8px 0";
      row.innerHTML = `<label style="display:flex;justify-content:space-between;align-items:center;gap:8px;cursor:pointer">
        <span>${label}</span>
        <input type="checkbox" ${settings[key] ? "checked" : ""}/>
      </label>`;
      const input = row.querySelector("input");
      input.addEventListener("change", () => { settings[key] = input.checked; saveSettings(); });
      card.appendChild(row);
    };

    addNum("基础分片并发 (1-16)", "chunkConcurrency", 1, 16);
    addNum("动态分片上限 (4-32)", "maxChunkConcurrency", 4, 32);
    addNum("队列并发数 (1-6)", "queueConcurrency", 1, 6);
    addNum("最大重试次数 (0-10)", "maxRetries", 0, 10);
    addNum("重试间隔(ms)", "retryDelayMs", 100, 30000);
    addBool("文件名含日期", "nameWithDate");
    addBool("文件名含频道名", "nameWithChannel");
    addBool("完成时通知", "notifyOnComplete");
    addBool("按 URL 去重 (历史)", "historyDedup");
    addBool("开始前选保存位置 (大文件流式写盘)", "useFileSystemAccess");

    const btnRow = document.createElement("div");
    btnRow.style.display = "flex";
    btnRow.style.justifyContent = "space-between";
    btnRow.style.marginTop = "14px";
    btnRow.innerHTML = `
      <button id="tmd-clear-hist" style="padding:6px 10px;border-radius:4px;border:1px solid #888;background:transparent;color:inherit;cursor:pointer">清空历史</button>
      <button id="tmd-close" style="padding:6px 14px;border-radius:4px;border:none;background:#2196f3;color:white;cursor:pointer">关闭</button>
    `;
    card.appendChild(btnRow);
    btnRow.querySelector("#tmd-clear-hist").onclick = () => { history.clear(); alert("历史已清空"); };
    btnRow.querySelector("#tmd-close").onclick = () => modal.remove();
    modal.addEventListener("click", (e) => { if (e.target === modal) modal.remove(); });

    modal.appendChild(card);
    document.body.appendChild(modal);
  };

  // ============================================================
  // 6. 入队便捷函数
  // ============================================================
  // Pause any currently playing <video>/<audio> so Telegram's preview stream
  // doesn't compete for bandwidth with our download.
  const stopPagePlayback = () => {
    try {
      document.querySelectorAll("video, audio").forEach((m) => {
        if (!m.paused && !m.ended) {
          try { m.pause(); } catch {}
        }
      });
    } catch {}
  };

  const enqueue = (opts) => {
    stopPagePlayback();
    const t = new DownloadTask(opts);
    return queue.add(t);
  };

  const tel_download_video = (url, ctx) =>
    enqueue({ url, kind: "video", context: ctx });
  const tel_download_audio = (url, ctx) =>
    enqueue({ url, kind: "audio", context: ctx });
  const tel_download_image = (url, ctx) =>
    enqueue({ url, kind: "image", context: ctx });

  const downloadByKind = (kind, url, ctx) =>
    kind === "video" ? tel_download_video(url, ctx) : tel_download_image(url, ctx);

  const syncViewerDownloadButton = (holder, mediaUrl, kind, className, html, ariaLabel) => {
    if (!mediaUrl) return false;
    const existing = holder.querySelector("button.tel-download");
    if (existing) {
      if (existing.dataset.mediaUrl === mediaUrl) return true;
      existing.remove();
    }
    const ctx = { channel: getChannelName() };
    const b = makeDownloadButton({
      className, html, ariaLabel,
      onClick: () => downloadByKind(kind, mediaUrl, ctx),
    });
    b.dataset.mediaUrl = mediaUrl;
    holder.prepend(b);
    return true;
  };

  // ============================================================
  // 7. 频道名提取（用于文件名前缀）
  // ============================================================
  const getChannelName = () => {
    if (!settings.nameWithChannel) return null;
    const selectors = [
      ".chat-info .peer-title",
      ".chat-info .user-title",
      ".Transition_slide-active .ChatInfo .title",
      "#MiddleColumn .ChatInfo h3",
    ];
    for (const s of selectors) {
      const el = document.querySelector(s);
      if (el && el.textContent.trim()) return sanitizeFilename(el.textContent.trim()).slice(0, 40);
    }
    return null;
  };

  // ============================================================
  // 8. Selection mode helpers: chat scroller and media detection
  // ============================================================
  const findChatScroller = () => {
    return (
      document.querySelector(".bubbles .scrollable.scrollable-y") ||
      document.querySelector(".bubbles .scrollable-y") ||
      (document.querySelector(".bubbles-inner") || {}).parentElement ||
      document.querySelector(".MessageList") ||
      document.querySelector(".scrollable-y")
    );
  };

  const VIDEO_THUMB_HOST_SELECTOR =
    ".media-inner, .media-container, .message-media, .album-item, .AlbumItem, " +
    ".Media, .media, .Photo, .photo, .VideoPlayer, .video";
  const VIDEO_PLAY_CUE_SELECTOR =
    ".icon-play, .tgico-play, .play-button, .PlayButton, .video-play, .media-play, " +
    "i[class*='play' i], button[class*='play' i], [role='button'][class*='play' i], " +
    "[aria-label*='Play' i], [title*='Play' i]";
  const isVideoThumbnailImage = (img) => {
    if (!img || img.tagName !== "IMG") return false;
    const host = img.closest(VIDEO_THUMB_HOST_SELECTOR) || img.parentElement;
    if (!host || !host.querySelector) return false;
    return !!(host.querySelector("video") || host.querySelector(VIDEO_PLAY_CUE_SELECTOR));
  };

  // ============================================================
  // 8b. 点选批量下载：在页面所有媒体缩略图右上角叠加点选圆圈，
  //     用户挑一批 → 选目录 → 一次性下载到目录（无保存框）
  // ============================================================
  const selectMode = (() => {
    let active = false;
    let observer = null;
    let bar = null;
    let debugLayer = null;
    // key = canonical URL, value = { kind: 'image' | 'video', url }
    const selected = new Map();

    const STYLE_ID = "tmd-select-mode-style";
    const injectStyle = () => {
      if (document.getElementById(STYLE_ID)) return;
      const s = document.createElement("style");
      s.id = STYLE_ID;
      s.textContent = `
        .tmd-pick {
          position: absolute !important;
          top: 6px;
          right: 6px;
          width: 26px; height: 26px;
          border-radius: 50%;
          background: rgba(0,0,0,0.55);
          border: 2px solid #fff;
          box-shadow: 0 0 0 2px rgba(0,0,0,0.35);
          cursor: pointer;
          z-index: 2147483000;
          display: flex;
          align-items: center;
          justify-content: center;
          color: #fff;
          font: 700 14px/1 system-ui, sans-serif;
          user-select: none;
          transition: background 0.15s;
        }
        .tmd-pick:hover { background: rgba(33,150,243,0.85); }
        .tmd-pick.on { background: #2196f3; border-color: #fff; }
        .tmd-pick.on::before { content: "✓"; }
        /* 文件类型（.document）：原文件需 Telegram 原生下载，用橙色区分 */
        .tmd-pick.doc { background: rgba(255,152,0,0.6); border-color: #ffca28; }
        .tmd-pick.doc:hover { background: rgba(255,193,7,0.95); }
        .tmd-pick.doc.on { background: #2196f3; border-color: #fff; }

        #tmd-select-bar {
          position: fixed;
          left: 50%;
          bottom: 24px;
          transform: translateX(-50%);
          background: rgba(20,24,30,0.95);
          color: #fff;
          padding: 10px 16px;
          border-radius: 10px;
          display: flex;
          gap: 10px;
          align-items: center;
          font: 13px/1.4 system-ui, sans-serif;
          box-shadow: 0 12px 40px rgba(0,0,0,0.5);
          z-index: 2147483001;
        }
        #tmd-select-bar button {
          padding: 6px 14px;
          border-radius: 5px;
          border: none;
          cursor: pointer;
          font-size: 13px;
          font-family: inherit;
        }
        #tmd-select-bar .tmd-primary { background: #4caf50; color: #fff; }
        #tmd-select-bar .tmd-secondary { background: #2196f3; color: #fff; }
        #tmd-select-bar .tmd-ghost {
          background: transparent; color: #fff; border: 1px solid #666;
        }
        #tmd-select-bar .tmd-toggle.on {
          background: #2196f3;
          color: #fff;
        }
        #tmd-select-bar .tmd-toggle.off {
          background: transparent;
          color: #fff;
          border: 1px solid #666;
        }
        #tmd-select-bar #tmd-select-count {
          font-weight: 600;
          min-width: 90px;
        }
        .tmd-debug-layer {
          position: fixed;
          inset: 0;
          pointer-events: none;
          z-index: 2147483002;
          font: 11px/1.2 ui-monospace, SFMono-Regular, Consolas, monospace;
        }
        .tmd-debug-box {
          position: fixed;
          box-sizing: border-box;
          border: 2px solid rgba(33,150,243,0.9);
          background: rgba(33,150,243,0.08);
        }
        .tmd-debug-box.skip {
          border-color: rgba(255,152,0,0.75);
          border-style: dashed;
          background: transparent;
        }
        .tmd-debug-tag {
          position: absolute;
          left: 0;
          top: 0;
          transform: translate(-1px, -100%);
          padding: 2px 5px;
          border-radius: 3px 3px 0 0;
          background: #2196f3;
          color: #fff;
          white-space: nowrap;
        }
        .tmd-debug-box.skip .tmd-debug-tag { background: #ff9800; }
        .tmd-row-sweep {
          position: fixed;
          pointer-events: none;
          box-sizing: border-box;
          border: 2px solid rgba(33,150,243,0.85);
          background: rgba(33,150,243,0.12);
          z-index: 2147483000;
          display: none;
        }
      `;
      document.head.appendChild(s);
    };

    // "文件形式"消息容器（img 只是封面缩略图，原文件需 Telegram 原生下载触发）
    const DOC_CONTAINER_SELECTOR =
      ".document, .document-with-thumb, .Document, .File, .file-message, .FileTransfer";
    const ALBUM_ITEM_SELECTOR = ".album-item-select-wrapper";
    const MESSAGE_ROW_SELECTOR = ".Message, .message, .bubble, .Message__content, .bubble-content";

    // 分类一个 <img>/<video>：document（文件形式）、image、video
    // 返回 { type, el, url?, docEl? } 或 null
    const classifyPick = (el) => {
      const docEl = el.closest && el.closest(DOC_CONTAINER_SELECTOR);
      if (docEl) return { type: "document", el, docEl };
      if (isVideoThumbnailImage(el)) return null;
      const url = el.tagName === "VIDEO" ? videoSrcOf(el) : (el.src || el.currentSrc);
      if (!url || url.startsWith("data:")) return null;
      return { type: el.tagName === "VIDEO" ? "video" : "image", el, url };
    };

    // 生成 Map key：普通媒体用 URL；文件用 docEl 的稳定 key
    const keyOf = (info) => {
      if (info.type === "document") {
        const d = info.docEl;
        if (!d.dataset.tmdDocKey) {
          const mid = d.getAttribute("data-mid")
                    || d.getAttribute("data-peer-id")
                    || Math.random().toString(36).slice(2);
          d.dataset.tmdDocKey = "doc-" + mid + "-" + Math.random().toString(36).slice(2, 6);
        }
        return d.dataset.tmdDocKey;
      }
      return info.url;
    };

    const pickHostOf = (info) => {
      if (!info) return null;
      if (info.type === "document") return info.docEl;
      const el = info.el;
      if (!el || !el.closest) return el ? el.parentElement : null;
      return el.closest(ALBUM_ITEM_SELECTOR) || el.parentElement;
    };

    // 是否值得加 checkbox——排除头像、贴纸、表情、侧栏、小图标；文件类型不受尺寸限制
    const isContentMedia = (el) => {
      if (!el) return false;
      // 排除已知"非内容"容器
      if (el.closest(
        ".avatar, .Avatar, .sticker, .Sticker, .reaction, .ReactionStaticEmoji, " +
        ".emoji, .chatlist, .sidebar-left, .ChatInfo, .ChatList, " +
        "#ColumnLeft, #LeftColumn, .peer-avatar, .user-avatar"
      )) return false;
      // 必须在消息容器里
      if (!el.closest(MESSAGE_ROW_SELECTOR)) return false;
      // 文件形式（.document 等）直接通过 —— 原文件通过原生下载处理
      if (el.closest(DOC_CONTAINER_SELECTOR)) return true;
      if (isVideoThumbnailImage(el)) return false;
      // 非文件形式：排除小尺寸图标
      const src = el.tagName === "VIDEO" ? videoSrcOf(el) : (el.src || el.currentSrc);
      if (!src || src.startsWith("data:")) return false;
      if (el.tagName === "IMG") {
        const w = el.naturalWidth || el.width || 0;
        const h = el.naturalHeight || el.height || 0;
        if (w && w < 120 && h && h < 120) return false;
      }
      return true;
    };

    const updateCount = () => {
      if (!bar) return;
      const c = bar.querySelector("#tmd-select-count");
      if (c) c.textContent = `已选 ${selected.size} 项`;
    };

    const syncPickVisual = (key, on) => {
      document.querySelectorAll(".tmd-pick").forEach((cb) => {
        if (cb.dataset.tmdKey === key) cb.classList.toggle("on", on);
      });
    };

    const PICK_GAP = 12;
    const PICK_SIZE = 26;
    const PICK_INSET = 6;
    const PICK_STEP = 34;
    const overlapPadded = (a, b, pad = PICK_GAP) =>
      !(a.right + pad < b.left || b.right + pad < a.left || a.bottom + pad < b.top || b.bottom + pad < a.top);

    const visualRectOfHost = (host) => {
      if (!host || !host.getBoundingClientRect) return null;
      const hostRect = host.getBoundingClientRect();
      if (!hostRect.width || !hostRect.height) return hostRect;

      let left = hostRect.left;
      let top = hostRect.top;
      let right = hostRect.right;
      let bottom = hostRect.bottom;

      if (host.matches && host.matches(ALBUM_ITEM_SELECTOR) && host.closest) {
        const album = host.closest(".Album");
        if (album && album.getBoundingClientRect) {
          const albumRect = album.getBoundingClientRect();
          const items = Array.from(album.querySelectorAll(ALBUM_ITEM_SELECTOR))
            .map((el) => ({ el, rect: el.getBoundingClientRect() }))
            .filter((item) => item.rect.width > 0 && item.rect.height > 0);
          const rowSlack = Math.max(6, Math.min(24, hostRect.height * 0.08));
          const row = items
            .filter((item) => Math.abs(item.rect.top - hostRect.top) <= rowSlack)
            .sort((a, b) => a.rect.left - b.rect.left);
          const idx = row.findIndex((item) => item.el === host);
          if (idx >= 0) {
            const next = row.slice(idx + 1).find((item) => item.rect.left > hostRect.left + 2);
            left = Math.max(left, albumRect.left);
            top = Math.max(top, albumRect.top);
            right = next ? Math.min(right, next.rect.left) : Math.min(right, albumRect.right);
            bottom = Math.min(bottom, albumRect.bottom);
          }
        }
      }

      if (right - left < PICK_SIZE + PICK_INSET * 2) right = hostRect.right;
      if (bottom - top < PICK_SIZE + PICK_INSET * 2) bottom = hostRect.bottom;
      return { left, top, right, bottom, width: right - left, height: bottom - top };
    };

    const placePick = (cb, hostRect, visualRect, slot = 0) => {
      const maxDown = Math.max(0, Math.floor((visualRect.height - PICK_SIZE - PICK_INSET) / PICK_STEP));
      const down = Math.min(slot, maxDown);
      const side = Math.max(0, slot - maxDown);
      const minLeft = visualRect.left - hostRect.left + PICK_INSET;
      const baseLeft = visualRect.right - hostRect.left - PICK_INSET - PICK_SIZE;
      const top = visualRect.top - hostRect.top + PICK_INSET + down * PICK_STEP;
      const left = Math.max(minLeft, baseLeft - side * PICK_STEP);
      cb.style.setProperty("top", `${Math.round(top)}px`, "important");
      cb.style.setProperty("left", `${Math.round(left)}px`, "important");
      cb.style.setProperty("right", "auto", "important");
    };

    const relayoutPicks = () => {
      const picks = Array.from(document.querySelectorAll(".tmd-pick"));
      picks.forEach((cb) => {
        const host = cb.parentElement;
        const hostRect = host && host.getBoundingClientRect ? host.getBoundingClientRect() : null;
        const visualRect = visualRectOfHost(host) || hostRect;
        if (hostRect && visualRect) {
          placePick(cb, hostRect, visualRect, 0);
        } else {
          cb.style.setProperty("top", `${PICK_INSET}px`, "important");
          cb.style.setProperty("right", `${PICK_INSET}px`, "important");
        }
      });

      const placed = [];
      picks
        .filter((cb) => cb.isConnected && cb.offsetParent)
        .sort((a, b) => {
          const ar = visualRectOfHost(a.parentElement) || a.getBoundingClientRect();
          const br = visualRectOfHost(b.parentElement) || b.getBoundingClientRect();
          return ar.top - br.top || ar.left - br.left;
        })
        .forEach((cb) => {
          const host = cb.parentElement;
          const hostRect = host && host.getBoundingClientRect ? host.getBoundingClientRect() : null;
          const visualRect = visualRectOfHost(host) || hostRect;
          const maxDown = visualRect ? Math.max(0, Math.floor((visualRect.height - PICK_SIZE - PICK_INSET) / PICK_STEP)) : 0;
          for (let n = 0; n <= Math.max(3, maxDown + 3); n++) {
            if (hostRect && visualRect) placePick(cb, hostRect, visualRect, n);
            const rect = cb.getBoundingClientRect();
            if (!placed.some((r) => overlapPadded(rect, r))) {
              placed.push(rect);
              return;
            }
          }
          placed.push(cb.getBoundingClientRect());
        });
    };

    const addCheckboxFor = (el) => {
      if (!isContentMedia(el)) return;
      if (el.dataset.tmdPickable === "1") return;
      const info = classifyPick(el);
      if (!info) return;

      // 对文件类型：把 checkbox 挂到文件行本身（位置更显眼），而不是 img 的紧邻父元素
      const host = pickHostOf(info);
      if (!host) return;
      const key = keyOf(info);
      const existingCb = Array.from(host.children).find((child) =>
        child.classList && child.classList.contains("tmd-pick") &&
        (child.dataset.tmdKey === key || !child.dataset.tmdKey)
      );
      host.dataset.tmdParent = "1";
      host.dataset.tmdPickKey = key;
      if (existingCb) {
        existingCb.dataset.tmdKey = key;
        existingCb.classList.toggle("on", selected.has(key));
        if (!host.querySelector("[data-tmd-pickable='1']")) el.dataset.tmdPickable = "1";
        return;
      }

      el.dataset.tmdPickable = "1";
      const cs = getComputedStyle(host);
      if (cs.position === "static" || !cs.position) host.style.position = "relative";

      const cb = document.createElement("div");
      cb.className = "tmd-pick";
      cb.dataset.tmdKey = key;
      if (info.type === "document") {
        cb.classList.add("doc");
        cb.title = "文件：将用 Telegram 原生下载触发（按 Chrome 下载设置处理，不写入选定目录）";
      } else {
        cb.title = "点击选择此媒体";
      }
      cb.addEventListener("click", (e) => {
        e.stopPropagation();
        e.preventDefault();
        if (selected.has(key)) {
          selected.delete(key);
          syncPickVisual(key, false);
        } else {
          selected.set(key, info);
          syncPickVisual(key, true);
        }
        updateCount();
      }, { capture: true });
      cb.addEventListener("mousedown", (e) => e.stopPropagation(), { capture: true });

      host.appendChild(cb);
    };

    const scanAll = () => {
      document.querySelectorAll("img, video").forEach(addCheckboxFor);
      relayoutPicks();
    };

    const buildBar = () => {
      bar = document.createElement("div");
      bar.id = "tmd-select-bar";
      bar.innerHTML = `
        <span id="tmd-select-count">已选 0 项</span>
        <span id="tmd-select-hint" style="opacity:0.55;font-size:11px;margin-right:4px">拖动空白处可按行刷选</span>
        <button class="tmd-toggle" id="tmd-select-row-sweep"></button>
        <button class="tmd-secondary" id="tmd-select-all">全选可见</button>
        <button class="tmd-secondary" id="tmd-select-invert">反选</button>
        <button class="tmd-secondary" id="tmd-select-clear">清空</button>
        <button class="tmd-secondary" id="tmd-select-layout-diag">布局诊断</button>
        <button class="tmd-primary" id="tmd-select-download">下载选中到目录…</button>
        <button class="tmd-ghost" id="tmd-select-exit">退出</button>
      `;
      document.body.appendChild(bar);

      const syncRowSweepToggle = () => {
        const btn = bar.querySelector("#tmd-select-row-sweep");
        const hint = bar.querySelector("#tmd-select-hint");
        const on = settings.rowSweepSelect !== false;
        btn.textContent = on ? "按行：开" : "按行：关";
        btn.classList.toggle("on", on);
        btn.classList.toggle("off", !on);
        btn.title = on ? "从聊天空白处拖动时按消息行批量选中" : "恢复旧模式：只能从媒体或圆圈上开始拖选";
        if (hint) hint.textContent = on ? "拖动空白处可按行刷选" : "拖动媒体/圆圈可刷选";
      };
      bar.querySelector("#tmd-select-row-sweep").onclick = () => {
        settings.rowSweepSelect = settings.rowSweepSelect === false;
        saveSettings();
        hideSweepBox();
        syncRowSweepToggle();
      };
      syncRowSweepToggle();

      bar.querySelector("#tmd-select-all").onclick = () => {
        document.querySelectorAll('[data-tmd-pickable="1"]').forEach((el) => {
          const info = classifyPick(el);
          if (!info) return;
          const key = keyOf(info);
          if (selected.has(key)) return;
          selected.set(key, info);
          syncPickVisual(key, true);
        });
        updateCount();
      };
      bar.querySelector("#tmd-select-invert").onclick = () => {
        document.querySelectorAll('[data-tmd-pickable="1"]').forEach((el) => {
          const info = classifyPick(el);
          if (!info) return;
          const key = keyOf(info);
          if (selected.has(key)) {
            selected.delete(key);
            syncPickVisual(key, false);
          } else {
            selected.set(key, info);
            syncPickVisual(key, true);
          }
        });
        updateCount();
      };
      bar.querySelector("#tmd-select-clear").onclick = () => {
        selected.clear();
        document.querySelectorAll(".tmd-pick.on").forEach((cb) => cb.classList.remove("on"));
        updateCount();
      };
      bar.querySelector("#tmd-select-exit").onclick = () => exit();
      bar.querySelector("#tmd-select-download").onclick = downloadSelected;
      bar.querySelector("#tmd-select-layout-diag").onclick = showLayoutDiagnostic;
    };

    const describeEl = (el) => {
      if (!el) return "null";
      const cls = (el.className || "").toString().trim().replace(/\s+/g, ".");
      return el.tagName.toLowerCase() + (cls ? "." + cls : "");
    };

    const rectInfoFromRect = (r) => {
      if (!r) return null;
      return {
        left: Math.round(r.left),
        top: Math.round(r.top),
        right: Math.round(r.right),
        bottom: Math.round(r.bottom),
        width: Math.round(r.width),
        height: Math.round(r.height),
      };
    };

    const rectInfo = (el) => {
      if (!el || !el.getBoundingClientRect) return null;
      return rectInfoFromRect(el.getBoundingClientRect());
    };

    const rectInside = (inner, outer, pad = 0) =>
      !!inner && !!outer &&
      inner.left >= outer.left - pad &&
      inner.top >= outer.top - pad &&
      inner.right <= outer.right + pad &&
      inner.bottom <= outer.bottom + pad;

    const shortHtml = (el) =>
      el ? el.outerHTML.replace(/\s+/g, " ").slice(0, 700) : "";

    const parentChain = (el, limit = 6) => {
      const out = [];
      for (let cur = el; cur && cur !== document.body && out.length < limit; cur = cur.parentElement) {
        out.push(describeEl(cur));
      }
      return out;
    };

    const candidateReason = (el) => {
      if (!el) return "missing";
      if (el.closest(".avatar, .Avatar, .sticker, .Sticker, .reaction, .ReactionStaticEmoji, .emoji, .chatlist, .sidebar-left, .ChatInfo, .ChatList, #ColumnLeft, #LeftColumn, .peer-avatar, .user-avatar")) return "ui-or-avatar";
      if (!el.closest(MESSAGE_ROW_SELECTOR)) return "outside-message";
      if (el.closest(DOC_CONTAINER_SELECTOR)) return "document";
      if (isVideoThumbnailImage(el)) return "video-thumbnail-skip";
      const src = el.tagName === "VIDEO" ? videoSrcOf(el) : (el.src || el.currentSrc);
      if (!src || src.startsWith("data:")) return "no-src";
      if (el.tagName === "IMG") {
        const w = el.naturalWidth || el.width || 0;
        const h = el.naturalHeight || el.height || 0;
        if (w && w < 120 && h && h < 120) return "small-image";
      }
      return "pickable";
    };

    const clearLayoutDebug = () => {
      if (debugLayer) { debugLayer.remove(); debugLayer = null; }
    };

    const drawDebugBox = (item, className = "", showTag = true) => {
      const r = item.hostVisualRect || item.hostRect || item.elRect;
      if (!r || r.width <= 0 || r.height <= 0) return;
      const box = document.createElement("div");
      box.className = "tmd-debug-box" + (className ? " " + className : "");
      Object.assign(box.style, {
        left: `${r.left}px`,
        top: `${r.top}px`,
        width: `${Math.max(2, r.width)}px`,
        height: `${Math.max(2, r.height)}px`,
      });
      if (showTag) {
        const tag = document.createElement("div");
        tag.className = "tmd-debug-tag";
        tag.textContent = item.label;
        box.appendChild(tag);
      }
      debugLayer.appendChild(box);
    };

    const buildLayoutDiagnostic = () => {
      scanAll();
      const items = [];
      const skipped = [];
      const keyCounts = {};
      document.querySelectorAll('[data-tmd-pickable="1"]').forEach((el, idx) => {
        const info = classifyPick(el);
        if (!info) return;
        const key = keyOf(info);
        const host = pickHostOf(info);
        const hostVisualRect = visualRectOfHost(host);
        const pick = host && Array.from(host.children).find((child) =>
          child.classList && child.classList.contains("tmd-pick") && child.dataset.tmdKey === key
        );
        const hostVisualInfo = rectInfoFromRect(hostVisualRect);
        const pickRectInfo = rectInfo(pick);
        keyCounts[key] = (keyCounts[key] || 0) + 1;
        const item = {
          index: idx,
          label: `#${idx + 1} ${info.type}`,
          type: info.type,
          key,
          selected: selected.has(key),
          duplicateKeyCount: 0,
          el: describeEl(el),
          host: describeEl(host),
          mediaHost: describeEl(el.parentElement),
          pick: describeEl(pick),
          elRect: rectInfo(el),
          hostRect: rectInfo(host),
          hostVisualRect: hostVisualInfo,
          mediaHostRect: rectInfo(el.parentElement),
          pickRect: pickRectInfo,
          pickInsideHostVisual: hostVisualInfo && pickRectInfo ? rectInside(pickRectInfo, hostVisualInfo, 1) : null,
          pickStyle: pick ? { top: pick.style.top, left: pick.style.left, right: pick.style.right, className: pick.className } : null,
          src: info.url ? info.url.slice(0, 180) : "",
          srcHash: info.url ? hashCode(info.url) : "",
          natural: el.tagName === "IMG" ? {
            width: el.naturalWidth || 0,
            height: el.naturalHeight || 0,
          } : null,
          hostChildren: host ? Array.from(host.children).slice(0, 8).map(describeEl) : [],
          parentChain: parentChain(el),
          outerHTML: shortHtml(host || el),
        };
        items.push(item);
      });
      items.forEach((item) => { item.duplicateKeyCount = keyCounts[item.key] || 0; });

      items.forEach((item) => {
        item.pickCollisions = [];
      });
      for (let i = 0; i < items.length; i++) {
        const a = items[i].pickRect;
        if (!a) continue;
        for (let j = i + 1; j < items.length; j++) {
          const b = items[j].pickRect;
          if (b && overlapPadded(a, b)) {
            items[i].pickCollisions.push(j);
            items[j].pickCollisions.push(i);
          }
        }
      }

      document.querySelectorAll("img, video").forEach((el, idx) => {
        const reason = candidateReason(el);
        if (reason === "pickable" || reason === "document") return;
        if (reason === "video-thumbnail-skip") {
          skipped.push({
            index: idx,
            label: `skip-${skipped.length + 1}`,
            reason,
            el: describeEl(el),
            elRect: rectInfo(el),
            host: describeEl(el.closest(VIDEO_THUMB_HOST_SELECTOR) || el.parentElement),
            hostRect: rectInfo(el.closest(VIDEO_THUMB_HOST_SELECTOR) || el.parentElement),
            src: (el.src || el.currentSrc || "").slice(0, 180),
            srcHash: el.src || el.currentSrc ? hashCode(el.src || el.currentSrc) : "",
            parentChain: parentChain(el),
            outerHTML: shortHtml(el.closest(VIDEO_THUMB_HOST_SELECTOR) || el.parentElement || el),
          });
        }
      });

      return {
        label: "select-layout",
        version: "2.0.28",
        url: location.href,
        viewport: { width: innerWidth, height: innerHeight, scrollX, scrollY },
        counts: {
          pickable: items.length,
          selected: selected.size,
          skippedVideoThumbs: skipped.length,
          collisions: items.reduce((sum, item) => sum + item.pickCollisions.length, 0) / 2,
          outOfVisualBounds: items.filter((item) => item.pickInsideHostVisual === false).length,
          duplicateKeys: Object.values(keyCounts).filter((n) => n > 1).length,
        },
        items,
        skipped,
      };
    };

    const showLayoutDiagnostic = async () => {
      clearLayoutDebug();
      const diag = buildLayoutDiagnostic();
      debugLayer = document.createElement("div");
      debugLayer.className = "tmd-debug-layer";
      document.body.appendChild(debugLayer);
      diag.items.forEach(drawDebugBox);
      diag.skipped.forEach((item) => drawDebugBox(item, "skip", false));
      const text = "TMD Select Layout Diagnostic — paste this back to Codex:\n\n" + JSON.stringify(diag, null, 2);
      try { localStorage.setItem("tmd_last_select_layout_diagnostic", text); } catch {}
      console.log(text);
      try {
        await navigator.clipboard.writeText(text);
        alert(`已生成静态布局诊断并复制到剪贴板。\n\n蓝框=${diag.counts.pickable} 个可选内容；橙框=${diag.counts.skippedVideoThumbs} 个跳过的视频封面；碰撞=${diag.counts.collisions}；越界=${diag.counts.outOfVisualBounds}。`);
      } catch (err) {
        alert("已生成静态布局诊断，剪贴板写入失败；内容已输出到 console，并保存到 localStorage.tmd_last_select_layout_diagnostic。\n\n" + err.message);
      }
    };

    const resolveLiveDocEl = (docEl) => {
      if (docEl && docEl.isConnected) return docEl;
      const key = docEl && docEl.dataset && docEl.dataset.tmdDocKey;
      const name = docEl ? docName(docEl) : "";
      for (const el of document.querySelectorAll(DOC_CONTAINER_SELECTOR)) {
        if (key && el.dataset && el.dataset.tmdDocKey === key) return el;
        if (name && docName(el) === name) return el;
      }
      return docEl;
    };

    const getDocClickTarget = (docEl) => {
      return docEl.querySelector(
        ".file-icon-container .action-icon, " +
        ".file-icon-container, .file-preview, img.full-media, canvas.thumbnail, " +
        ".document-ico, .document-name, .file-title"
      ) || docEl;
    };

    const dispatchMouseSequence = (target, x, y) => {
      const base = {
        bubbles: true,
        cancelable: true,
        composed: true,
        view: window,
        button: 0,
        buttons: 1,
        clientX: x,
        clientY: y,
      };
      if (typeof PointerEvent === "function") {
        try { target.dispatchEvent(new PointerEvent("pointerdown", { ...base, pointerId: 1, pointerType: "mouse" })); } catch {}
      }
      target.dispatchEvent(new MouseEvent("mousedown", base));
      if (typeof PointerEvent === "function") {
        try { target.dispatchEvent(new PointerEvent("pointerup", { ...base, buttons: 0, pointerId: 1, pointerType: "mouse" })); } catch {}
      }
      target.dispatchEvent(new MouseEvent("mouseup", { ...base, buttons: 0 }));
      target.dispatchEvent(new MouseEvent("click", { ...base, buttons: 0 }));
    };

    // 触发文件的原生下载/预览：必须点文件内部的缩略图/眼睛图标，不能点 .File 根节点
    const triggerNativeDocDownload = async (docEl, state) => {
      const originalName = docName(docEl);
      let liveDocEl = resolveLiveDocEl(docEl);
      if (!liveDocEl || !liveDocEl.isConnected) {
        const msg = `文件节点不在当前 DOM: ${originalName}`;
        if (state) state.error = msg;
        throw new Error(msg);
      }

      try { liveDocEl.scrollIntoView({ block: "center", inline: "nearest" }); } catch {}
      await sleep(120);
      liveDocEl = resolveLiveDocEl(liveDocEl);
      if (!liveDocEl || !liveDocEl.isConnected) {
        const msg = `滚动后文件节点丢失: ${originalName}`;
        if (state) state.error = msg;
        throw new Error(msg);
      }

      const target = getDocClickTarget(liveDocEl);
      const rect = target.getBoundingClientRect();
      if (!rect.width || !rect.height) {
        const msg = `empty rect → ${describeEl(target)}`;
        if (state) state.clickLog = msg;
        logger.warn(`[doc-click] ${msg}: ${originalName}`);
        target.click();
        return;
      }

      const x = Math.max(1, Math.min(window.innerWidth - 1, rect.left + rect.width / 2));
      const y = Math.max(1, Math.min(window.innerHeight - 1, rect.top + rect.height / 2));
      const hit = document.elementFromPoint(x, y);
      const clickLog = `${describeEl(target)} @ ${Math.round(x)},${Math.round(y)} hit=${describeEl(hit)}`;
      if (state) state.clickLog = clickLog;
      logger.info(`[doc-click] ${originalName} → ${clickLog}`);

      if (hit && !liveDocEl.contains(hit)) {
        const msg = `点击坐标命中外部元素: ${describeEl(hit)}`;
        if (state) state.error = msg;
        logger.warn(`[doc-click] ${msg}, fallback direct click: ${originalName}`);
        target.click();
        return;
      }

      dispatchMouseSequence(target, x, y);
    };

    // 从 docEl 中读取 Telegram 下载进度（0~1，下载中）/ -1（下载中但读不到具体值）/ null（无 preloader）
    // 兼容多种 webk/webz 渲染版本
    const readDocProgress = (docEl) => {
      // 1) 显式属性 data-progress / aria-valuenow
      const explicit = docEl.querySelector("[data-progress], [aria-valuenow]");
      if (explicit) {
        const v = parseFloat(explicit.dataset.progress || explicit.getAttribute("aria-valuenow"));
        if (!isNaN(v)) return v > 1 ? v / 100 : v;
      }
      // 2) 任何元素的 stroke-dashoffset（不限于 circle，svg path 也用）
      //    既看 attribute 也看 inline style
      const strokeEls = docEl.querySelectorAll("circle, path, [stroke-dashoffset], [style*='dashoffset']");
      for (const c of strokeEls) {
        let off = c.getAttribute("stroke-dashoffset");
        let arr = c.getAttribute("stroke-dasharray");
        if (!off && c.style && c.style.strokeDashoffset) off = c.style.strokeDashoffset;
        if (!arr && c.style && c.style.strokeDasharray) arr = c.style.strokeDasharray;
        if (off !== null && arr !== null && off !== "" && arr !== "") {
          const o = parseFloat(off);
          const a = parseFloat((arr || "").toString().split(/[\s,]+/)[0]);
          if (!isNaN(o) && !isNaN(a) && a > 0 && o >= 0 && o <= a) {
            return 1 - o / a;
          }
        }
      }
      // 3) CSS 自定义变量 --progress
      const cssEl = docEl.querySelector("[style*='--progress']");
      if (cssEl) {
        const v = parseFloat(cssEl.style.getPropertyValue("--progress"));
        if (!isNaN(v)) return v > 1 ? v / 100 : v;
      }
      // 4) 文本里的百分比（备用）
      const txt = docEl.textContent || "";
      const m = txt.match(/(\d{1,3})\s*%/);
      if (m) {
        const v = parseInt(m[1]);
        if (v >= 0 && v <= 100) return v / 100;
      }
      // 5) 仅有 preloader 容器存在（下载中，但读不到具体值）
      if (docEl.querySelector(
        ".preloader-container, .preloader-circular, .preloader-template, " +
        ".preloader-streamable, .preloader, [class*='preload' i], " +
        ".tgico-cancel, [class*='progress' i]"
      )) return -1;
      return null;
    };

    // 从 docEl 提取文件名（兼容 webk 的 .document-name + webz 的 .file-title）
    const docName = (docEl) => {
      const sels = [
        ".document-name", ".File__title", ".file-title", ".file-name",
        "[class*='document-name' i]", "[class*='file-title' i]",
      ];
      for (const sel of sels) {
        const el = docEl.querySelector(sel);
        if (el) {
          const name = el.getAttribute("title") || el.textContent.trim();
          if (name) return name;
        }
      }
      const titled = docEl.querySelector("[title]");
      if (titled && titled.getAttribute("title")) return titled.getAttribute("title");
      return "(未知文件)";
    };

    // 判断 docEl 是 weba/webz 的 .File：优先走 direct-blob，不模拟点击。
    const isWebzFile = (docEl) => docEl.classList.contains("File");

    // 文件名在目录里去重
    const uniqueFileNameInDir = async (dirHandle, baseName) => {
      const safe = sanitizeFilename(baseName);
      const dotIdx = safe.lastIndexOf(".");
      const stem = dotIdx > 0 ? safe.slice(0, dotIdx) : safe;
      const ext = dotIdx > 0 ? safe.slice(dotIdx) : "";
      let candidate = safe;
      for (let i = 0; i < 10000; i++) {
        let exists = false;
        try { await dirHandle.getFileHandle(candidate); exists = true; } catch { exists = false; }
        if (!exists) return candidate;
        candidate = `${stem}_${i + 1}${ext}`;
      }
      return candidate;
    };

    const parseTelegramSize = (text) => {
      if (!text) return 0;
      const m = text.replace(/,/g, "").match(/(\d+(?:\.\d+)?)\s*(B|KB|KIB|MB|MIB|GB|GIB)/i);
      if (!m) return 0;
      const n = parseFloat(m[1]);
      const unit = m[2].toUpperCase();
      const factor =
        unit === "B" ? 1 :
        unit === "KB" || unit === "KIB" ? 1024 :
        unit === "MB" || unit === "MIB" ? 1024 * 1024 :
        1024 * 1024 * 1024;
      return Math.round(n * factor);
    };

    const expectedDocSize = (docEl) => {
      const sels = [
        ".file-subtitle", ".document-size", ".File__subtitle",
        "[class*='file-subtitle' i]", "[class*='document-size' i]",
      ];
      for (const sel of sels) {
        const el = docEl.querySelector(sel);
        const size = parseTelegramSize(el && el.textContent);
        if (size) return size;
      }
      return parseTelegramSize(docEl.textContent || "");
    };

    const isImageFileName = (name) => /\.(jpe?g|png|webp|gif|bmp|avif|heic|heif)$/i.test(name || "");

    const saveBlobToDir = async (dirHandle, fileName, blob) => {
      const fname = await uniqueFileNameInDir(dirHandle, fileName);
      const fh = await dirHandle.getFileHandle(fname, { create: true });
      const w = await fh.createWritable();
      await w.write(blob);
      await w.close();
      return fname;
    };

    const reactPropsOf = (el) => {
      if (!el) return null;
      for (const key of Object.keys(el)) {
        if (key.startsWith("__reactProps$") || key.startsWith("__reactEventHandlers$")) return el[key];
      }
      return null;
    };

    const handlerFromProps = (props) => {
      if (!props) return null;
      for (const key of [
        "onClick",
        "onMouseDown",
        "onPointerDown",
        "onDoubleClick",
        "onMouseUp",
        "onPointerUp",
      ]) {
        if (typeof props[key] === "function") return { key, fn: props[key] };
      }
      return null;
    };

    const makeSyntheticClickEvent = (target, currentTarget) => {
      let defaultPrevented = false;
      let propagationStopped = false;
      return {
        type: "click",
        button: 0,
        buttons: 0,
        detail: 1,
        target,
        currentTarget,
        nativeEvent: { target, currentTarget, button: 0, buttons: 0 },
        preventDefault() { defaultPrevented = true; },
        stopPropagation() { propagationStopped = true; },
        isDefaultPrevented() { return defaultPrevented; },
        isPropagationStopped() { return propagationStopped; },
        persist() {},
      };
    };

    const invokeTelegramReactClick = (docEl, state) => {
      const liveDocEl = resolveLiveDocEl(docEl);
      const target =
        liveDocEl.querySelector(".file-icon-container .action-icon") ||
        liveDocEl.querySelector(".file-icon-container") ||
        liveDocEl.querySelector(".file-preview") ||
        liveDocEl;
      const directCandidates = [
        target,
        liveDocEl.querySelector(".file-icon-container"),
        liveDocEl.querySelector(".file-preview"),
        liveDocEl.querySelector("img.full-media"),
        liveDocEl.querySelector(".file-title"),
        liveDocEl,
      ].filter(Boolean);

      for (const el of directCandidates) {
        const props = reactPropsOf(el);
        const handler = handlerFromProps(props);
        if (!handler) continue;
        const ev = makeSyntheticClickEvent(target, el);
        handler.fn(ev);
        if (state) state.clickLog = `react-handler ${handler.key} ${describeEl(el)}`;
        logger.info(`[react-open] ${docName(liveDocEl)} → ${handler.key} ${describeEl(el)}`);
        return true;
      }

      // React/Solid handlers are often attached to the message bubble, not the .File row.
      for (let el = liveDocEl.parentElement; el && el !== document.body; el = el.parentElement) {
        const props = reactPropsOf(el);
        const handler = handlerFromProps(props);
        if (!handler) continue;
        const ev = makeSyntheticClickEvent(target, el);
        handler.fn(ev);
        if (state) state.clickLog = `ancestor-handler ${handler.key} ${describeEl(el)} target=${describeEl(target)}`;
        logger.info(`[react-open] ${docName(liveDocEl)} → ancestor ${handler.key} ${describeEl(el)}`);
        return true;
      }

      // Telegram Web A often uses document-level delegated listeners. A DOM-native
      // element.click() still targets the right icon and does not depend on screen coordinates.
      try {
        target.click();
        if (state) state.clickLog = `native-element-click ${describeEl(target)}`;
        logger.info(`[native-open] ${docName(liveDocEl)} → ${describeEl(target)}`);
        return true;
      } catch (err) {
        if (state) state.clickLog = `native-element-click failed: ${err.message}`;
      }

      if (state) state.clickLog = "open-handler missing";
      return false;
    };

    const findActiveViewerSlide = () =>
      document.querySelector("#MediaViewer .MediaViewerSlide--active") ||
      document.querySelector(".media-viewer-whole .media-viewer-aspecter");

    const closeMediaViewer = async () => {
      const sendEscape = () => {
        const opts = { key: "Escape", code: "Escape", keyCode: 27, which: 27, bubbles: true };
        for (const target of [document.activeElement, document.body, document, window].filter(Boolean)) {
          try {
            target.dispatchEvent(new KeyboardEvent("keydown", opts));
            target.dispatchEvent(new KeyboardEvent("keyup", opts));
          } catch {}
        }
      };
      const closeBtn = [
        "#MediaViewer button[title='Close']",
        "#MediaViewer button[aria-label='Close']",
        "#MediaViewer [role='button'][title='Close']",
        "#MediaViewer [role='button'][aria-label='Close']",
        ".media-viewer-whole .btn-close",
        ".media-viewer-whole button[title='Close']",
        ".media-viewer-whole button[aria-label='Close']",
        ".media-viewer-topbar button[title='Close']",
        ".media-viewer-topbar button[aria-label='Close']",
      ].map((sel) => document.querySelector(sel)).find(Boolean);

      if (closeBtn) {
        closeBtn.click();
      } else {
        sendEscape();
      }

      for (let i = 0; i < 6; i++) {
        await sleep(100);
        if (!findActiveViewerSlide()) return true;
      }

      // Some weba/webz builds ignore the close button while video focus is active.
      sendEscape();
      for (let i = 0; i < 15; i++) {
        await sleep(100);
        if (!findActiveViewerSlide()) return true;
      }
      return false;
    };

    const waitForTaskDone = (task, s, refresh) => new Promise((resolve, reject) => {
      if (!task) return resolve(null);
      let offTask = null;
      const sync = (t) => {
        if (t.state === TaskState.COMPLETED) {
          s.state = "saved";
          s.progress = 1;
          s.outputName = t.fileName;
          if (offTask) offTask();
          resolve(t.fileName);
        } else if ([TaskState.FAILED, TaskState.CANCELLED].includes(t.state)) {
          s.state = "failed";
          s.progress = 1;
          s.error = t.error || t.state;
          if (offTask) offTask();
          reject(new Error(s.error));
        } else {
          const p = t.totalSize ? t.progress / 100 : 0;
          s.state = "downloading";
          s.progress = Math.max(s.progress || 0, 0.9 + Math.min(0.09, p * 0.09));
          refresh();
        }
      };
      offTask = task.on(sync);
      sync(task);
    });

    const saveWebaFileViaReactViewer = async (docEl, dirHandle, s, renderProgress, kind, ctx = {}) => {
      const refresh = () => {
        try { renderProgress && renderProgress(); } catch {}
      };
      const liveDocEl = resolveLiveDocEl(docEl);
      const name = docName(liveDocEl);
      const expected = expectedDocSize(liveDocEl);
      const mediaKind = kind || (isImageFileName(name) ? "image" : "video");
      const startedAt = Date.now();
      let openedViewer = false;

      try {
        if (findActiveViewerSlide()) {
          s.error = "关闭残留 MediaViewer，避免读取上一个媒体 URL";
          refresh();
          const closed = await closeMediaViewer();
          if (!closed) throw new Error("MediaViewer 未关闭，已阻止读取旧媒体 URL");
          await sleep(150);
        }

        if (!invokeTelegramReactClick(liveDocEl, s)) {
          throw new Error("找不到 Telegram React 打开处理器");
        }

        s.progress = Math.max(s.progress || 0, 0.72);
        refresh();

        let slide = null;
        for (let i = 0; i < 50; i++) {
          slide = findActiveViewerSlide();
          if (slide) break;
          await sleep(200);
        }
        if (!slide) throw new Error("打开处理器已调用，但 MediaViewer 未出现");
        openedViewer = true;

        const pageFetch = WIN.fetch || fetch;

        if (mediaKind === "video") {
          const seenUrls = ctx.batchSeenUrls;
          let mediaUrl = "";
          let duplicateUrl = "";
          for (let i = 0; i < 140; i++) {
            slide = findActiveViewerSlide() || slide;
            const candidate = videoSrcOf(slide && slide.querySelector("video"));
            if (candidate) {
              if (!seenUrls || !seenUrls.has(candidate)) {
                mediaUrl = candidate;
                break;
              }
              duplicateUrl = candidate;
              s.error = "viewer 仍是本批次已下载的视频 URL，等待切换";
            }
            s.progress = 0.72 + Math.min(0.18, (i / 140) * 0.18);
            refresh();
            await sleep(200);
          }
          if (!mediaUrl) {
            if (duplicateUrl) throw new Error("视频 URL 与本批次前一个重复，已阻止重复下载");
            throw new Error("MediaViewer 未出现 video URL");
          }
          if (seenUrls) seenUrls.add(mediaUrl);
          s.mediaUrl = mediaUrl.length > 180 ? mediaUrl.slice(0, 180) + "..." : mediaUrl;
          s.mediaUrlHash = hashCode(mediaUrl);
          s.clickLog = `${s.clickLog || "native-element-click"} → viewer video`;
          const task = tel_download_video(mediaUrl, { ...ctx, channel: getChannelName(), dirHandle, originalName: name });
          await closeMediaViewer();
          openedViewer = false;
          return await waitForTaskDone(task, s, refresh);
        }

        let bestBlob = null;
        let bestImg = null;
        let bestSize = 0;
        let lastSrc = "";
        let lastFetchAt = 0;
        for (let i = 0; i < 120; i++) {
          let best = null, bestArea = 0;
          const imgs = Array.from(slide.querySelectorAll("img[src^='blob:'], img[src^='https:']"));
          for (const img of imgs) {
            if (img.classList.contains("thumbnail")) continue;
            const area = (img.naturalWidth || img.width || 0) * (img.naturalHeight || img.height || 0);
            if (area >= bestArea && img.src) { bestArea = area; best = img; }
          }

          const now = Date.now();
          if (best && best.src && (best.src !== lastSrc || now - lastFetchAt > 700)) {
            lastSrc = best.src;
            lastFetchAt = now;
            try {
              const res = await pageFetch.call(WIN, best.src);
              if (res.ok) {
                const blob = await res.blob();
                if (blob.size > bestSize) {
                  bestBlob = blob;
                  bestImg = best;
                  bestSize = blob.size;
                  s.error = expected
                    ? `viewer blob 等待原图: ${formatBytes(bestSize)} / ${formatBytes(expected)}`
                    : `viewer blob: ${formatBytes(bestSize)}`;
                }
                if (!expected || blob.size >= expected * 0.75) {
                  bestBlob = blob;
                  bestImg = best;
                  break;
                }
              }
            } catch (err) {
              s.error = "fetch viewer blob: " + err.message;
            }
          }

          s.progress = 0.72 + Math.min(0.18, (i / 120) * 0.18);
          refresh();
          await sleep(250);
        }

        if (!bestBlob || !bestImg) throw new Error("MediaViewer 未出现可保存图片");
        if (expected && bestBlob.size < expected * 0.75) {
          throw new Error(`viewer blob 仍太小: ${formatBytes(bestBlob.size)} / 页面标注 ${formatBytes(expected)}`);
        }

        const fname = await saveBlobToDir(dirHandle, name, bestBlob);
        recordSavedFileInPanel({
          fileName: fname,
          kind: "image",
          size: bestBlob.size,
          startedAt,
          finishedAt: Date.now(),
        });
        s.outputName = fname;
        s.clickLog = `${s.clickLog || "native-element-click"} → viewer ${describeEl(bestImg)}`;
        return fname;
      } finally {
        if (openedViewer) await closeMediaViewer();
      }
    };

    // weba/webz 的 .File 图片行里已经挂着 blob: 图片；直接转存，避免模拟点击点歪。
    const saveWebaFileBlobDirect = async (docEl, dirHandle, s, renderProgress, doneCheck, ctx = {}) => {
      const refresh = () => {
        try { renderProgress && renderProgress(); } catch {}
      };
      s.state = "downloading";
      s.progress = 0.05;
      s.error = "";
      const startedAt = Date.now();
      try {
        const liveDocEl = resolveLiveDocEl(docEl);
        if (!liveDocEl || !liveDocEl.isConnected) throw new Error("文件节点不在当前 DOM");

        const name = docName(liveDocEl);
        const mediaKind = isImageFileName(name) ? "image" : "video";

        const img =
          liveDocEl.querySelector("img.full-media[src^='blob:']") ||
          liveDocEl.querySelector(".file-preview img[src^='blob:']") ||
          liveDocEl.querySelector("img[src^='blob:']");
        if (!img || !img.src) throw new Error("文件行里没有可转存的 blob 图片");

        s.clickLog = `direct-blob ${describeEl(img)}`;
        const expected = expectedDocSize(liveDocEl);
        s.progress = 0.2;
        refresh();

        const pageFetch = WIN.fetch || fetch;
        const res = await pageFetch.call(WIN, img.src);
        if (!res.ok) throw new Error("fetch blob: HTTP " + res.status);
        const blob = await res.blob();
        s.progress = 0.65;
        refresh();

        let fname = null;
        if (mediaKind === "video") {
          s.error = "视频文件尝试 viewer URL 入队";
          refresh();
          fname = await saveWebaFileViaReactViewer(liveDocEl, dirHandle, s, renderProgress, "video", ctx);
        } else if (expected && blob.size < expected * 0.75) {
          s.error = `行内 blob 太小，尝试 viewer 原图: ${formatBytes(blob.size)} / ${formatBytes(expected)}`;
          refresh();
          fname = await saveWebaFileViaReactViewer(liveDocEl, dirHandle, s, renderProgress, "image", ctx);
        } else {
          fname = await saveBlobToDir(dirHandle, name, blob);
          recordSavedFileInPanel({
            fileName: fname,
            kind: mediaKind,
            size: blob.size,
            startedAt,
            finishedAt: Date.now(),
          });
        }

        s.state = "saved";
        s.progress = 1;
        s.outputName = fname;
      } catch (err) {
        s.state = "failed";
        s.progress = 1;
        s.error = err.message || String(err);
        logger.error(`[direct-blob] ${s.name}: ${s.error}`);
      }
      refresh();
      doneCheck && doneCheck();
    };

    // 拦截 Telegram 原生 blob 下载，直接写入用户选的目录。
    const interceptDownloadsToDir = (dirHandle) => {
      let saved = 0, failed = 0;
      let active = true;
      const listeners = new Set();
      const fire = (info) => listeners.forEach((fn) => { try { fn(info); } catch {} });

      const orig = WIN.HTMLAnchorElement.prototype.click;
      WIN.HTMLAnchorElement.prototype.click = function () {
        if (active && this.href && this.href.startsWith("blob:") && this.download) {
          const href = this.href;
          const fileName = this.download;
          (async () => {
            const startedAt = Date.now();
            try {
              const res = await fetch(href);
              if (!res.ok) throw new Error("fetch blob: HTTP " + res.status);
              const blob = await res.blob();
              const fname = await uniqueFileNameInDir(dirHandle, fileName);
              const fh = await dirHandle.getFileHandle(fname, { create: true });
              const w = await fh.createWritable();
              await w.write(blob);
              await w.close();
              saved++;
              recordSavedFileInPanel({
                fileName: fname,
                kind: isImageFileName(fname) ? "image" : "video",
                size: blob.size,
                startedAt,
                finishedAt: Date.now(),
              });
              logger.info(`[intercept] saved → ${fname} (${blob.size} bytes)`);
              fire({ ok: true, fileName: fname, count: saved, failed });
            } catch (err) {
              failed++;
              logger.error(`[intercept] save failed (${fileName}): ${err.message}`);
              fire({ ok: false, error: err.message, count: saved, failed });
            }
          })();
          return; // 不 fall through —— 阻止浏览器原生下载
        }
        return orig.call(this);
      };

      return {
        onProgress(fn) { listeners.add(fn); return () => listeners.delete(fn); },
        get count() { return saved; },
        get failed() { return failed; },
        stop() {
          active = false;
          if (WIN.HTMLAnchorElement.prototype.click !== orig) {
            WIN.HTMLAnchorElement.prototype.click = orig;
          }
        },
      };
    };

    // 顶部进度浮窗
    const TOAST_ID = "tmd-toast";
    const showToast = (html) => {
      let t = document.getElementById(TOAST_ID);
      if (!t) {
        t = document.createElement("div");
        t.id = TOAST_ID;
        Object.assign(t.style, {
          position: "fixed",
          left: "50%",
          top: "20px",
          transform: "translateX(-50%)",
          background: "rgba(20,24,30,0.96)",
          color: "#fff",
          padding: "12px 20px",
          borderRadius: "10px",
          fontFamily: "system-ui, sans-serif",
          fontSize: "13px",
          lineHeight: "1.5",
          zIndex: 2147483002,
          boxShadow: "0 8px 30px rgba(0,0,0,0.45)",
          minWidth: "300px",
          textAlign: "center",
        });
        document.body.appendChild(t);
      }
      t.innerHTML = html;
      return t;
    };
    const dismissToast = (delay = 0) => {
      const t = document.getElementById(TOAST_ID);
      if (!t) return;
      if (delay > 0) setTimeout(() => t.remove(), delay);
      else t.remove();
    };

    const downloadSelected = async () => {
      if (selected.size === 0) {
        alert("未选择任何媒体");
        return;
      }
      const docs = [], media = [];
      selected.forEach((info) => {
        if (info.type === "document") docs.push(info);
        else media.push(info);
      });

      let dirHandle;
      try {
        dirHandle = await pickWritableDirectory();
      } catch (err) {
        if (err.name !== "AbortError") alert("目录不可用: " + err.message);
        return;
      }

      // 目录选好后先退出点选 UI，避免我们的浮层盖住文件缩略图/眼睛图标。
      exit();

      const batchTotal = media.length + docs.length;
      const batchNotice = createBatchPanelNotice({ total: batchTotal, dirName: dirHandle.name });
      let mediaOk = 0, mediaBad = 0, docsOk = 0, docsBad = 0;
      let mediaFinished = media.length === 0;
      let docsFinished = docs.length === 0;
      const refreshBatchNotice = (stateOverride) => {
        const ok = mediaOk + docsOk;
        const bad = mediaBad + docsBad;
        const allFinished = mediaFinished && docsFinished && ok + bad >= batchTotal;
        const state = stateOverride || (allFinished ? (bad > 0 ? "failed" : "done") : "running");
        updateBatchPanelNotice(batchNotice, {
          ok,
          bad,
          state,
          finishedAt: state === "running" ? 0 : Date.now(),
        });
      };
      const watchMediaBatchTask = (task) => {
        if (!task) {
          mediaOk++;
          mediaFinished = mediaOk + mediaBad >= media.length;
          refreshBatchNotice();
          return;
        }
        task.on((t) => {
          if (t._tmdBatchCounted) return;
          if (t.state === TaskState.COMPLETED) {
            t._tmdBatchCounted = true;
            mediaOk++;
          } else if (t.state === TaskState.FAILED || t.state === TaskState.CANCELLED) {
            t._tmdBatchCounted = true;
            mediaBad++;
          } else {
            return;
          }
          mediaFinished = mediaOk + mediaBad >= media.length;
          refreshBatchNotice();
        });
      };
      refreshBatchNotice();

      // 1) 普通媒体走 DownloadTask 队列
      const ctx = { channel: getChannelName(), dirHandle, batchSeenUrls: new Set() };
      media.forEach((v) => {
        const url = v.url;
        let task = null;
        if (v.type === "video" || url.includes("stream/") || url.includes("?mime=video")) {
          task = tel_download_video(url, ctx);
        } else {
          task = tel_download_image(url, ctx);
        }
        watchMediaBatchTask(task);
      });

      // 2) 文件类型分两路：
      //    A. weba/webz .File 图片 — DOM 里已有 blob:，直接 fetch + 校验大小 + 写目录
      //    B. webk .document — click 触发 + anchor.click 拦截
      if (docs.length > 0) {
        const interception = interceptDownloadsToDir(dirHandle);
        let triggered = 0;
        let cancelled = false;
        let timeoutId = null;
        let pollId = null;

        // 状态机：pending → downloading(p) → cached → saved/failed
        // 路由策略：
        //   weba/webz 的 .File 图片 → 直接 fetch 行内 blob 并按页面大小校验后写目录（不模拟点击）
        //   webk 的 .document → 直接 click + anchor.click 拦截
        const tracker = new Map();
        docs.forEach((d) => {
          tracker.set(d.docEl, {
            state: "pending", progress: 0, name: docName(d.docEl),
            cachedSince: 0, reclickedAt: 0, lastClickAt: 0,
            useViewer: isWebzFile(d.docEl),
            route: isWebzFile(d.docEl) ? "directBlob" : "native",
          });
        });

        const buildDiagnosticText = (label = "manual") => {
          const reactDiag = (live) => {
            const rows = [];
            let cur = live;
            for (let depth = 0; cur && cur !== document.body && depth < 8; depth++, cur = cur.parentElement) {
              const props = reactPropsOf(cur);
              rows.push({
                depth,
                el: describeEl(cur),
                hasProps: !!props,
                handlers: props ? Object.keys(props).filter((k) => /^on[A-Z]/.test(k)).slice(0, 12) : [],
              });
            }
            return rows;
          };
          const counts = {};
          const routeCounts = {};
          tracker.forEach((s) => {
            counts[s.state] = (counts[s.state] || 0) + 1;
            routeCounts[s.route || "?"] = (routeCounts[s.route || "?"] || 0) + 1;
          });
          const samples = docs.map((d, i) => {
            const el = d.docEl;
            const trk = tracker.get(el);
            const live = resolveLiveDocEl(el);
            const rect = live && live.getBoundingClientRect ? live.getBoundingClientRect() : null;
            return {
              index: i,
              name: trk ? trk.name : "?",
              state: trk ? trk.state : "?",
              error: trk ? (trk.error || "") : "",
              route: trk ? (trk.route || "") : "",
              clickLog: trk ? (trk.clickLog || "") : "",
              outputName: trk ? (trk.outputName || "") : "",
              mediaUrlHash: trk ? (trk.mediaUrlHash || "") : "",
              mediaUrl: trk ? (trk.mediaUrl || "") : "",
              isConnected: !!(live && live.isConnected),
              rect: rect ? {
                left: Math.round(rect.left),
                top: Math.round(rect.top),
                width: Math.round(rect.width),
                height: Math.round(rect.height),
              } : null,
              classNames: live ? live.className : "",
              childTagsAndClasses: live ? Array.from(live.children).map(
                (c) => c.tagName.toLowerCase() + (c.className ? "." + c.className.split(/\s+/).join(".") : "")
              ) : [],
              hasCircle: !!(live && live.querySelector("circle")),
              hasPreloader: !!(live && live.querySelector("[class*='preload' i]")),
              hasProgressClass: !!(live && live.querySelector("[class*='progress' i]")),
              expectedSize: live ? expectedDocSize(live) : 0,
              inlineBlobCount: live ? live.querySelectorAll("img[src^='blob:']").length : 0,
              reactPropsOnFile: !!(live && reactPropsOf(live)),
              reactPropsOnIcon: !!(live && reactPropsOf(live.querySelector(".file-icon-container .action-icon"))),
              reactAncestorProps: live ? reactDiag(live) : [],
              outerHTML: live ? live.outerHTML.slice(0, 2000) : "",
            };
          });
          return "TMD Diagnostic — paste this back to Claude:\n\n" + JSON.stringify({
            label,
            version: "2.0.28",
            url: location.href,
            userAgent: navigator.userAgent,
            total: docs.length,
            counts,
            routeCounts,
            interception: { count: interception.count, failed: interception.failed },
            samples,
          }, null, 2);
        };

        const persistDiagnostic = (label) => {
          const text = buildDiagnosticText(label);
          try { localStorage.setItem("tmd_last_diagnostic", text); } catch {}
          console.log(text);
          return text;
        };

        const copyDiagnostic = async (label = "manual") => {
          const text = persistDiagnostic(label);
          try {
            await navigator.clipboard.writeText(text);
            alert("✔ 已复制诊断信息到剪贴板。\n\n请粘贴到对话里发给我。");
          } catch (e) {
            alert(
              "剪贴板写入失败，但诊断已输出到 console，并保存到 localStorage.tmd_last_diagnostic。\n\n" +
              "错误：" + e.message
            );
          }
        };

        const totalProgress = () => {
          let sum = 0;
          tracker.forEach((s) => { sum += s.state === "saved" ? 1 : (s.state === "cached" ? 0.95 : s.progress); });
          return sum / tracker.size;
        };

        const renderToast = () => {
          let viewerOk = 0, viewerBad = 0;
          tracker.forEach((s) => {
            if (!s.useViewer) return;
            if (s.state === "saved") viewerOk++;
            else if (s.state === "failed") viewerBad++;
          });
          const ok = interception.count + viewerOk;
          const bad = interception.failed + viewerBad;
          const total = docs.length;
          let downloading = 0, cached = 0;
          tracker.forEach((s) => {
            if (s.state === "downloading") downloading++;
            else if (s.state === "cached") cached++;
          });
          const pct = Math.round(totalProgress() * 100);
          docsOk = 0;
          docsBad = 0;
          tracker.forEach((s) => {
            if (s.state === "saved") docsOk++;
            else if (s.state === "failed") docsBad++;
          });
          refreshBatchNotice();

          const t = showToast(
            `<div style="font-weight:600;margin-bottom:8px">批量下载文件…</div>` +
            // 总进度条
            `<div style="height:8px;background:rgba(255,255,255,0.12);border-radius:4px;overflow:hidden;margin:4px 0 8px">` +
            `<div style="height:100%;width:${pct}%;background:linear-gradient(90deg,#2196f3,#4caf50);transition:width 0.4s"></div>` +
            `</div>` +
            `<div style="font-size:13px;opacity:0.95;margin-bottom:4px"><b>${pct}%</b> 总进度</div>` +
            // 分阶段计数
            `<div style="font-size:12px;opacity:0.8;line-height:1.7">` +
              `已发起 ${triggered}/${total} · ` +
              `Telegram 下载中 ${downloading} · ` +
              `已缓存待保存 ${cached} · ` +
              `已写入磁盘 <b style="color:#4caf50">${ok}</b>/${total}` +
              (bad > 0 ? ` · 失败 ${bad}` : "") +
            `</div>` +
            `<div style="font-size:11px;opacity:0.55;margin-top:6px">→「${dirHandle.name}」</div>` +
            `<div style="margin-top:10px;display:flex;gap:6px;justify-content:center">` +
            `<button id="tmd-toast-diag" style="padding:5px 12px;border-radius:4px;border:1px solid #888;background:transparent;color:#fff;cursor:pointer;font-size:11px">诊断（复制 HTML）</button>` +
            `<button id="tmd-toast-reclick" style="padding:5px 12px;border-radius:4px;border:1px solid #888;background:transparent;color:#fff;cursor:pointer;font-size:11px">手动重 click 全部</button>` +
            `<button id="tmd-toast-cancel" style="padding:5px 14px;border-radius:4px;border:1px solid #888;background:transparent;color:#fff;cursor:pointer;font-size:12px">取消</button>` +
            `</div>`
          );
          const cancelBtn = t.querySelector("#tmd-toast-cancel");
          if (cancelBtn) {
            cancelBtn.onclick = () => {
              cancelled = true;
              interception.stop();
              if (timeoutId) clearTimeout(timeoutId);
              if (pollId) clearInterval(pollId);
              off();
              docsOk = interception.count;
              docsBad = interception.failed + Math.max(0, total - docsOk);
              docsFinished = true;
              refreshBatchNotice("failed");
              showToast(`已取消<br/><small style="opacity:0.7">${interception.count}/${total} 已写入目录</small>`);
              dismissToast(4000);
            };
          }
          // 诊断：把前 3 个 docEl 的关键信息复制到剪贴板
          const diagBtn = t.querySelector("#tmd-toast-diag");
          if (diagBtn) {
            diagBtn.onclick = () => copyDiagnostic("in-progress");
          }
          // 手动一键 reclick 所有未 saved 的 webk doc；weba/webz 走 direct-blob，不点击
          const rcBtn = t.querySelector("#tmd-toast-reclick");
          if (rcBtn) {
            rcBtn.onclick = () => {
              let n = 0;
              for (const [docEl, s] of tracker) {
                if (s.state === "saved" || s.state === "failed") continue;
                if (s.useViewer) continue;
                triggerNativeDocDownload(docEl, s).catch((e) => logger.warn("Manual reclick failed: " + e.message));
                n++;
              }
              logger.info(`[manual reclick] triggered ${n} docs`);
            };
          }
        };

        const off = interception.onProgress((info) => {
          if (info.ok) {
            // 在 webk(click+拦截) 路径里，把"已缓存"最早的那个标为 saved
            let target = null, oldest = Infinity;
            tracker.forEach((s, el) => {
              if (s.useViewer) return; // viewer 路径自己处理
              if (s.state === "cached" && s.cachedSince < oldest) {
                oldest = s.cachedSince; target = el;
              }
            });
            if (!target) {
              for (const [el, s] of tracker) {
                if (s.useViewer) continue;
                if (s.state !== "saved" && s.state !== "failed") { target = el; break; }
              }
            }
            if (target) {
              const s = tracker.get(target);
              s.state = "saved";
              s.progress = 1;
            }
          }
          renderToast();
          finishIfDone();
        });

        // 轮询每秒：仅对"触发路径"（webk）做状态推进 + reclick 兜底
        // viewer 路径自己管理状态，跳过
        pollId = setInterval(() => {
          if (cancelled) return;
          const now = Date.now();
          for (const [docEl, s] of tracker) {
            if (s.useViewer) continue;
            if (s.state === "saved" || s.state === "failed") continue;
            const p = readDocProgress(docEl);
            if (p === null) {
              if (s.state === "downloading") {
                s.state = "cached";
                s.cachedSince = now;
                s.progress = 0.95;
              } else if (s.state === "cached") {
                if (!s.reclickedAt && now - s.cachedSince > 5000) {
                  s.reclickedAt = now;
                  logger.info(`[reclick A: cached>5s] ${s.name}`);
                  triggerNativeDocDownload(docEl, s).catch((e) => logger.warn("Reclick failed: " + e.message));
                }
              } else if (s.state === "pending" && s.lastClickAt > 0) {
                if (!s.reclickedAt && now - s.lastClickAt > 60000) {
                  s.reclickedAt = now;
                  logger.info(`[reclick B: pending>60s, no progress signal] ${s.name}`);
                  triggerNativeDocDownload(docEl, s).catch((e) => logger.warn("Reclick failed: " + e.message));
                }
              }
            } else {
              s.state = "downloading";
              if (p >= 0) s.progress = p;
            }
          }
          renderToast();
        }, 1000);

        renderToast();

        // 完成检测（基于 tracker 状态，不依赖 interception 计数）
        const allDone = () => {
          for (const [, s] of tracker) {
            if (s.state !== "saved" && s.state !== "failed") return false;
          }
          return true;
        };
        const finishIfDone = () => {
          if (cancelled) return;
          if (!allDone()) return;
          if (pollId) clearInterval(pollId);
          if (timeoutId) clearTimeout(timeoutId);
          interception.stop();
          off();
          let okN = 0, badN = 0;
          tracker.forEach((s) => { if (s.state === "saved") okN++; else if (s.state === "failed") badN++; });
          docsOk = okN;
          docsBad = badN;
          docsFinished = true;
          refreshBatchNotice();
          if (badN > 0) persistDiagnostic("final-failed");
          const t = showToast(
            `<div style="font-weight:600;color:${badN > 0 ? "#ff9800" : "#4caf50"}">${badN > 0 ? "⚠ 批量完成但有失败" : "✔ 完成"}</div>` +
            `<div style="font-size:12px;opacity:0.85;margin-top:4px">${okN} 个文件已写入「${dirHandle.name}」` +
            (badN > 0 ? `<br/>失败 ${badN}（诊断已写入 console/localStorage）` : "") + `</div>` +
            (badN > 0
              ? `<div style="margin-top:10px;display:flex;gap:6px;justify-content:center">` +
                `<button id="tmd-final-diag" style="padding:5px 12px;border-radius:4px;border:1px solid #888;background:transparent;color:#fff;cursor:pointer;font-size:11px">复制诊断</button>` +
                `<button id="tmd-final-close" style="padding:5px 12px;border-radius:4px;border:1px solid #888;background:transparent;color:#fff;cursor:pointer;font-size:11px">关闭</button>` +
                `</div>`
              : "")
          );
          const finalDiagBtn = t.querySelector("#tmd-final-diag");
          if (finalDiagBtn) finalDiagBtn.onclick = () => copyDiagnostic("final-failed-click");
          const finalCloseBtn = t.querySelector("#tmd-final-close");
          if (finalCloseBtn) finalCloseBtn.onclick = () => dismissToast();
          if (badN === 0) dismissToast(6000);
        };

        // 启动：分两路处理
        (async () => {
          const directDocs = docs.filter((d) => tracker.get(d.docEl).useViewer);
          const triggerDocs = docs.filter((d) => !tracker.get(d.docEl).useViewer);

          // weba/webz .File 直接转存 blob，串行写目录，避免点击跑偏
          const directLoop = (async () => {
            for (let i = 0; i < directDocs.length; i++) {
              if (cancelled) return;
              const d = directDocs[i];
              triggered++;
              renderToast();
              try {
                await saveWebaFileBlobDirect(d.docEl, dirHandle, tracker.get(d.docEl), renderToast, finishIfDone, ctx);
              } catch (err) {
                const s = tracker.get(d.docEl);
                if (s) s.state = "failed";
                if (s) s.error = err.message || String(err);
                logger.error(`[direct-loop] ${docName(d.docEl)}: ${err.message || String(err)}`);
                renderToast();
                finishIfDone();
              }
              if (cancelled) return;
              await sleep(120);
            }
          })();

          // webk 触发路径（顺序 click + 拦截器接 saveAs）
          const triggerLoop = (async () => {
            for (let i = 0; i < triggerDocs.length; i++) {
              if (cancelled) return;
              const d = triggerDocs[i];
              const s = tracker.get(d.docEl);
              try {
                await triggerNativeDocDownload(d.docEl, s);
                triggered++;
                if (s) s.lastClickAt = Date.now();
                renderToast();
              } catch (e) {
                if (s) { s.state = "failed"; s.error = e.message || String(e); }
                logger.warn("Native trigger failed: " + e.message);
              }
              await sleep(500);
            }
          })();

          await Promise.all([directLoop, triggerLoop]);
        })();

        // 安全网：30 分钟超时
        timeoutId = setTimeout(() => {
          let okN = 0, badN = 0;
          tracker.forEach((s) => { if (s.state === "saved") okN++; else if (s.state === "failed") badN++; });
          if (!cancelled && okN + badN < docs.length) {
            logger.warn(`[batch] timeout ${okN + badN}/${docs.length}`);
            if (pollId) clearInterval(pollId);
            interception.stop();
            off();
            docsOk = okN;
            docsBad = badN + Math.max(0, docs.length - okN - badN);
            docsFinished = true;
            refreshBatchNotice("failed");
            showToast(
              `⚠ <b>超时</b>：已完成 ${okN + badN}/${docs.length}，已写入 ${okN}<br/>` +
              `<small style="opacity:0.75">部分文件 Telegram 还没下载完。可重新选未完成的再试。</small>`
            );
            dismissToast(10000);
          }
        }, 30 * 60 * 1000);
      }

      exit();
      logger.info(
        `Selection submitted: ${media.length} media + ${docs.length} doc(s) → "${dirHandle.name}"`
      );
    };

    // ---------------- Drag brush / row sweep selection ----------------
    let dragIntent = false;
    let dragging = false;
    let dragMode = null; // 'select' | 'deselect'
    let dragStartTarget = null;
    let dragStartedOnPickable = false;
    let dragStartX = 0, dragStartY = 0;
    let sweepBox = null;
    const touched = new Set();

    const pickableInHost = (host) => {
      if (!host) return null;
      if (host.dataset && host.dataset.tmdPickable === "1") return host;
      if (!host.querySelector) return null;
      return host.querySelector(":scope > [data-tmd-pickable='1']") ||
             host.querySelector("[data-tmd-pickable='1']");
    };

    const pickableFromElement = (el) => {
      if (!el || !el.closest) return null;
      if (el.classList && el.classList.contains("tmd-pick")) return pickableInHost(el.parentElement);
      if (el.dataset && el.dataset.tmdPickable === "1") return el;

      const pickable = el.closest("[data-tmd-pickable='1']");
      if (pickable) return pickable;

      const host = el.closest("[data-tmd-parent='1']");
      if (host) return pickableInHost(host);

      const docEl = el.closest(DOC_CONTAINER_SELECTOR);
      if (docEl && docEl.dataset && docEl.dataset.tmdParent === "1") return pickableInHost(docEl);
      return null;
    };

    const findPickableAt = (x, y) => {
      const els = document.elementsFromPoint ? document.elementsFromPoint(x, y) : [document.elementFromPoint(x, y)];
      if (!els.length || (bar && bar.contains(els[0]))) return null;
      for (const el of els) {
        const target = pickableFromElement(el);
        if (target) return target;
      }
      return null;
    };

    const dragScopeRect = () => {
      const scroller = findChatScroller && findChatScroller();
      const rect = scroller && scroller.getBoundingClientRect ? scroller.getBoundingClientRect() : null;
      if (rect && rect.width > 0 && rect.height > 0) {
        const left = Math.max(0, rect.left);
        const top = Math.max(0, rect.top);
        const right = Math.min(innerWidth, rect.right);
        const bottom = Math.min(innerHeight, rect.bottom);
        return { left, top, right, bottom, width: right - left, height: bottom - top };
      }
      return { left: 0, top: 0, right: innerWidth, bottom: innerHeight, width: innerWidth, height: innerHeight };
    };

    const isPointInDragScope = (x, y) => {
      const r = dragScopeRect();
      return x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;
    };

    const shouldIgnoreDragStart = (e) => {
      const el = e.target;
      if (!el || !el.closest) return false;
      return !!el.closest(
        "#tmd-select-bar, #tmd-settings, #tmd-panel, " +
        "button, input, textarea, select, a, [contenteditable='true']"
      );
    };

    const messageRowOfPickable = (pickableEl) => {
      const info = classifyPick(pickableEl);
      const host = pickHostOf(info);
      return (host && host.closest && host.closest(MESSAGE_ROW_SELECTOR)) || host || pickableEl;
    };

    const rowSweepTargets = (fromY, toY) => {
      const top = Math.min(fromY, toY) - 8;
      const bottom = Math.max(fromY, toY) + 8;
      const out = [];
      document.querySelectorAll('[data-tmd-pickable="1"]').forEach((el) => {
        const row = messageRowOfPickable(el);
        const rect = row && row.getBoundingClientRect ? row.getBoundingClientRect() : el.getBoundingClientRect();
        if (!rect || rect.width <= 0 || rect.height <= 0) return;
        if (rect.bottom < 0 || rect.top > innerHeight) return;
        if (rect.bottom >= top && rect.top <= bottom) out.push(el);
      });
      return out;
    };

    const ensureSweepBox = () => {
      if (sweepBox && sweepBox.isConnected) return sweepBox;
      sweepBox = document.createElement("div");
      sweepBox.className = "tmd-row-sweep";
      document.body.appendChild(sweepBox);
      return sweepBox;
    };

    const updateSweepBox = (fromY, toY) => {
      const scope = dragScopeRect();
      const top = Math.max(scope.top, Math.min(fromY, toY));
      const bottom = Math.min(scope.bottom, Math.max(fromY, toY));
      const box = ensureSweepBox();
      Object.assign(box.style, {
        display: "block",
        left: `${Math.round(scope.left)}px`,
        top: `${Math.round(top)}px`,
        width: `${Math.max(0, Math.round(scope.width))}px`,
        height: `${Math.max(2, Math.round(bottom - top))}px`,
      });
    };

    const hideSweepBox = () => {
      if (sweepBox) sweepBox.style.display = "none";
    };

    const setPickedState = (pickableEl, shouldSelect) => {
      const info = classifyPick(pickableEl);
      if (!info) return;
      const key = keyOf(info);
      if (shouldSelect) {
        if (!selected.has(key)) {
          selected.set(key, info);
          syncPickVisual(key, true);
        }
      } else {
        if (selected.has(key)) {
          selected.delete(key);
          syncPickVisual(key, false);
        }
      }
    };

    const applyDrag = (target) => {
      if (!target || touched.has(target)) return;
      touched.add(target);
      setPickedState(target, dragMode === "select");
      updateCount();
    };

    const rowSweepEnabled = () => settings.rowSweepSelect !== false;

    const applyRowSweep = (currentY) => {
      updateSweepBox(dragStartY, currentY);
      rowSweepTargets(dragStartY, currentY).forEach(applyDrag);
    };

    const onMouseDown = (e) => {
      if (!active || e.button !== 0) return;
      if (shouldIgnoreDragStart(e)) return;
      const target = findPickableAt(e.clientX, e.clientY);
      if (!target && !(rowSweepEnabled() && isPointInDragScope(e.clientX, e.clientY))) return;
      dragIntent = true;
      dragging = false;
      dragStartTarget = target;
      dragStartedOnPickable = !!target;
      dragStartX = e.clientX;
      dragStartY = e.clientY;
      dragMode = null;
      touched.clear();
    };

    const onMouseMove = (e) => {
      if (!dragIntent) return;
      if (!dragging) {
        const dx = e.clientX - dragStartX;
        const dy = e.clientY - dragStartY;
        if (dx * dx + dy * dy < 25) return;
        dragging = true;
        const info = dragStartTarget ? classifyPick(dragStartTarget) : null;
        const startKey = info && keyOf(info);
        dragMode = startKey && selected.has(startKey) ? "deselect" : "select";
        if (e.altKey && !dragStartedOnPickable && rowSweepEnabled()) dragMode = "deselect";
        if (dragStartTarget) applyDrag(dragStartTarget);
        document.body.style.userSelect = "none";
      }
      e.preventDefault();
      e.stopPropagation();
      const t = findPickableAt(e.clientX, e.clientY);
      if (t) applyDrag(t);
      if (rowSweepEnabled()) applyRowSweep(e.clientY);
      else hideSweepBox();
    };

    const onMouseUp = (e) => {
      if (!dragIntent) return;
      const wasDragging = dragging;
      dragIntent = false;
      dragging = false;
      dragStartTarget = null;
      dragStartedOnPickable = false;
      dragMode = null;
      document.body.style.userSelect = "";
      hideSweepBox();
      if (wasDragging) {
        document.addEventListener("click", (ce) => {
          ce.stopPropagation();
          ce.preventDefault();
        }, { once: true, capture: true });
      }
    };

    const enter = () => {
      if (active) return;
      active = true;
      injectStyle();
      scanAll();
      buildBar();
      updateCount();
      observer = new MutationObserver(() => scanAll());
      observer.observe(document.body, { childList: true, subtree: true });
      document.addEventListener("mousedown", onMouseDown, true);
      document.addEventListener("mousemove", onMouseMove, true);
      document.addEventListener("mouseup", onMouseUp, true);
    };

    const exit = () => {
      if (!active) return;
      active = false;
      clearLayoutDebug();
      if (observer) { observer.disconnect(); observer = null; }
      document.removeEventListener("mousedown", onMouseDown, true);
      document.removeEventListener("mousemove", onMouseMove, true);
      document.removeEventListener("mouseup", onMouseUp, true);
      document.body.style.userSelect = "";
      if (sweepBox) { sweepBox.remove(); sweepBox = null; }
      document.querySelectorAll(".tmd-pick").forEach((cb) => cb.remove());
      document.querySelectorAll('[data-tmd-pickable="1"]').forEach((el) => {
        delete el.dataset.tmdPickable;
      });
      document.querySelectorAll('[data-tmd-parent="1"]').forEach((el) => {
        delete el.dataset.tmdParent;
        // 不回滚 position:relative 以免破坏其他样式；代价小
      });
      if (bar) { bar.remove(); bar = null; }
      selected.clear();
    };

    const toggle = () => (active ? exit() : enter());
    return { enter, exit, toggle, isActive: () => active };
  })();

  // ============================================================
  // 9. 扫描：为 Telegram 的下载按钮添加我们的下载能力（兼容 /a/ 和 /k/）
  // ============================================================
  const addDownloadButtonWebZ = () => {
    const storiesContainer = document.getElementById("StoryViewer");
    if (storiesContainer) {
      const storyHeader =
        storiesContainer.querySelector(".GrsJNw3y") ||
        storiesContainer.querySelector(".DropdownMenu")?.parentNode;
      if (storyHeader && !storyHeader.querySelector(".tel-download")) {
        const btn = makeDownloadButton({
          className: "Button tiny translucent-white round tel-download",
          html: `<i class="icon icon-download"></i>`,
          onClick: () => {
          const ctx = { channel: getChannelName() };
          const videoSrc = videoSrcOf(storiesContainer.querySelector("video"));
          if (videoSrc) return tel_download_video(videoSrc, ctx);
          const images = storiesContainer.querySelectorAll("img.PVZ8TOWS");
          const last = images[images.length - 1]?.src;
          if (last) tel_download_image(last, ctx);
          },
        });
        storyHeader.insertBefore(btn, storyHeader.querySelector("button"));
      }
    }

    const mediaContainer = document.querySelector("#MediaViewer .MediaViewerSlide--active");
    const mediaViewerActions = document.querySelector("#MediaViewer .MediaViewerActions");
    if (!mediaContainer || !mediaViewerActions) return;

    const videoPlayer = mediaContainer.querySelector(".MediaViewerContent > .VideoPlayer");
    const videoUrl = videoSrcOf(videoPlayer?.querySelector("video"));
    const img = mediaContainer.querySelector(".MediaViewerContent > div > img");
    hideNativeDownloadButtons(mediaViewerActions, (btn) => btn.getAttribute("title") === "Download");
    removeAll(videoPlayer, ".VideoPlayerControls .tel-download");
    syncViewerDownloadButton(
      mediaViewerActions,
      videoUrl || img?.src,
      videoUrl ? "video" : "image",
      "Button smaller translucent-white round tel-download",
      `<i class="icon icon-download"></i>`,
      "Download"
    );
  };

  const addDownloadButtonWebK = () => {
    // Pinned voice / circle video
    const pinnedAudio = document.body.querySelector(".pinned-audio");
    let dataMid;
    let downloadButtonPinnedAudio =
      document.body.querySelector("._tel_download_button_pinned_container") ||
      document.createElement("button");
    if (pinnedAudio) {
      dataMid = pinnedAudio.getAttribute("data-mid");
      downloadButtonPinnedAudio.className =
        "btn-icon tgico-download _tel_download_button_pinned_container";
      downloadButtonPinnedAudio.innerHTML = `<span class="tgico button-icon">${DOWNLOAD_ICON}</span>`;
    }
    const audioElements = document.body.querySelectorAll("audio-element");
    audioElements.forEach((audioElement) => {
      const bubble = audioElement.closest(".bubble");
      if (!bubble || bubble.querySelector("._tel_download_button_pinned_container")) return;
      if (
        dataMid &&
        downloadButtonPinnedAudio.getAttribute("data-mid") !== dataMid &&
        audioElement.getAttribute("data-mid") === dataMid
      ) {
        const link = audioElement.audio && audioElement.audio.getAttribute("src");
        const isAudio = audioElement.audio && audioElement.audio instanceof HTMLAudioElement;
        if (!link) return;
        downloadButtonPinnedAudio.onclick = (e) => {
          e.stopPropagation();
          const ctx = { channel: getChannelName() };
          if (isAudio) tel_download_audio(link, ctx);
          else tel_download_video(link, ctx);
        };
        downloadButtonPinnedAudio.setAttribute("data-mid", dataMid);
        const wrapper = pinnedAudio.querySelector(".pinned-container-wrapper-utils");
        if (wrapper) wrapper.appendChild(downloadButtonPinnedAudio);
      }
    });

    // Stories
    const storiesContainer = document.getElementById("stories-viewer");
    if (storiesContainer) {
      const createBtn = () => makeDownloadButton({
        className: "btn-icon rp tel-download",
        html: `<span class="tgico">${DOWNLOAD_ICON}</span><div class="c-ripple"></div>`,
        onClick: () => {
          const ctx = { channel: getChannelName() };
          const videoSrc = videoSrcOf(storiesContainer.querySelector("video.media-video"));
          if (videoSrc) return tel_download_video(videoSrc, ctx);
          const imageSrc = storiesContainer.querySelector("img.media-photo")?.src;
          if (imageSrc) tel_download_image(imageSrc, ctx);
        },
      });
      const storyHeader = storiesContainer.querySelector("[class^='_ViewerStoryHeaderRight']");
      if (storyHeader && !storyHeader.querySelector(".tel-download")) storyHeader.prepend(createBtn());
      const storyFooter = storiesContainer.querySelector("[class^='_ViewerStoryFooterRight']");
      if (storyFooter && !storyFooter.querySelector(".tel-download")) storyFooter.prepend(createBtn());
    }

    const mediaContainer = document.querySelector(".media-viewer-whole");
    if (!mediaContainer) return;
    const mediaAspecter = mediaContainer.querySelector(
      ".media-viewer-movers .media-viewer-aspecter"
    );
    const mediaButtons = mediaContainer.querySelector(
      ".media-viewer-topbar .media-viewer-buttons"
    );
    if (!mediaAspecter || !mediaButtons) return;

    const videoEl = mediaAspecter.querySelector("video");
    const videoUrl = videoSrcOf(videoEl);
    const thumb = mediaAspecter.querySelector("img.thumbnail");
    hideNativeDownloadButtons(mediaButtons, (btn) => {
      const txt = (btn.textContent || "").trim();
      return txt === DOWNLOAD_ICON || btn.getAttribute("title") === "Download";
    });
    removeAll(mediaAspecter, ".default__controls.ckin__controls .tel-download, .VideoPlayerControls .tel-download");
    syncViewerDownloadButton(
      mediaButtons,
      videoUrl || thumb?.src,
      videoUrl ? "video" : "image",
      "btn-icon tgico-download tel-download",
      `<span class="tgico button-icon">${DOWNLOAD_ICON}</span>`
    );
  };

  // ============================================================
  // 10. 注册菜单命令
  // ============================================================
  GM.menu("打开设置面板", openSettings);
  GM.menu("点选批量下载（推荐）", () => selectMode.enter());
  GM.menu("清空下载历史", () => { if (confirm("确认清空下载历史？")) history.clear(); });

  // ============================================================
  // 12. 启动
  // ============================================================
  logger.info(`Initialized v2.0.28 · queueConcurrency=${settings.queueConcurrency} · chunkConcurrency=${settings.chunkConcurrency} · maxChunkConcurrency=${settings.maxChunkConcurrency}`);
  const boot = () => {
    panel.mount();
    setInterval(addDownloadButtonWebZ, REFRESH_DELAY);
    setInterval(addDownloadButtonWebK, REFRESH_DELAY);
    if ("Notification" in window && Notification.permission === "default") {
      // Request notification permission on first user interaction
      const once = () => {
        Notification.requestPermission().catch(() => {});
        window.removeEventListener("click", once);
      };
      window.addEventListener("click", once, { once: true });
    }
  };

  if (document.readyState === "complete" || document.readyState === "interactive") {
    boot();
  } else {
    window.addEventListener("DOMContentLoaded", boot);
  }
})();