@zucker-framework/ext-kit 1.0.2 → 1.0.5

package/dist/ext-kit.js

@@ -1,24 +1,60 @@
 "use strict";
 (() => {
-  // src/util.ts
-  function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  var __defProp = Object.defineProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/util.js
+  function cancelled() {
+    return new Error("Cancelled");
   }
-  function clamp(value, min, max) {
-    return Math.min(Math.max(value, min), max);
+  function throwIfAborted(signal) {
+    if (signal?.aborted) throw cancelled();
   }
-  function normalizeError(error) {
-    return error instanceof Error ? error.message : String(error);
+  function withAbort(promise, signal) {
+    if (!signal) return promise;
+    if (signal.aborted) {
+      promise.catch(() => {
+      });
+      return Promise.reject(cancelled());
+    }
+    return new Promise((resolve, reject) => {
+      const abort = () => reject(cancelled());
+      signal.addEventListener("abort", abort, { once: true });
+      promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    });
   }
-  function storageGet(keys) {
-    return new Promise((resolve) => chrome.storage.local.get(keys, resolve));
+  function delay(ms, signal) {
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+      const finish = () => {
+        signal?.removeEventListener("abort", abort);
+        resolve();
+      };
+      const timer = setTimeout(finish, ms);
+      const abort = () => {
+        clearTimeout(timer);
+        reject(cancelled());
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+    });
   }
-  function storageSet(value) {
-    return new Promise((resolve) => chrome.storage.local.set(value, () => resolve()));
+  function normalizeError(error) {
+    return error instanceof Error ? error.message : String(error);
   }
-  function storageRemove(keys) {
-    return new Promise((resolve) => chrome.storage.local.remove(keys, () => resolve()));
+  function storageCall(area, method, value) {
+    return new Promise(
+      (resolve, reject) => chrome.storage[area][method](value, (result) => {
+        const error = chrome.runtime.lastError;
+        error ? reject(new Error(error.message)) : resolve(result);
+      })
+    );
   }
+  var storageGet = (keys) => storageCall("local", "get", keys);
+  var storageSet = (value) => storageCall("local", "set", value);
+  var storageRemove = (keys) => storageCall("local", "remove", keys);
 
   // src/naming.ts
   function sanitize(value) {
@@ -34,7 +70,7 @@
   function normalizeUrls(urls) {
     const out = [];
     const seen = /* @__PURE__ */ new Set();
-    for (const raw of urls || []) {
+    for (const raw of Array.isArray(urls) ? urls : []) {
       const value = String(raw || "").trim();
       if (!/^https?:\/\//i.test(value)) {
         continue;
@@ -42,7 +78,6 @@
       let key = value;
       try {
         const parsed = new URL(value);
-        parsed.hash = "";
         key = parsed.toString();
       } catch {
         continue;
@@ -112,226 +147,779 @@
     return `${brand}/${quickFolder}/${base}-${fileStamp()}.${extension}`;
   }
 
-  // src/licensing.ts
-  var CACHE_TTL_MS = 12 * 60 * 60 * 1e3;
-  function unwrap(payload) {
-    const obj = payload;
-    return obj && typeof obj === "object" && "result" in obj ? obj.result : obj || {};
-  }
+  // src/licensing.js
   function createLicensing(product, brand, config) {
+    for (const key of ["cacheTtlMs", "offlineGraceMs", "requestTimeoutMs", "retryDelayMs"]) {
+      if (!Number.isFinite(config[key]) || config[key] < 0 || key === "requestTimeoutMs" && !config[key])
+        throw new RangeError(`Invalid licensing ${key}`);
+    }
     const TOKEN_KEY = `${product}_license_token`;
     const ENTITLEMENT_KEY = `${product}_entitlement`;
     const DEVICE_KEY = `${product}_device_id`;
-    async function getDeviceId() {
-      const data = await storageGet(DEVICE_KEY);
-      if (data[DEVICE_KEY]) {
-        return data[DEVICE_KEY];
+    let refresh = null;
+    let nextRefreshAt = 0;
+    let generation = 0;
+    let mutation = false;
+    let lastStatus = null;
+    const unavailable = () => ({
+      state: "unavailable",
+      message: "Could not verify your saved Pro license. Check your connection and use Recheck Pro in License. Your activation is still saved."
+    });
+    const proStatus = (entitlement) => ({ state: "pro", entitlement });
+    function fallbackStatus(cached) {
+      if (lastStatus?.state === "invalid") return lastStatus;
+      const cachedEntitlement = usableCache(cached);
+      return cachedEntitlement ? proStatus(cachedEntitlement) : unavailable();
+    }
+    function normalize(value) {
+      if (!value || value.invalid === true) return null;
+      const normalized = config.normalizeEntitlement(value);
+      if (!normalized || typeof normalized.expiresAt !== "string") return null;
+      const expires = Date.parse(normalized.expiresAt);
+      return Number.isFinite(expires) && expires > Date.now() ? normalized : null;
+    }
+    function usableCache(cached) {
+      const age = Date.now() - Number(cached?.checkedAt);
+      return Number.isFinite(age) && age >= 0 && age < config.offlineGraceMs ? normalize(cached) : null;
+    }
+    async function request(operation, input = {}) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), config.requestTimeoutMs);
+      try {
+        return await withAbort(Promise.resolve().then(() => config.request(operation, input, controller.signal)), controller.signal);
+      } catch {
+        throw new Error(
+          "License service unreachable. Check your connection and retry."
+        );
+      } finally {
+        clearTimeout(timer);
       }
-      const bytes = new Uint8Array(16);
-      crypto.getRandomValues(bytes);
-      const id = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    async function getDeviceId() {
+      const stored = await storageGet(DEVICE_KEY);
+      if (stored[DEVICE_KEY]) return stored[DEVICE_KEY];
+      const id = crypto.randomUUID();
       await storageSet({ [DEVICE_KEY]: id });
       return id;
     }
     async function activate(code) {
-      const deviceId = await getDeviceId();
-      let response;
+      if (mutation) throw new Error("A license change is already in progress");
+      mutation = true;
+      generation += 1;
       try {
-        const platform = navigator.userAgentData?.platform || "Chrome";
-        response = await fetch(`${config.apiBase}/extension/licenses/activate`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            code: String(code || "").trim().toUpperCase().replace(/[^A-Z0-9]/g, ""),
-            deviceId,
-            deviceName: `${brand} \xB7 ${platform}`
-          })
+        const deviceId = await getDeviceId();
+        const data = await request("activate", { code, deviceId, brand });
+        if (!data.accepted)
+          throw new Error(data.denied ? "Invalid or expired code, or its device limit is reached." : "Activation failed. Please retry later.");
+        const entitlement = normalize(data?.entitlement);
+        if (!entitlement || typeof data?.token !== "string" || !data.token)
+          throw new Error(
+            "License service returned invalid activation data. Please retry."
+          );
+        await storageSet({
+          [TOKEN_KEY]: data.token,
+          [ENTITLEMENT_KEY]: { ...entitlement, checkedAt: Date.now() }
         });
-      } catch {
-        throw new Error("License service unreachable. Check your connection and retry.");
-      }
-      const payload = await response.json().catch(() => ({}));
-      if (!response.ok) {
-        if (response.status === 403) {
-          throw new Error("Invalid code, or its device limit is reached.");
-        }
-        throw new Error("Activation failed. Please retry later.");
+        nextRefreshAt = 0;
+        lastStatus = proStatus(entitlement);
+        return entitlement;
+      } finally {
+        mutation = false;
       }
-      const data = unwrap(payload);
-      await storageSet({
-        [TOKEN_KEY]: data.token || "",
-        [ENTITLEMENT_KEY]: { ...data.entitlement || {}, checkedAt: Date.now() }
-      });
-      return data.entitlement;
     }
-    function normalize(value) {
-      const v = value;
-      if (!v) {
-        return null;
+    async function refreshEntitlement(token, cached, version) {
+      try {
+        const data = await request("me", { token });
+        if (version !== generation) return null;
+        if (data.denied === true) {
+          const denied = {
+            state: "invalid",
+            message: "Your saved Pro license could not be validated. Use Recheck Pro or enter your original activation code in License to restore it."
+          };
+          lastStatus = denied;
+          try {
+            await storageRemove(ENTITLEMENT_KEY);
+          } catch {
+            await storageSet({
+              [ENTITLEMENT_KEY]: { invalid: true, active: false, checkedAt: Date.now() }
+            }).catch(() => {
+              console.warn(
+                `${brand}: rejected license cache could not be invalidated`
+              );
+            });
+          }
+          return denied;
+        }
+        const entitlement = data.accepted ? normalize(data.entitlement) : null;
+        if (entitlement) {
+          await storageSet({
+            [ENTITLEMENT_KEY]: { ...entitlement, checkedAt: Date.now() }
+          });
+          return proStatus(entitlement);
+        }
+        return fallbackStatus(cached);
+      } catch {
+        if (version !== generation) return null;
+        return fallbackStatus(cached);
       }
-      const expired = v.expiresAt && new Date(v.expiresAt).getTime() <= Date.now();
-      return expired ? null : { plan: v.plan || "pro", expiresAt: v.expiresAt || "" };
     }
-    async function getEntitlement() {
+    async function getStatus({ cachedOnly = false, force = false } = {}) {
       const data = await storageGet([TOKEN_KEY, ENTITLEMENT_KEY]);
-      const token = data[TOKEN_KEY];
-      const cached = data[ENTITLEMENT_KEY];
-      if (!token) {
-        return null;
-      }
-      if (cached?.checkedAt && Date.now() - cached.checkedAt < CACHE_TTL_MS) {
-        return normalize(cached);
-      }
-      let response;
-      try {
-        response = await fetch(`${config.apiBase}/extension/licenses/me`, {
-          headers: { Authorization: `Bearer ${token}` }
+      const token = data[TOKEN_KEY], cached = data[ENTITLEMENT_KEY];
+      if (!token) return { state: "free" };
+      const valid = lastStatus?.state === "invalid" ? null : usableCache(cached);
+      if (!force && valid && Date.now() - cached.checkedAt < config.cacheTtlMs)
+        return proStatus(valid);
+      if (mutation) return { state: "checking", refreshing: true };
+      if (!refresh && (force || Date.now() >= nextRefreshAt)) {
+        const version = generation;
+        nextRefreshAt = Date.now() + config.retryDelayMs;
+        refresh = refreshEntitlement(token, cached, version).then((status2) => {
+          if (version === generation && status2) lastStatus = status2;
+          return status2;
+        }).finally(() => {
+          refresh = null;
         });
-      } catch {
-        return cached ? normalize(cached) : null;
       }
-      if (!response.ok) {
-        if (response.status === 401 || response.status === 403) {
-          await clear();
-          return null;
-        }
-        return cached ? normalize(cached) : null;
+      if (refresh && !cachedOnly) {
+        const status2 = await refresh;
+        return status2 || getStatus();
       }
-      const payload = await response.json().catch(() => ({}));
-      const entitlement = unwrap(payload)?.entitlement;
-      await storageSet({
-        [ENTITLEMENT_KEY]: { ...entitlement || {}, checkedAt: Date.now() }
-      });
-      return normalize(entitlement);
+      const remembered = lastStatus?.state === "pro" ? null : lastStatus;
+      const status = valid ? proStatus(valid) : refresh ? { state: "checking" } : remembered || unavailable();
+      return { ...status, refreshing: Boolean(refresh) };
     }
-    async function isPro() {
-      return Boolean(await getEntitlement());
+    async function getEntitlement(options) {
+      return (await getStatus(options)).entitlement || null;
     }
-    async function clear() {
-      await storageRemove([TOKEN_KEY, ENTITLEMENT_KEY]);
+    async function deactivate() {
+      if (mutation) throw new Error("A license change is already in progress");
+      mutation = true;
+      generation += 1;
+      try {
+        const data = await storageGet(TOKEN_KEY);
+        if (data[TOKEN_KEY]) {
+          const result = await request("deactivate", { token: data[TOKEN_KEY] });
+          if (!result.accepted || result.deactivated !== true)
+            throw new Error(
+              "Could not release this device. Your license is still saved; please retry."
+            );
+        }
+        await storageRemove([TOKEN_KEY, ENTITLEMENT_KEY]);
+        nextRefreshAt = 0;
+        lastStatus = null;
+      } finally {
+        mutation = false;
+      }
     }
-    return { activate, getEntitlement, isPro, clear, purchaseUrl: config.purchaseUrl };
+    return {
+      activate,
+      getEntitlement,
+      getStatus,
+      deactivate,
+      purchaseUrl: config.purchaseUrl
+    };
   }
 
-  // src/download.ts
-  function createDownloader(justification) {
-    const pendingDownloadNames = /* @__PURE__ */ new Map();
+  // src/download.js
+  function createDownloader(justification, options = {}) {
+    const deadlineMs = options.deadlineMs ?? 12e4;
+    const blobLeaseMs = options.blobLeaseMs ?? 18e4;
+    const pollMs = options.pollMs ?? 1e3;
+    if (![deadlineMs, blobLeaseMs, pollMs].every((n) => Number.isFinite(n) && n > 0) || blobLeaseMs <= deadlineMs)
+      throw new RangeError("Invalid download deadline, polling or blob lease");
+    const names = /* @__PURE__ */ new Map();
+    const waiters = /* @__PURE__ */ new Map();
     let offscreenSetup = null;
     chrome.downloads.onDeterminingFilename.addListener((item, suggest) => {
-      const fileName = pendingDownloadNames.get(item.url) || pendingDownloadNames.get(item.finalUrl || "");
-      if (!fileName) {
-        return;
-      }
-      suggest({ filename: fileName, conflictAction: "uniquify" });
-      return true;
+      const filename = names.get(item.url) || names.get(item.finalUrl);
+      if (filename) suggest({ filename, conflictAction: "uniquify" });
+    });
+    chrome.downloads.onChanged.addListener((delta) => {
+      if (delta.state?.current === "complete" || delta.state?.current === "interrupted")
+        waiters.get(delta.id)?.();
     });
     async function ensureOffscreen() {
-      if (await chrome.offscreen.hasDocument()) {
-        return;
-      }
-      if (!offscreenSetup) {
-        offscreenSetup = chrome.offscreen.createDocument({
-          url: "offscreen.html",
-          reasons: [chrome.offscreen.Reason.BLOBS],
-          justification
-        }).catch((error) => {
-          if (!String(error?.message || "").includes("Only a single")) {
-            throw error;
-          }
-        }).finally(() => {
+      if (!offscreenSetup)
+        offscreenSetup = (async () => {
+          if (!await chrome.offscreen.hasDocument())
+            await chrome.offscreen.createDocument({
+              url: options.offscreenUrl || "offscreen.html",
+              reasons: [chrome.offscreen.Reason.BLOBS],
+              justification
+            });
+        })().finally(() => {
           offscreenSetup = null;
         });
-      }
       return offscreenSetup;
     }
-    async function downloadViaBlob(base64, mime, filename) {
+    async function cleanup(url) {
+      names.delete(url);
+      if (url)
+        await chrome.runtime.sendMessage({ target: "offscreen", type: "REVOKE_BLOB_URL", url }).catch(() => {
+        });
+    }
+    async function waitForDownload(id, signal) {
+      return new Promise((resolve, reject) => {
+        let finished = false;
+        let deadlineError;
+        const finish = (error, item) => {
+          if (finished) return;
+          finished = true;
+          clearInterval(poll);
+          clearTimeout(timeout);
+          signal?.removeEventListener("abort", abort);
+          waiters.delete(id);
+          error ? reject(error) : resolve(item);
+        };
+        const inspect = async () => {
+          try {
+            const [item] = await chrome.downloads.search({ id });
+            if (!item) return finish(new Error("Download no longer exists"));
+            if (item.state === "complete") finish(null, item);
+            else if (item.state === "interrupted")
+              finish(
+                deadlineError || new Error(
+                  item.error === "USER_CANCELED" ? "Cancelled" : `Download interrupted: ${item.error || "unknown error"}`
+                )
+              );
+          } catch (error) {
+            finish(error);
+          }
+        };
+        const abort = async () => {
+          await chrome.downloads.cancel(id).catch(() => {
+          });
+          const [item] = await chrome.downloads.search({ id }).catch(() => []);
+          item?.state === "complete" ? finish(null, item) : finish(cancelled());
+        };
+        const poll = setInterval(inspect, pollMs);
+        const timeout = setTimeout(async () => {
+          deadlineError = new Error("Download completion timed out");
+          await chrome.downloads.cancel(id).catch(() => {
+          });
+          finish(deadlineError);
+        }, deadlineMs);
+        waiters.set(id, inspect);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted) void abort();
+        else void inspect();
+      });
+    }
+    async function recover(item, signal) {
+      const matches = item.downloadId != null ? await chrome.downloads.search({ id: item.downloadId }) : await chrome.downloads.search({
+        url: `^${item.downloadUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`
+      });
+      const download = matches.find(
+        (d) => d.byExtensionId === chrome.runtime.id && (!item.downloadUrl || d.url === item.downloadUrl)
+      );
+      if (!download) {
+        await cleanup(item.downloadUrl);
+        throw new Error(
+          "Interrupted download could not be confirmed. Retry this page."
+        );
+      }
+      try {
+        return await waitForDownload(download.id, signal);
+      } finally {
+        await cleanup(item.downloadUrl);
+      }
+    }
+    async function downloadViaBlob(base64, mime, filename, { signal, onPrepared, onCreated } = {}) {
+      throwIfAborted(signal);
       await ensureOffscreen();
+      throwIfAborted(signal);
       const created = await chrome.runtime.sendMessage({
         target: "offscreen",
         type: "CREATE_BLOB_URL",
         base64,
-        mime
+        mime,
+        leaseMs: blobLeaseMs
       });
-      if (!created?.ok || !created.url) {
+      if (!created?.ok || !created.url)
         throw new Error(created?.error || "Failed to prepare download");
-      }
       const url = created.url;
-      pendingDownloadNames.set(url, filename);
-      const cleanup = () => {
-        pendingDownloadNames.delete(url);
-        chrome.runtime.sendMessage({ target: "offscreen", type: "REVOKE_BLOB_URL", url }).catch(() => {
-        });
-      };
+      names.set(url, filename);
+      let downloadId;
       try {
-        const downloadId = await new Promise((resolve, reject) => {
-          chrome.downloads.download(
-            { url, filename, conflictAction: "uniquify", saveAs: false },
-            (id) => {
-              const error = chrome.runtime.lastError;
-              error ? reject(new Error(error.message)) : resolve(id);
-            }
-          );
+        await onPrepared?.(url);
+        throwIfAborted(signal);
+        downloadId = await chrome.downloads.download({
+          url,
+          filename,
+          conflictAction: "uniquify",
+          saveAs: false
         });
-        setTimeout(cleanup, 6e4);
+        await onCreated?.(downloadId);
+        await waitForDownload(downloadId, signal);
         return downloadId;
       } catch (error) {
-        cleanup();
+        if (downloadId != null)
+          await chrome.downloads.cancel(downloadId).catch(() => {
+          });
         throw error;
+      } finally {
+        await cleanup(url);
       }
     }
-    return { downloadViaBlob };
+    return { downloadViaBlob, recover };
   }
 
-  // src/session.ts
+  // src/scroll-capture.js
+  var scroll_capture_exports = {};
+  __export(scroll_capture_exports, {
+    prepare: () => prepare,
+    restore: () => restore
+  });
+  var sessions = /* @__PURE__ */ new WeakMap();
+  function pageTask(action, id, index, leaseMs) {
+    const key = "__zuckerScrollCapture";
+    let state = window[key];
+    if (action === "restore") {
+      if (state?.id === id) state.restore();
+      return {};
+    }
+    if (action === "init") {
+      if (state) throw new Error("Another scrolling-content capture is active");
+      const elements = [...document.querySelectorAll("*")];
+      if (elements.length > 3e4)
+        throw new Error(
+          "This page is too complex to expand its scrolling content safely."
+        );
+      const panels = elements.filter((el) => {
+        if (el === document.body || el === document.documentElement || el === document.scrollingElement || el.closest(
+          'nav,aside,[role="navigation"],[role="menu"],textarea,select'
+        ))
+          return false;
+        const rect = el.getBoundingClientRect(), css = getComputedStyle(el);
+        if (rect.width < 120 || rect.height < 80 || el.scrollHeight <= el.clientHeight + 2 || !/^(auto|scroll|overlay)$/.test(css.overflowY) || css.visibility !== "visible")
+          return false;
+        for (let parent = el; parent; parent = parent.parentElement) {
+          const style = getComputedStyle(parent);
+          if (style.display === "none" || Number(style.opacity) === 0)
+            return false;
+        }
+        return true;
+      });
+      if (!panels.length) return { count: 0 };
+      if (panels.length > 24)
+        throw new Error(
+          "This page has too many independent scrolling areas. Use Visible window or export smaller sections."
+        );
+      const virtual = '.rc-virtual-list-holder,.ant-table-tbody-virtual-holder,[data-virtuoso-scroller],.ReactVirtualized__Grid,.ReactVirtualized__List,[data-virtualized="true"]';
+      if (panels.some(
+        (el) => el.matches(virtual) || [...el.querySelectorAll(virtual)].some(
+          (list) => list.getClientRects().length && list.checkVisibility({
+            checkOpacity: true,
+            checkVisibilityCSS: true
+          })
+        )
+      ))
+        throw new Error(
+          "This page uses a virtual scrolling list. A complete full-page capture is not available; use the table's export or Visible window."
+        );
+      const changes = /* @__PURE__ */ new Map(), scrolls = /* @__PURE__ */ new Map();
+      state = {
+        id,
+        panels,
+        changes,
+        scrolls,
+        boxes: /* @__PURE__ */ new Map(),
+        watchdog: null,
+        leaseMs
+      };
+      state.set = (el, property, value) => {
+        if (!changes.has(el))
+          changes.set(el, {
+            hadStyle: el.hasAttribute("style"),
+            properties: /* @__PURE__ */ new Map()
+          });
+        const saved = changes.get(el).properties;
+        if (!saved.has(property))
+          saved.set(property, {
+            value: el.style.getPropertyValue(property),
+            priority: el.style.getPropertyPriority(property)
+          });
+        el.style.setProperty(property, value, "important");
+      };
+      state.restore = () => {
+        clearTimeout(state.watchdog);
+        const scrollingProperties = /* @__PURE__ */ new Set([
+          "scroll-behavior",
+          "scroll-snap-type",
+          "overflow-anchor"
+        ]);
+        const restoreProperty = (el, property, old) => old.value ? el.style.setProperty(property, old.value, old.priority) : el.style.removeProperty(property);
+        for (const [el, saved] of [...changes].reverse())
+          for (const [property, old] of saved.properties)
+            if (!scrollingProperties.has(property))
+              restoreProperty(el, property, old);
+        for (const [el, saved] of scrolls) {
+          el.scrollLeft = saved.x;
+          el.scrollTop = saved.y;
+        }
+        for (const [el, saved] of changes) {
+          for (const [property, old] of saved.properties)
+            if (scrollingProperties.has(property))
+              restoreProperty(el, property, old);
+          if (!saved.hadStyle && !el.style.length) {
+            el.getAttribute("style");
+            el.removeAttribute("style");
+          }
+        }
+        if (window[key]?.id === id) delete window[key];
+      };
+      window[key] = state;
+      state.watchdog = setTimeout(state.restore, state.leaseMs);
+      for (const el of elements) {
+        if (!el.scrollTop && !el.scrollLeft) continue;
+        scrolls.set(el, { x: el.scrollLeft, y: el.scrollTop });
+        state.set(el, "scroll-behavior", "auto");
+        state.set(el, "scroll-snap-type", "none");
+        state.set(el, "overflow-anchor", "none");
+      }
+      for (const panel of panels) {
+        const rect = panel.getBoundingClientRect();
+        state.boxes.set(panel, { width: rect.width, x: rect.x });
+        scrolls.set(panel, { x: panel.scrollLeft, y: panel.scrollTop });
+        state.set(panel, "scroll-behavior", "auto");
+        state.set(panel, "scroll-snap-type", "none");
+        state.set(panel, "overflow-anchor", "none");
+        panel.scrollTop = 0;
+      }
+      return { count: panels.length };
+    }
+    if (!state || state.id !== id)
+      throw new Error(
+        "The page changed while preparing its scrolling content."
+      );
+    clearTimeout(state.watchdog);
+    state.watchdog = setTimeout(state.restore, state.leaseMs);
+    if (action === "scroll" || action === "position") {
+      const panel = state.panels[index];
+      if (!panel.isConnected)
+        throw new Error(
+          "A scrolling area changed during capture. Please retry."
+        );
+      if (action === "scroll")
+        panel.scrollTop += Math.max(80, panel.clientHeight * 0.8);
+      return {
+        bottom: panel.scrollTop + panel.clientHeight >= panel.scrollHeight - 1,
+        height: panel.scrollHeight
+      };
+    }
+    if (action === "expand") {
+      for (const panel of [...state.panels].reverse()) {
+        if (!panel.isConnected)
+          throw new Error(
+            "A scrolling area changed during capture. Please retry."
+          );
+        let el = panel;
+        while (el) {
+          const rect = el.getBoundingClientRect(), css = getComputedStyle(el);
+          if (!state.scrolls.has(el))
+            state.scrolls.set(el, { x: el.scrollLeft, y: el.scrollTop });
+          if (!state.boxes.has(el))
+            state.boxes.set(el, { width: rect.width, x: rect.x });
+          state.set(el, "scroll-behavior", "auto");
+          state.set(el, "overflow-anchor", "none");
+          state.set(el, "transition", "none");
+          state.set(el, "box-sizing", "border-box");
+          state.set(el, "width", `${state.boxes.get(el).width}px`);
+          state.set(el, "max-height", "none");
+          state.set(el, "flex-shrink", "0");
+          if (css.position === "fixed") {
+            state.set(el, "position", "absolute");
+            state.set(el, "top", `${rect.top + scrollY}px`);
+            state.set(el, "left", `${rect.left + scrollX}px`);
+            state.set(el, "right", "auto");
+          }
+          if (css.position === "fixed" || css.position === "absolute")
+            state.set(el, "bottom", "auto");
+          if (state.panels.includes(el)) {
+            const height = el.scrollHeight + el.offsetHeight - el.clientHeight;
+            state.set(el, "height", `${height}px`);
+            state.set(el, "min-height", `${height}px`);
+            state.set(el, "scrollbar-gutter", "stable");
+            state.set(el, "overflow-y", "hidden");
+            el.scrollTop = 0;
+          } else {
+            state.set(el, "height", "auto");
+            state.set(
+              el,
+              "min-height",
+              `${Math.max(rect.height, el.clientHeight)}px`
+            );
+            if (/hidden|clip|auto|scroll/.test(css.overflowY)) {
+              state.set(el, "overflow-x", "clip");
+              state.set(el, "overflow-y", "visible");
+            }
+          }
+          if (css.contain !== "none") state.set(el, "contain", "none");
+          el = el.parentElement;
+        }
+      }
+      return { height: document.documentElement.scrollHeight };
+    }
+    if (action === "measure") {
+      for (const panel of state.panels) {
+        const rect = panel.getBoundingClientRect(), original = state.boxes.get(panel);
+        if (Math.abs(rect.width - original.width) > 1 || Math.abs(rect.x - original.x) > 1)
+          throw new Error(
+            "This scrolling layout cannot be expanded without changing its width. Use Visible window or the website's export."
+          );
+      }
+      return {
+        height: Math.max(
+          document.documentElement.scrollHeight,
+          document.body?.scrollHeight || 0
+        ),
+        panels: state.panels.map((el) => [el.scrollHeight, el.clientHeight]),
+        ready: document.fonts.status === "loaded" && [...document.images].every(
+          (image) => image.complete || !state.panels.some((panel) => panel.contains(image)) || !image.getClientRects().length || image.checkVisibility?.({
+            checkOpacity: true,
+            checkVisibilityCSS: true
+          }) === false
+        )
+      };
+    }
+    return {};
+  }
+  async function command(ctx, id, action, index, leaseMs) {
+    const response = await ctx[action === "restore" ? "cleanup" : "send"](
+      "Runtime.evaluate",
+      {
+        expression: `(${pageTask.toString()})(${JSON.stringify(action)},${JSON.stringify(id)},${JSON.stringify(index)},${JSON.stringify(leaseMs)})`,
+        returnByValue: true
+      }
+    );
+    if (response?.exceptionDetails)
+      throw new Error(
+        response.exceptionDetails.exception?.description?.split("\n")[0] || "Could not prepare scrolling content"
+      );
+    return response?.result?.value || {};
+  }
+  async function prepare(ctx, waitForContent = async () => {
+  }) {
+    const id = crypto.randomUUID();
+    sessions.set(ctx, id);
+    const readinessMs = Math.min(
+      6e4,
+      Math.max(0, Number(ctx.options?.readyTimeoutMs) || 25e3)
+    );
+    const initial = await command(
+      ctx,
+      id,
+      "init",
+      null,
+      Math.max(6e4, readinessMs + 15e3)
+    );
+    if (!initial.count) {
+      sessions.delete(ctx);
+      return;
+    }
+    let deadline = Date.now() + readinessMs + 15e3;
+    for (let index = 0; index < initial.count; index++) {
+      let bottom = false;
+      for (let step = 0; step < 60 && Date.now() < deadline; step++) {
+        const position = await command(ctx, id, "scroll", index);
+        await new Promise((resolve) => setTimeout(resolve, 120));
+        if (position.bottom) {
+          await waitForContent();
+          const loaded = await command(ctx, id, "position", index);
+          if (loaded.bottom && loaded.height === position.height) {
+            bottom = true;
+            break;
+          }
+        }
+      }
+      if (!bottom)
+        throw new Error(
+          "Scrolling content keeps growing or exceeds the capture limit. Use Visible window or a smaller section."
+        );
+    }
+    await waitForContent();
+    await command(ctx, id, "expand");
+    await waitForContent();
+    deadline = Date.now() + 15e3;
+    let previous = "", stable = 0;
+    while (Date.now() < deadline) {
+      await command(ctx, id, "expand");
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      const measured = await command(ctx, id, "measure");
+      const signature = JSON.stringify([measured.height, measured.panels]);
+      stable = measured.ready && signature === previous && measured.panels.every(([full, view]) => full <= view + 2) ? stable + 1 : 0;
+      if (stable >= 2) return;
+      previous = signature;
+    }
+    throw new Error(
+      "Scrolling content did not settle in time. Wait for it to finish loading and retry."
+    );
+  }
+  async function restore(ctx) {
+    const id = sessions.get(ctx);
+    if (!id) return;
+    sessions.delete(ctx);
+    await command(ctx, id, "restore");
+  }
+
+  // src/session.js
   function debuggerAttach(target, version) {
-    return new Promise((resolve, reject) => {
-      chrome.debugger.attach(target, version, () => {
+    return new Promise(
+      (resolve, reject) => chrome.debugger.attach(target, version, () => {
         const error = chrome.runtime.lastError;
         error ? reject(new Error(error.message)) : resolve();
-      });
-    });
+      })
+    );
   }
   function debuggerDetach(target) {
-    return new Promise((resolve, reject) => {
-      chrome.debugger.detach(target, () => {
+    return new Promise(
+      (resolve, reject) => chrome.debugger.detach(target, () => {
         const error = chrome.runtime.lastError;
         error ? reject(new Error(error.message)) : resolve();
-      });
-    });
+      })
+    );
   }
-  function sendCommand(target, method, params) {
-    return new Promise((resolve, reject) => {
-      chrome.debugger.sendCommand(target, method, params || {}, (result) => {
-        const error = chrome.runtime.lastError;
-        error ? reject(new Error(error.message)) : resolve(result || {});
-      });
+  function sendCommand(target, method, params, signal) {
+    throwIfAborted(signal);
+    return withAbort(
+      new Promise(
+        (resolve, reject) => chrome.debugger.sendCommand(target, method, params || {}, (result) => {
+          const error = chrome.runtime.lastError;
+          if (error) reject(new Error(error.message));
+          else if (result?.exceptionDetails)
+            reject(new Error("Page script could not be evaluated"));
+          else resolve(result || {});
+        })
+      ),
+      signal
+    );
+  }
+  async function waitForLoad(tabId, timeoutMs, signal) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      throwIfAborted(signal);
+      const tab = await chrome.tabs.get(tabId);
+      if (tab.status === "complete") return;
+      await delay(250, signal);
+    }
+    throw new Error("Page load timeout");
+  }
+  async function evaluatePage(target, fn, args, signal) {
+    const result = await sendCommand(
+      target,
+      "Runtime.evaluate",
+      {
+        expression: `(${fn.toString()})(${JSON.stringify(args ?? null)})`,
+        returnByValue: true
+      },
+      signal
+    );
+    return result.result?.value;
+  }
+  function watchNetwork(target) {
+    const pending = /* @__PURE__ */ new Set();
+    let changedAt = Date.now();
+    const listener = (source, method, params) => {
+      if (source.tabId !== target.tabId) return;
+      if (method === "Network.requestWillBeSent" && ["Document", "XHR", "Fetch", "Stylesheet", "Font"].includes(params.type)) {
+        pending.add(params.requestId);
+        changedAt = Date.now();
+      } else if (["Network.loadingFinished", "Network.loadingFailed"].includes(method) && pending.delete(params.requestId))
+        changedAt = Date.now();
+    };
+    chrome.debugger.onEvent.addListener(listener);
+    return {
+      busy: () => pending.size > 0 || Date.now() - changedAt < 750,
+      reset: () => {
+        pending.clear();
+        changedAt = Date.now();
+      },
+      dispose: () => chrome.debugger.onEvent.removeListener(listener)
+    };
+  }
+  async function preparePageForCapture(target, signal) {
+    await sendCommand(
+      target,
+      "Emulation.setFocusEmulationEnabled",
+      { enabled: true },
+      signal
+    ).catch((error) => {
+      throwIfAborted(signal);
     });
   }
-  function waitForLoad(tabId, timeoutMs) {
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      const finish = (fn, value) => {
-        if (!settled) {
-          settled = true;
-          chrome.tabs.onUpdated.removeListener(listener);
-          clearTimeout(timer);
-          fn(value);
-        }
-      };
-      const listener = (updatedTabId, changeInfo) => {
-        if (updatedTabId === tabId && changeInfo.status === "complete") {
-          finish(resolve);
-        }
-      };
-      const timer = setTimeout(() => finish(reject, new Error("Page load timeout")), timeoutMs);
-      chrome.tabs.onUpdated.addListener(listener);
-      chrome.tabs.get(tabId).then((tab) => {
-        if (tab.status === "complete") {
-          finish(resolve);
-        }
-      }).catch(() => {
+  function pageMetrics({ maxSeenY = 0 } = {}) {
+    function visible(el) {
+      if (!el?.getBoundingClientRect) return false;
+      const rect = el.getBoundingClientRect();
+      if (rect.width <= 2 || rect.height <= 2 || rect.top > maxSeenY + innerHeight)
+        return false;
+      for (let node = el; node instanceof Element; node = node.parentElement) {
+        const style = getComputedStyle(node);
+        if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) < 0.05)
+          return false;
+      }
+      return true;
+    }
+    const text = (document.body?.innerText || "").replace(/\s+/g, " ").trim();
+    const strong = '[aria-busy="true"],.ant-spin-spinning,.ant-skeleton,.mantine-Loader-root,.MuiCircularProgress-root,.v-progress-circular--indeterminate,.el-loading-mask,.chakra-spinner,[role="progressbar"]:not([aria-valuenow])';
+    let loading = [...document.querySelectorAll(strong)].some(visible);
+    if (!loading)
+      loading = [
+        ...document.querySelectorAll(".loading,.loader,.spinner,.skeleton")
+      ].some((el) => {
+        if (!visible(el)) return false;
+        const words = (el.innerText || "").trim();
+        const rect = el.getBoundingClientRect();
+        return words.length < 160 && /^(loading\b|please wait\b|加载中|正在加载|読み込み中|로딩)/i.test(
+          words
+        ) || !words && rect.width <= 256 && rect.height <= 256 && getComputedStyle(el).animationName !== "none";
       });
-    });
+    const pendingImages = [...document.images].filter(
+      (img) => !img.complete && visible(img) && img.width * img.height > 4e3
+    ).length;
+    const fontsPending = document.fonts?.status === "loading";
+    let hash = 0;
+    for (let i = 0; i < text.length; i += Math.max(1, Math.floor(text.length / 2e3)))
+      hash = Math.imul(hash, 31) + text.charCodeAt(i) | 0;
+    const height = Math.max(
+      document.body?.scrollHeight || 0,
+      document.documentElement.scrollHeight
+    );
+    return {
+      complete: document.readyState === "complete",
+      loading,
+      pendingImages,
+      fontsPending,
+      signature: [
+        location.href,
+        text.length,
+        hash,
+        height,
+        pendingImages,
+        fontsPending
+      ].join("|")
+    };
+  }
+  async function waitForPageStable(target, options, signal, network, maxSeenY = 0) {
+    const start = Date.now();
+    let signature = "", stableSince = start, last;
+    while (Date.now() - start < options.readyTimeoutMs) {
+      throwIfAborted(signal);
+      last = await evaluatePage(target, pageMetrics, { maxSeenY }, signal);
+      if (!last) throw new Error("Could not inspect page readiness");
+      if (last.signature !== signature || !last.complete || last.loading || last.pendingImages || last.fontsPending || network?.busy())
+        stableSince = Date.now();
+      signature = last.signature;
+      if (Date.now() - stableSince >= 1e3) return "";
+      await delay(250, signal);
+    }
+    const reason = last?.loading ? "Page still shows loading UI" : "Page content is still changing or loading";
+    if (options.allowUnstable)
+      return `${reason}; captured after the readiness timeout at your request.`;
+    throw new Error(
+      `${reason}. Increase readiness wait, or choose Capture after timeout in Settings if this page is ready.`
+    );
   }
   function challengeError(name) {
     const error = new Error(`Blocked by ${name} verification`);
@@ -341,122 +929,96 @@
   function isChallengeError(error) {
     return Boolean(error?.isChallenge);
   }
-  var CHALLENGE_TITLE_RE = /just a moment|checking your browser|attention required|verifying|security checkpoint|正在验证|安全检查点|verify you are human|are you a robot|请完成验证|人机验证|captcha/;
-  async function probePage(target) {
-    const r = await sendCommand(target, "Runtime.evaluate", {
-      returnByValue: true,
-      expression: `(function(){
-      var uri=document.documentURI||"";
-      if(uri.indexOf("chrome-error://")===0) return {error:"Page failed to load (DNS or network error)",challenge:""};
-      var t=(document.title||"").toLowerCase();
-      var b=(document.body?document.body.innerText:"").slice(0,500).toLowerCase();
-      var u=(location.href||"").toLowerCase();
-      var s=t+" "+b+" "+u;
-      var c="";
-      if(/just a moment|checking your browser|attention required|cf-browser-verification|challenges\\.cloudflare/.test(s)) c="Cloudflare";
-      else if(/verifying your browser|\u6B63\u5728\u9A8C\u8BC1\u60A8\u7684\u6D4F\u89C8\u5668|security checkpoint|\u5B89\u5168\u68C0\u67E5\u70B9/.test(s)) c="Vercel";
-      else if(/verify you are human|are you a robot|\u8BF7\u5B8C\u6210\u9A8C\u8BC1|\u4EBA\u673A\u9A8C\u8BC1|captcha/.test(s)) c="bot-check";
-      return {error:"",challenge:c};
-    })()`
+  function pageProbe() {
+    if (document.documentURI.startsWith("chrome-error://"))
+      return {
+        error: "Page failed to load (DNS or network error)",
+        challenge: ""
+      };
+    const shown = (selector) => [...document.querySelectorAll(selector)].some((el) => {
+      const r = el.getBoundingClientRect();
+      return r.width > 0 && r.height > 0 && el.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true });
     });
-    const value = r.result?.value;
-    return value || { error: "", challenge: "" };
+    const title = document.title.trim().toLowerCase();
+    let challenge = "";
+    if (shown("#challenge-form,#challenge-stage,#cf-challenge-running") && /just a moment|checking your browser|attention required|verify/.test(
+      title
+    ))
+      challenge = "Cloudflare";
+    else if (shown("#vercel-security-checkpoint,#challenge-container") && /security checkpoint|verifying your browser|安全检查点/.test(title))
+      challenge = "Vercel";
+    else if (/^(verify you are human|human verification|are you a robot|captcha|人机验证)[\s.!?—-]*$/i.test(
+      title
+    ) && shown(
+      'iframe[src*="recaptcha"],iframe[src*="hcaptcha"],iframe[src*="challenges.cloudflare.com"],input[name*="captcha"],[data-sitekey]'
+    ))
+      challenge = "bot-check";
+    return { error: "", challenge };
+  }
+  async function probePage(target, signal) {
+    return await evaluatePage(target, pageProbe, null, signal) || {
+      error: "",
+      challenge: ""
+    };
   }
-  async function waitForVerification(tabId, shouldStop, timeoutMs = 18e4) {
+  async function waitForVerification(tabId, shouldStop, signal, timeoutMs = 18e4) {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
-      if (shouldStop()) {
-        return false;
-      }
-      await delay(2500);
+      throwIfAborted(signal);
+      if (shouldStop()) return false;
+      await delay(2500, signal);
       const tab = await chrome.tabs.get(tabId).catch(() => null);
-      if (!tab) {
-        return false;
-      }
-      const title = (tab.title || "").toLowerCase();
-      const url = (tab.url || "").toLowerCase();
-      if (url.startsWith("chrome-error")) {
-        continue;
-      }
-      if (title && !CHALLENGE_TITLE_RE.test(title)) {
-        return true;
+      if (!tab) return false;
+      if (tab.status !== "complete") continue;
+      const target = { tabId };
+      let attached = false;
+      try {
+        await debuggerAttach(target, "1.3");
+        attached = true;
+        const result = await probePage(target, signal);
+        if (!result.challenge && !result.error) return true;
+      } catch {
+        throwIfAborted(signal);
+      } finally {
+        if (attached) await debuggerDetach(target).catch(() => {
+        });
       }
     }
     return false;
   }
   async function focusTab(tabId) {
-    await chrome.tabs.update(tabId, { active: true }).catch(() => {
-    });
-    try {
-      const tab = await chrome.tabs.get(tabId);
-      if (tab.windowId != null) {
-        await chrome.windows.update(tab.windowId, { focused: true });
-      }
-    } catch {
-    }
-  }
-  function autoScroll(target) {
-    return sendCommand(target, "Runtime.evaluate", {
-      awaitPromise: true,
-      expression: `new Promise(function(resolve){
-      var distance=600, scrolled=0, guard=0;
-      var maxHeight=Math.min(document.body?document.body.scrollHeight:0, 20000);
-      var timer=setInterval(function(){
-        window.scrollBy(0, distance);
-        scrolled+=distance; guard+=1;
-        var reached=scrolled>=Math.max(maxHeight, document.body?document.body.scrollHeight:0);
-        if(reached || guard>60){
-          clearInterval(timer);
-          setTimeout(function(){ window.scrollTo(0,0); setTimeout(resolve, 400); }, 300);
-        }
-      }, 120);
-    })`
-    }).catch(() => void 0);
+    const tab = await chrome.tabs.update(tabId, { active: true });
+    await chrome.windows.update(tab.windowId, { focused: true });
   }
-  function revealAnimations(target, reversible = false) {
-    return sendCommand(target, "Runtime.evaluate", {
-      expression: `(function(){
-      try{
-        var reversible=${reversible ? "true" : "false"};
-        var state=reversible?{style:null,aos:[],inline:[]}:null;
-        var css=document.createElement('style');
-        css.textContent=[
-          '[data-aos]{opacity:1!important;transform:none!important;transition:none!important;}',
-          '.wow{visibility:visible!important;opacity:1!important;animation-name:none!important;}',
-          '.animate__animated,.animated{opacity:1!important;}',
-          '[data-scroll]{opacity:1!important;transform:none!important;}',
-          '.reveal,[data-sr],[data-sr-id],.sr-reveal{opacity:1!important;transform:none!important;visibility:visible!important;}'
-        ].join('');
-        (document.head||document.documentElement).appendChild(css);
-        if(state) state.style=css;
-        document.querySelectorAll('[data-aos]').forEach(function(el){
-          if(state&&!el.classList.contains('aos-animate')) state.aos.push(el);
-          el.classList.add('aos-animate');
-        });
-        // \u901A\u7528\u515C\u5E95\uFF1A\u88AB\u52A8\u753B\u85CF\u8D77\u6765\u7684\u5185\u5BB9\u5757\uFF08opacity\u22480 \u4E14\u5E26 transition/animation\uFF09\u5F3A\u5236\u663E\u793A\u3002
-        // \u53EA\u5904\u7406 static/relative\uFF08\u666E\u901A\u5185\u5BB9\u6D41\uFF09\uFF0C\u8DF3\u8FC7 fixed/absolute\uFF08\u591A\u4E3A\u5F39\u7A97/\u83DC\u5355/\u8F6E\u64AD\uFF09\uFF0C\u907F\u514D\u8BEF\u4F24
-        var all=document.body?document.body.querySelectorAll('*'):[];
-        for(var i=0;i<all.length;i++){
-          var el=all[i], s=getComputedStyle(el);
-          if(parseFloat(s.opacity)<0.05 && (s.transitionDuration!=='0s'||s.animationName!=='none')){
-            var p=s.position;
-            if(p==='static'||p==='relative'){
-              if(state) state.inline.push({
-                el:el,
-                opacity:el.style.getPropertyValue('opacity'),
-                opacityPriority:el.style.getPropertyPriority('opacity'),
-                transform:el.style.getPropertyValue('transform'),
-                transformPriority:el.style.getPropertyPriority('transform')
-              });
-              el.style.setProperty('opacity','1','important');
-              el.style.setProperty('transform','none','important');
-            }
-          }
-        }
-        if(state) window.__zuckerExtRevealState=state;
-      }catch(e){}
-    })()`
-    }).catch(() => void 0);
+  async function autoScroll(target, signal) {
+    let maxSeenY = 0;
+    for (let step = 0; step < 60; step++) {
+      const position = await evaluatePage(
+        target,
+        () => {
+          window.scrollBy({ top: 600, behavior: "instant" });
+          return {
+            y: scrollY,
+            bottom: scrollY + innerHeight >= Math.max(
+              document.documentElement.scrollHeight,
+              document.body?.scrollHeight || 0
+            ) - 1
+          };
+        },
+        null,
+        signal
+      );
+      maxSeenY = Math.max(maxSeenY, position.y);
+      await delay(120, signal);
+      if (position.bottom) break;
+    }
+    await evaluatePage(
+      target,
+      () => window.scrollTo({ left: 0, top: 0, behavior: "instant" }),
+      null,
+      signal
+    );
+    return maxSeenY;
   }
   async function getScrollPosition(target) {
     const result = await sendCommand(target, "Runtime.evaluate", {
@@ -466,71 +1028,91 @@
     const value = result.result?.value;
     return value || { x: 0, y: 0 };
   }
+  function hidePageCaptureDecorations() {
+    const hosts = [...document.querySelectorAll("browser-mcp-container")];
+    window.__zuckerExtCaptureDecorations = hosts.map((el) => ({
+      el,
+      display: el.style.getPropertyValue("display"),
+      priority: el.style.getPropertyPriority("display")
+    }));
+    hosts.forEach((el) => el.style.setProperty("display", "none", "important"));
+    return {
+      width: innerWidth,
+      height: innerHeight,
+      dpr: devicePixelRatio || 1
+    };
+  }
+  function showPageCaptureDecorations() {
+    for (const saved of window.__zuckerExtCaptureDecorations || []) {
+      if (saved.display)
+        saved.el.style.setProperty("display", saved.display, saved.priority);
+      else saved.el.style.removeProperty("display");
+    }
+    delete window.__zuckerExtCaptureDecorations;
+  }
+  function suppressCaptureDecorations(target, signal) {
+    return sendCommand(
+      target,
+      "Runtime.evaluate",
+      { expression: `(${hidePageCaptureDecorations.toString()})()` },
+      signal
+    );
+  }
+  function restoreCaptureDecorations(target) {
+    return sendCommand(target, "Runtime.evaluate", {
+      expression: `(${showPageCaptureDecorations.toString()})()`
+    });
+  }
   function restorePageAfterQuick(target, position) {
     const x = Number(position?.x) || 0;
     const y = Number(position?.y) || 0;
     return sendCommand(target, "Runtime.evaluate", {
-      expression: `(function(){
-      try{
-        var state=window.__zuckerExtRevealState;
-        if(state){
-          if(state.style&&state.style.remove) state.style.remove();
-          (state.aos||[]).forEach(function(el){ el.classList.remove('aos-animate'); });
-          (state.inline||[]).forEach(function(saved){
-            if(saved.opacity) saved.el.style.setProperty('opacity',saved.opacity,saved.opacityPriority||'');
-            else saved.el.style.removeProperty('opacity');
-            if(saved.transform) saved.el.style.setProperty('transform',saved.transform,saved.transformPriority||'');
-            else saved.el.style.removeProperty('transform');
-          });
-          delete window.__zuckerExtRevealState;
-        }
-      }catch(e){}
-      window.scrollTo(${x}, ${y});
-    })()`
+      expression: `window.scrollTo({ left: ${x}, top: ${y}, behavior: "instant" })`
     });
   }
 
-  // src/engine.ts
-  var LOAD_TIMEOUT_MS = 3e4;
-  var SAME_HOST_MIN_GAP_MS = 1800;
-  var DEFAULT_TEXTS = {
-    alreadyRunning: "Another capture is already running",
-    cannotQuick: "This page cannot be captured. Open an http(s) website first.",
-    challengeBeforeQuick: (challenge) => `Complete the ${challenge} verification before capturing this page.`,
-    quickFolder: "Quick Captures"
-  };
+  // src/engine.js
   function initExtension(config) {
-    const texts = { ...DEFAULT_TEXTS, ...config.texts || {} };
-    const freeDailyLimit = config.freeDailyLimit ?? 30;
-    const USAGE_KEY = `${config.product}_free_usage`;
-    const BATCH_KEY = `${config.product}_batch_state`;
+    if (!Number.isSafeInteger(config.freeDailyLimit) || config.freeDailyLimit < 0)
+      throw new RangeError("freeDailyLimit must be an explicit non-negative integer");
+    const normalizeSettings = (defaults, input) => {
+      const settings = config.normalizeSettings ? config.normalizeSettings(defaults, input) : { ...defaults, ...input && typeof input === "object" && !Array.isArray(input) ? input : {} };
+      return {
+        ...settings,
+        delayMs: Math.min(1e4, Math.max(0, Number(settings.delayMs) || 0)),
+        readyTimeoutMs: Math.min(6e4, Math.max(5e3, Number(settings.readyTimeoutMs) || 25e3)),
+        allowUnstable: settings.allowUnstable === true,
+        ignoreChallenge: settings.ignoreChallenge === true,
+        expandScrollAreas: settings.expandScrollAreas !== false
+      };
+    };
+    const scrollCapture = config.scrollCapture || scroll_capture_exports;
+    const texts = {
+      alreadyRunning: "Another capture is already running",
+      cannotQuick: "Open an http(s) website first.",
+      challengeBeforeQuick: (name) => `Complete the ${name} verification, or enable Capture verification page in Settings if this is a normal page.`,
+      quickFolder: "Quick Captures",
+      ...config.texts
+    };
     const prefix = config.messagePrefix;
-    const licensing = createLicensing(config.product, config.brand, config.licensing);
+    const BATCH_KEY = `${config.product}_batch_state`, QUICK_KEY = `${config.product}_quick_state`;
+    const USAGE_KEY = `${config.product}_free_usage`, TAB_KEY = `${config.product}_owned_tab`;
+    const licensing = createLicensing(
+      config.product,
+      config.brand,
+      config.licensing
+    );
     const downloader = createDownloader(
-      `Convert large ${config.brand} output into a downloadable blob URL.`
+      `Prepare local ${config.brand} downloads.`,
+      config.downloads
     );
+    let activeRun = null;
     let batch = idleBatch();
-    let restorePromise = restoreBatch();
-    let quickRunning = false;
-    chrome.runtime.onInstalled.addListener(() => {
-      const previousRestore = restorePromise;
-      restorePromise = (async () => {
-        await previousRestore.catch(() => {
-        });
-        batch = idleBatch();
-        await storageRemove(BATCH_KEY);
-        setBadge("");
-      })();
-    });
-    chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
-      if (message?.target === "offscreen") {
-        return false;
-      }
-      handleMessage(message).then(sendResponse).catch((error) => sendResponse({ ok: false, error: normalizeError(error) }));
-      return true;
-    });
+    let restorePromise;
     function idleBatch() {
       return {
+        version: 2,
+        id: crypto.randomUUID(),
         running: false,
         cancelRequested: false,
         startedAt: null,
@@ -539,417 +1121,777 @@
         done: 0,
         success: 0,
         failed: 0,
+        cancelled: 0,
         current: "",
         freeLimited: false,
         needVerify: null,
-        skipVerify: false,
-        settings: { ...config.defaultSettings },
+        settings: normalizeSettings(config.defaultSettings),
         pro: false,
         items: []
       };
     }
-    async function handleMessage(message) {
-      await restorePromise;
-      switch (message.type) {
-        case `${prefix}_START`:
-          return startBatch(message.urls, message.settings);
-        // 两个后缀都接受：CAPTURE_CURRENT（截图类）/ CONVERT_CURRENT（转换类），兼容既有 popup
-        case `${prefix}_CAPTURE_CURRENT`:
-        case `${prefix}_CONVERT_CURRENT`:
-          return quickCapture(message.tabId, message.settings);
-        case `${prefix}_CANCEL`:
-          return cancelBatch();
-        case `${prefix}_CLEAR_BATCH`:
-          return clearBatch();
-        case `${prefix}_SKIP_VERIFY`:
-          batch.skipVerify = true;
-          await persistBatch();
-          return { ok: true };
-        case `${prefix}_STATE`:
-          return { ok: true, batch: publicBatch(), quota: await getQuota() };
-        case `${prefix}_ACTIVATE`:
-          await licensing.activate(message.code);
-          return { ok: true, quota: await getQuota() };
-        case `${prefix}_CLEAR_LICENSE`:
-          await licensing.clear();
-          return { ok: true, quota: await getQuota() };
-        default:
-          return { ok: false, error: "Unknown message" };
-      }
+    function reserveRun(restoring = false) {
+      if (activeRun || !restoring && batch.running) return null;
+      activeRun = {
+        controller: new AbortController(),
+        job: null,
+        skipVerify: false,
+        windowId: null,
+        idleTabId: null
+      };
+      return activeRun;
     }
-    async function getQuota() {
-      const entitlement = await licensing.getEntitlement().catch(() => null);
-      if (entitlement) {
-        return { pro: true, expiresAt: entitlement.expiresAt, limit: null, used: 0, remaining: 999999 };
+    function releaseRun(run) {
+      if (activeRun === run) {
+        activeRun = null;
+        setBadge("");
       }
-      const data = await storageGet(USAGE_KEY);
-      const usage = data[USAGE_KEY];
-      const today = todayString();
-      const used = usage && usage.date === today ? usage.used || 0 : 0;
-      return { pro: false, limit: freeDailyLimit, used, remaining: Math.max(0, freeDailyLimit - used) };
     }
-    async function recordUsage(count) {
-      const data = await storageGet(USAGE_KEY);
-      const today = todayString();
+    function recount(job) {
+      job.success = job.items.filter((i) => i.status === "success").length;
+      job.failed = job.items.filter((i) => i.status === "failed").length;
+      job.cancelled = job.items.filter((i) => i.status === "cancelled").length;
+      job.done = job.success + job.failed + job.cancelled;
+    }
+    function publicBatch() {
+      return {
+        ...batch,
+        busy: Boolean(activeRun),
+        // Marked running with no live controller: a final write failed and left
+        // downloads unconfirmed. The popup must stay usable in this state.
+        stalled: Boolean(batch.running && !activeRun),
+        items: batch.items.map(
+          ({ url, index, status, fileName, error, warning }) => ({
+            url,
+            index,
+            status,
+            fileName,
+            error,
+            warning
+          })
+        )
+      };
+    }
+    const persist = (job) => storageSet({ [BATCH_KEY]: job });
+    function usageFrom(data) {
       const usage = data[USAGE_KEY];
-      const used = usage && usage.date === today ? usage.used || 0 : 0;
-      await storageSet({ [USAGE_KEY]: { date: today, used: used + count } });
+      return usage?.date === todayString() && Number.isSafeInteger(usage.used) && usage.used >= 0 ? usage.used : 0;
     }
-    async function startBatch(urls, settings) {
-      if (batch.running || quickRunning) {
-        return { ok: false, error: texts.alreadyRunning };
-      }
-      const normalized = normalizeUrls(urls);
-      if (!normalized.length) {
-        return { ok: false, error: "No valid http(s) URLs" };
-      }
-      const quota = await getQuota();
-      if (!quota.pro && quota.remaining <= 0) {
+    async function getQuota(cachedOnly = false, force = false) {
+      const status = await licensing.getStatus({ cachedOnly, force });
+      const license = {
+        licenseStatus: status.state,
+        licenseMessage: status.message || "",
+        licenseRefreshing: Boolean(status.refreshing),
+        hasLicense: status.state !== "free"
+      };
+      if (status.entitlement)
         return {
-          ok: false,
-          error: `Daily free limit reached (${quota.limit} pages/day). Go Pro for unlimited pages.`
+          ...license,
+          pro: true,
+          expiresAt: status.entitlement.expiresAt,
+          limit: null,
+          used: 0,
+          remaining: null
         };
-      }
-      const freeLimited = !quota.pro && normalized.length > quota.remaining;
-      const accepted = quota.pro ? normalized : normalized.slice(0, quota.remaining);
-      const options = { ...config.defaultSettings, ...settings || {} };
-      batch = {
-        ...idleBatch(),
-        running: true,
-        startedAt: Date.now(),
-        folder: `${config.brand}/${folderNameFor(accepted)}`,
-        total: accepted.length,
-        freeLimited,
-        settings: options,
-        pro: quota.pro,
-        items: accepted.map((url, index) => ({
-          url,
-          index: index + 1,
-          status: "pending",
-          fileName: "",
-          error: "",
-          warning: "",
-          usageRecorded: false
-        }))
+      if (status.state !== "free")
+        return {
+          ...license,
+          pro: false,
+          limit: null,
+          used: 0,
+          remaining: null
+        };
+      const used = usageFrom(await storageGet(USAGE_KEY));
+      const limit = config.freeDailyLimit;
+      return {
+        ...license,
+        pro: false,
+        limit,
+        used,
+        remaining: Math.max(0, limit - used)
       };
-      await persistBatch();
-      runBatch(options).catch((error) => {
-        batch.running = false;
-        batch.current = normalizeError(error);
-        persistBatch();
-      });
-      return { ok: true, batch: publicBatch(), quota: await getQuota() };
     }
-    async function quickCapture(tabId, settings) {
-      if (batch.running || quickRunning) {
-        return { ok: false, error: texts.alreadyRunning };
+    function assertQuota(quota) {
+      if (quota.pro) return;
+      if (quota.hasLicense)
+        throw new Error(
+          quota.licenseMessage || "Checking your Pro license. Use Recheck Pro in License and retry."
+        );
+      if (!quota.remaining)
+        throw new Error(
+          `Daily free limit reached (${quota.limit} pages/day). Already purchased Pro? Enter your original activation code in License to restore unlimited exports.`
+        );
+    }
+    async function commitResult(job, item, status, error = "", quick = false) {
+      const previous = {
+        status: item.status,
+        error: item.error,
+        usageRecorded: item.usageRecorded
+      };
+      let used;
+      if (status === "success" && item.chargeFree && !item.usageRecorded) {
+        used = usageFrom(await storageGet(USAGE_KEY)) + 1;
       }
-      if (!Number.isInteger(tabId)) {
-        return { ok: false, error: "No active web page" };
+      item.status = status;
+      item.error = error;
+      if (used !== void 0) item.usageRecorded = true;
+      if (!quick) recount(job);
+      try {
+        await storageSet({
+          [quick ? QUICK_KEY : BATCH_KEY]: quick ? null : job,
+          ...used !== void 0 ? { [USAGE_KEY]: { date: todayString(), used } } : {}
+        });
+      } catch (error2) {
+        Object.assign(item, previous);
+        if (!quick) recount(job);
+        throw error2;
       }
-      const tab = await chrome.tabs.get(tabId).catch(() => null);
-      if (!tab?.url || !/^https?:\/\//i.test(tab.url)) {
-        return { ok: false, error: texts.cannotQuick };
+    }
+    function makeItem(url, index) {
+      return {
+        url,
+        index,
+        status: "pending",
+        fileName: "",
+        error: "",
+        warning: "",
+        usageRecorded: false
+      };
+    }
+    async function recoverQuick(signal) {
+      const quick = (await storageGet(QUICK_KEY))[QUICK_KEY];
+      if (!quick) return;
+      if (quick.downloadId == null && !quick.downloadUrl) {
+        await storageRemove(QUICK_KEY);
+        return;
       }
-      const quota = await getQuota();
-      if (!quota.pro && quota.remaining <= 0) {
-        return {
-          ok: false,
-          error: `Daily free limit reached (${quota.limit} pages/day). Go Pro for unlimited pages.`
+      let recovered = false;
+      try {
+        await downloader.recover(quick, signal);
+        recovered = true;
+      } catch {
+        await storageRemove(QUICK_KEY);
+      }
+      if (recovered) await commitResult(null, quick, "success", "", true);
+    }
+    async function startBatch(urls, settings) {
+      const run = reserveRun();
+      if (!run) return { ok: false, error: texts.alreadyRunning };
+      try {
+        await recoverQuick(run.controller.signal);
+        const normalized = normalizeUrls(urls);
+        if (!normalized.length) throw new Error("No valid http(s) URLs");
+        const quota = await withAbort(getQuota(), run.controller.signal);
+        throwIfAborted(run.controller.signal);
+        assertQuota(quota);
+        const accepted = quota.pro ? normalized : normalized.slice(0, quota.remaining);
+        batch = {
+          ...idleBatch(),
+          running: true,
+          startedAt: Date.now(),
+          folder: `${config.brand}/${folderNameFor(accepted)}-${crypto.randomUUID().slice(0, 6)}`,
+          total: accepted.length,
+          freeLimited: accepted.length < normalized.length,
+          settings: normalizeSettings(config.defaultSettings, settings),
+          pro: quota.pro,
+          items: accepted.map((url, index) => makeItem(url, index + 1))
         };
+        run.job = batch;
+        await persist(batch);
+        void runBatch(batch, run);
+        return { ok: true, batch: publicBatch(), quota };
+      } catch (error) {
+        releaseRun(run);
+        throw error;
       }
-      quickRunning = true;
-      setBadge("1");
+    }
+    async function runBatch(job, run, { keepLock = false } = {}) {
+      const signal = run.controller.signal;
+      const lastHostAt = /* @__PURE__ */ new Map();
       try {
-        const options = { ...config.defaultSettings, ...settings || {} };
-        const result = await captureExistingTab(tabId, tab.url, options);
-        if (!quota.pro) {
-          await recordUsage(1);
+        for (const item of job.items) {
+          if (["success", "failed", "cancelled"].includes(item.status))
+            continue;
+          if (item.downloadId != null || item.downloadUrl) {
+            let error2;
+            try {
+              await downloader.recover(item, signal);
+            } catch (failure) {
+              error2 = failure;
+            }
+            await commitResult(
+              job,
+              item,
+              error2 ? signal.aborted || error2.message === "Cancelled" ? "cancelled" : "failed" : "success",
+              error2 ? normalizeError(error2) : ""
+            );
+            continue;
+          }
+          throwIfAborted(signal);
+          const quota = await withAbort(getQuota(), signal);
+          assertQuota(quota);
+          const host = hostOf(item.url), previous = lastHostAt.get(host) || 0;
+          await delay(Math.max(0, (config.sameHostGapMs ?? 1800) - (Date.now() - previous)), signal);
+          lastHostAt.set(host, Date.now());
+          item.chargeFree = !quota.pro;
+          item.status = "running";
+          job.current = item.url;
+          setBadge(`${job.done + 1}/${job.total}`);
+          await persist(job);
+          let error;
+          try {
+            await captureUrl(item, job, run);
+          } catch (failure) {
+            error = failure;
+          }
+          await commitResult(
+            job,
+            item,
+            error ? signal.aborted || error.message === "Cancelled" ? "cancelled" : "failed" : "success",
+            error ? normalizeError(error) : ""
+          );
         }
-        setBadge("OK");
-        setTimeout(() => setBadge(""), 4e3);
-        return { ok: true, result, quota: await getQuota() };
       } catch (error) {
-        setBadge("ERR");
-        setTimeout(() => setBadge(""), 4e3);
-        return { ok: false, error: normalizeError(error), quota: await getQuota() };
+        const message = normalizeError(error);
+        job.current = message;
+        if (!signal.aborted && !job.cancelRequested) {
+          for (const item of job.items)
+            if (item.status === "pending") {
+              item.status = "failed";
+              item.error = message;
+            }
+        }
       } finally {
-        quickRunning = false;
+        if (signal.aborted || job.cancelRequested) {
+          job.cancelRequested = true;
+          for (const item of job.items)
+            if (["pending", "running"].includes(item.status))
+              item.status = "cancelled";
+          job.current = "Stopped";
+        } else if (job.items.every(
+          (i) => ["success", "failed", "cancelled"].includes(i.status)
+        ))
+          job.current = "Done";
+        job.running = job.items.some((item) => item.status === "downloading");
+        if (job.running)
+          job.current = "Some downloads could not be confirmed. Press Stop to reconcile them.";
+        job.needVerify = null;
+        recount(job);
+        try {
+          await persist(job);
+        } catch {
+          console.warn(`${config.brand}: could not save final task state`);
+        }
+        try {
+          await closeBatchWindow(run);
+        } finally {
+          if (!keepLock) releaseRun(run);
+        }
       }
     }
-    async function captureExistingTab(tabId, pageUrl, options) {
-      const target = { tabId };
-      let attached = false;
-      let scrollPosition = { x: 0, y: 0 };
+    async function quickCapture(tabId, settings) {
+      const run = reserveRun();
+      if (!run) return { ok: false, error: texts.alreadyRunning };
+      const signal = run.controller.signal;
       try {
-        await debuggerAttach(target, "1.3");
-        attached = true;
-        await sendCommand(target, "Page.enable");
-        await sendCommand(target, "Runtime.enable");
-        const probe = await probePage(target);
-        if (probe.error) {
-          throw new Error(probe.error);
-        }
-        if (probe.challenge) {
-          throw new Error(texts.challengeBeforeQuick(probe.challenge));
+        await recoverQuick(signal);
+        if (!Number.isInteger(tabId)) throw new Error("No active web page");
+        const tab = await chrome.tabs.get(tabId);
+        if (!/^https?:\/\//i.test(tab?.url || ""))
+          throw new Error(texts.cannotQuick);
+        const quota = await withAbort(getQuota(), signal);
+        assertQuota(quota);
+        const item = { ...makeItem(tab.url, 1), chargeFree: !quota.pro };
+        const options = normalizeSettings(config.defaultSettings, settings);
+        await storageSet({ [QUICK_KEY]: item });
+        const visibleOutput = await config.captureQuick?.({
+          tab,
+          options,
+          signal
+        });
+        if (visibleOutput)
+          return await deliverQuick(item, visibleOutput, signal);
+        const target = { tabId };
+        let attached = false, position = null;
+        const network = watchNetwork(target);
+        const ctx = makeContext(
+          "quick",
+          tabId,
+          item.url,
+          options,
+          target,
+          signal
+        );
+        try {
+          await debuggerAttach(target, "1.3");
+          attached = true;
+          if ((config.captureScope?.(options) || "full") === "full")
+            position = await getScrollPosition(target);
+          await config.beforeQuick?.(ctx, tab);
+          await sendCommand(target, "Network.enable", {}, signal);
+          if ((config.captureScope?.(options) || "full") === "full") {
+            await preparePageForCapture(target, signal);
+          }
+          await suppressCaptureDecorations(target, signal);
+          await prepareCapture(target, item, options, run, network, "quick");
+          const output = await capturePrepared(ctx, options, run, network);
+          throwIfAborted(signal);
+          return await deliverQuick(item, output, signal);
+        } finally {
+          network.dispose();
+          if (attached) {
+            await config.afterQuick?.(ctx).catch(() => {
+            });
+            await restoreCaptureDecorations(target).catch(() => {
+            });
+            if (position && await isCurrentQuickPage(ctx))
+              await restorePageAfterQuick(target, position).catch(() => {
+              });
+            await debuggerDetach(target).catch(() => {
+            });
+          }
         }
-        scrollPosition = await getScrollPosition(target);
-        await delay(clamp(Number(options.delayMs) || Number(config.defaultSettings.delayMs) || 1500, 0, 1e4));
-        await autoScroll(target);
-        await revealAnimations(target, true);
-        await delay(400);
-        const output = await config.capture(makeContext("quick", tabId, pageUrl, options, target));
-        const fileName = buildQuickFileName(config.brand, texts.quickFolder, pageUrl, output.extension);
-        await downloader.downloadViaBlob(output.base64, output.mime, fileName);
-        return { fileName, warning: output.warning || "" };
+      } catch (error) {
+        const saved = (await storageGet(QUICK_KEY))[QUICK_KEY];
+        if (!saved?.downloadId && !saved?.downloadUrl)
+          await storageRemove(QUICK_KEY);
+        return {
+          ok: false,
+          error: normalizeError(error),
+          quota: await getQuota(true)
+        };
       } finally {
-        if (attached) {
-          await restorePageAfterQuick(target, scrollPosition).catch(() => {
-          });
-          await debuggerDetach(target).catch(() => {
-          });
-        }
+        releaseRun(run);
       }
     }
-    async function cancelBatch() {
-      if (batch.running) {
-        batch.cancelRequested = true;
-        batch.current = "Stopping\u2026";
-        await persistBatch();
+    async function deliverQuick(item, output, signal) {
+      throwIfAborted(signal);
+      item.warning = [item.warning, output.warning].filter(Boolean).join(" ");
+      item.fileName = buildQuickFileName(
+        config.brand,
+        texts.quickFolder,
+        item.url,
+        output.extension
+      );
+      await saveOutput(
+        item,
+        output,
+        signal,
+        () => storageSet({ [QUICK_KEY]: item })
+      );
+      await commitResult(null, item, "success", "", true);
+      return {
+        ok: true,
+        result: { fileName: item.fileName, warning: item.warning },
+        quota: await getQuota(true)
+      };
+    }
+    async function isCurrentQuickPage(ctx) {
+      if (ctx.mode !== "quick") return true;
+      try {
+        const current = await chrome.tabs.get(ctx.tabId);
+        return current.url === ctx.url && (!current.pendingUrl || current.pendingUrl === ctx.url);
+      } catch {
+        return false;
       }
-      return { ok: true, batch: publicBatch() };
     }
-    async function clearBatch() {
-      if (batch.running) {
-        return { ok: false, error: "Stop the running batch before clearing it" };
+    async function assertCurrentQuickPage(ctx) {
+      if (!await isCurrentQuickPage(ctx))
+        throw new Error(
+          "The page changed during capture. Return to the requested page and try again."
+        );
+    }
+    async function capturePrepared(ctx, options, run, network) {
+      const expand = (config.captureScope?.(options) || "full") === "full" && options.expandScrollAreas;
+      try {
+        await assertCurrentQuickPage(ctx);
+        const warnings = /* @__PURE__ */ new Set();
+        if (expand)
+          await scrollCapture?.prepare(ctx, async () => {
+            await assertCurrentQuickPage(ctx);
+            const warning = await waitForPageStable(
+              { tabId: ctx.tabId },
+              options,
+              run.controller.signal,
+              network
+            );
+            if (warning) warnings.add(warning);
+          });
+        await assertCurrentQuickPage(ctx);
+        const output = await config.capture(ctx);
+        await assertCurrentQuickPage(ctx);
+        if (output.warning) warnings.add(output.warning);
+        return { ...output, warning: [...warnings].join(" ") };
+      } finally {
+        if (expand) await scrollCapture?.restore(ctx);
       }
-      batch = idleBatch();
-      await storageRemove(BATCH_KEY);
-      setBadge("");
-      return { ok: true, batch: publicBatch() };
     }
-    async function runBatch(options) {
-      const lastHostAt = {};
-      for (const item of batch.items) {
-        if (item.status !== "pending") {
-          continue;
-        }
-        if (batch.cancelRequested) {
-          break;
-        }
-        const host = hostOf(item.url);
-        const since = Date.now() - (lastHostAt[host] || 0);
-        if (lastHostAt[host] && since < SAME_HOST_MIN_GAP_MS) {
-          batch.current = "Pacing to avoid rate-limits\u2026";
-          await delay(SAME_HOST_MIN_GAP_MS - since);
-          if (batch.cancelRequested) {
-            break;
-          }
-        }
-        lastHostAt[host] = Date.now();
-        item.status = "running";
-        batch.current = item.url;
-        setBadge(`${batch.done + 1}/${batch.total}`);
-        await persistBatch();
-        let shouldCharge = false;
-        try {
-          const result = await captureUrl(item, options);
-          item.fileName = result.fileName;
-          item.warning = result.warning;
-          item.status = "success";
-          batch.success += 1;
-          if (!batch.pro && !item.usageRecorded) {
-            item.usageRecorded = true;
-            shouldCharge = true;
+    async function prepareCapture(target, item, options, run, network, mode = "batch") {
+      const signal = run.controller.signal;
+      const probe = await probePage(target, signal);
+      if (probe.error) throw new Error(probe.error);
+      if (probe.challenge && !options.ignoreChallenge)
+        throw challengeError(probe.challenge);
+      if (probe.challenge)
+        item.warning = `Captured a ${probe.challenge} verification page at your request.`;
+      const scope = config.captureScope?.(options) || "full";
+      if (scope === "viewport" && mode === "quick") return;
+      await delay(options.delayMs, signal);
+      const before = await waitForPageStable(target, options, signal, network);
+      const maxSeenY = scope === "full" ? await autoScroll(target, signal) : 0;
+      const after = await waitForPageStable(
+        target,
+        options,
+        signal,
+        network,
+        maxSeenY
+      );
+      item.warning = [
+        ...new Set([item.warning, before, after].filter(Boolean))
+      ].join(" ");
+    }
+    async function saveOutput(item, output, signal, save) {
+      throwIfAborted(signal);
+      await downloader.downloadViaBlob(
+        output.base64,
+        output.mime,
+        item.fileName,
+        {
+          signal,
+          onPrepared: async (url) => {
+            item.downloadUrl = url;
+            item.status = "downloading";
+            await save();
+          },
+          onCreated: async (id) => {
+            item.downloadId = id;
+            await save();
           }
-        } catch (error) {
-          item.status = "failed";
-          item.error = normalizeError(error);
-          batch.failed += 1;
-        }
-        batch.done = batch.success + batch.failed;
-        await persistBatch();
-        if (shouldCharge) {
-          await recordUsage(1);
-        }
-      }
-      batch.running = false;
-      batch.current = batch.cancelRequested ? "Stopped" : "Done";
-      batch.needVerify = null;
-      await persistBatch();
-      setBadge(batch.failed ? "ERR" : "OK");
-      setTimeout(() => setBadge(""), 4e3);
-    }
-    async function captureUrl(item, options) {
-      const maxChallengeRetry = 2;
-      let lastError;
-      for (let attempt = 0; attempt <= maxChallengeRetry; attempt += 1) {
-        if (batch.cancelRequested) {
-          throw new Error("Cancelled");
         }
+      );
+    }
+    async function captureUrl(item, job, run) {
+      const signal = run.controller.signal;
+      for (let attempt = 0; attempt <= 3; attempt++) {
+        throwIfAborted(signal);
         try {
-          return await captureOnce(item, options, false);
+          return await captureOnce(item, job, run, attempt === 3);
         } catch (error) {
-          lastError = error;
-          if (!isChallengeError(error)) {
-            throw error;
-          }
-          if (attempt < maxChallengeRetry) {
-            const backoff = 8e3 * (attempt + 1);
-            batch.current = `Rate-limited \u2014 cooling down ${backoff / 1e3}s (retry ${attempt + 1}/${maxChallengeRetry})`;
-            await delay(backoff);
-          }
+          if (!isChallengeError(error) || attempt === 3) throw error;
+          job.current = "Waiting before retrying verification\u2026";
+          await persist(job);
+          await delay(8e3 * (attempt + 1), signal);
         }
       }
-      if (isChallengeError(lastError) && !batch.cancelRequested) {
-        return await captureOnce(item, options, true);
-      }
-      throw lastError;
     }
-    async function captureOnce(item, options, interactive) {
-      const tab = await chrome.tabs.create({ url: item.url, active: Boolean(interactive) });
-      const tabId = tab.id;
-      if (!tabId) {
-        throw new Error("Could not open tab");
+    async function ensureBatchWindow(run) {
+      if (Number.isInteger(run.windowId)) {
+        const live = await chrome.windows.get(run.windowId).catch(() => null);
+        if (live) return run.windowId;
+        run.windowId = null;
+        run.idleTabId = null;
       }
-      const target = { tabId };
+      const created = await chrome.windows.create({ url: "about:blank", focused: false }).catch(() => null);
+      run.windowId = Number.isInteger(created?.id) ? created.id : null;
+      run.idleTabId = created?.tabs?.[0]?.id ?? null;
+      await saveTabLease(run);
+      return run.windowId;
+    }
+    function saveTabLease(run, tabId = null) {
+      return storageCall("session", "set", {
+        [TAB_KEY]: {
+          tabId,
+          jobId: run.job?.id,
+          windowId: run.windowId,
+          idleTabId: run.idleTabId
+        }
+      });
+    }
+    async function closeIdleTab(lease) {
+      if (!Number.isInteger(lease?.idleTabId)) return;
+      const tab = await chrome.tabs.get(lease.idleTabId).catch(() => null);
+      if (tab?.windowId === lease.windowId && tab.url === "about:blank" && (!tab.pendingUrl || tab.pendingUrl === "about:blank"))
+        await chrome.tabs.remove(tab.id).catch(() => {
+        });
+    }
+    async function closeBatchWindow(run) {
+      await closeIdleTab(run);
+      run.windowId = null;
+      run.idleTabId = null;
+      await storageCall("session", "remove", TAB_KEY).catch(() => {
+      });
+    }
+    async function captureOnce(item, job, run, interactive) {
+      const signal = run.controller.signal, options = job.settings;
+      const windowId = await ensureBatchWindow(run);
+      const tab = await chrome.tabs.create({
+        url: "about:blank",
+        active: interactive,
+        ...Number.isInteger(windowId) ? { windowId } : {}
+      });
+      const tabId = tab.id, target = { tabId };
       let attached = false;
+      const network = watchNetwork(target);
       try {
-        await waitForLoad(tabId, LOAD_TIMEOUT_MS);
-        await delay(Number(options.delayMs) || 0);
-        if (batch.cancelRequested) {
-          throw new Error("Cancelled");
-        }
+        await saveTabLease(run, tabId);
+        throwIfAborted(signal);
         await debuggerAttach(target, "1.3");
         attached = true;
-        await sendCommand(target, "Page.enable");
-        await sendCommand(target, "Runtime.enable");
-        const probe = await probePage(target);
-        if (probe.error) {
-          throw new Error(probe.error);
-        }
-        if (probe.challenge) {
-          if (!interactive) {
-            throw challengeError(probe.challenge);
-          }
-          await debuggerDetach(target).catch(() => {
-          });
+        await sendCommand(target, "Page.enable", {}, signal);
+        await sendCommand(target, "Network.enable", {}, signal);
+        const ctx = makeContext(
+          "batch",
+          tabId,
+          item.url,
+          options,
+          target,
+          signal
+        );
+        if (config.beforeScroll) await config.beforeScroll(ctx);
+        await preparePageForCapture(target, signal);
+        await chrome.tabs.update(tabId, { url: item.url });
+        await waitForLoad(tabId, 3e4, signal);
+        await suppressCaptureDecorations(target, signal);
+        const probe = await probePage(target, signal);
+        if (probe.challenge && !options.ignoreChallenge && interactive) {
+          await debuggerDetach(target);
           attached = false;
           await focusTab(tabId);
-          batch.needVerify = { url: item.url, challenge: probe.challenge };
-          batch.current = `Complete ${probe.challenge} verification in the opened tab\u2026`;
-          await persistBatch();
-          batch.skipVerify = false;
-          const passed = await waitForVerification(tabId, () => batch.cancelRequested || batch.skipVerify);
-          batch.needVerify = null;
-          batch.current = item.url;
-          await persistBatch();
-          if (!passed) {
-            throw challengeError(`${probe.challenge} verification not completed`);
-          }
-          await delay(800);
+          job.needVerify = { url: item.url, challenge: probe.challenge };
+          job.current = `Complete ${probe.challenge} verification in the opened tab\u2026`;
+          run.skipVerify = false;
+          await persist(job);
+          const passed = await waitForVerification(
+            tabId,
+            () => run.skipVerify,
+            signal
+          );
+          job.needVerify = null;
+          job.current = item.url;
+          await persist(job);
+          if (!passed)
+            throw challengeError(
+              `${probe.challenge} verification not completed`
+            );
           await debuggerAttach(target, "1.3");
           attached = true;
-          await sendCommand(target, "Page.enable");
-          await sendCommand(target, "Runtime.enable");
-        }
-        const ctx = makeContext("batch", tabId, item.url, options, target);
-        if (config.beforeScroll) {
-          await config.beforeScroll(ctx);
+          network.reset();
+          await sendCommand(target, "Network.enable", {}, signal);
+          await preparePageForCapture(target, signal);
         }
-        await autoScroll(target);
-        await revealAnimations(target);
-        await delay(400);
-        const output = await config.capture(ctx);
-        const fileName = buildBatchFileName(batch.folder, item, output.extension);
-        await downloader.downloadViaBlob(output.base64, output.mime, fileName);
-        return { fileName, warning: output.warning || "" };
+        await prepareCapture(target, item, options, run, network);
+        const output = await capturePrepared(ctx, options, run, network);
+        throwIfAborted(signal);
+        item.warning = [item.warning, output.warning].filter(Boolean).join(" ");
+        item.fileName = buildBatchFileName(job.folder, item, output.extension);
+        await saveOutput(item, output, signal, () => persist(job));
       } finally {
+        network.dispose();
         if (attached) {
+          await restoreCaptureDecorations(target).catch(() => {
+          });
           await debuggerDetach(target).catch(() => {
           });
         }
         await chrome.tabs.remove(tabId).catch(() => {
         });
+        await saveTabLease(run);
       }
     }
-    function makeContext(mode, tabId, url, options, target) {
+    function makeContext(mode, tabId, url, options, target, signal) {
       return {
         mode,
         tabId,
         url,
         options,
-        send: (method, params) => sendCommand(target, method, params)
+        send: (method, params) => sendCommand(target, method, params, signal),
+        cleanup: (method, params) => sendCommand(target, method, params)
       };
     }
-    function publicBatch() {
-      return {
-        running: batch.running,
-        total: batch.total,
-        done: batch.done,
-        success: batch.success,
-        failed: batch.failed,
-        current: batch.current,
-        folder: batch.folder,
-        freeLimited: batch.freeLimited,
-        needVerify: batch.needVerify,
-        items: batch.items.map((item) => ({
-          url: item.url,
-          index: item.index,
-          status: item.status,
-          fileName: item.fileName,
-          error: item.error,
-          warning: item.warning
-        }))
-      };
-    }
-    async function persistBatch() {
-      await storageSet({ [BATCH_KEY]: batch });
-    }
     async function restoreBatch() {
-      const data = await storageGet(BATCH_KEY);
+      const data = await storageGet([BATCH_KEY, QUICK_KEY]);
+      const lease = (await storageCall("session", "get", TAB_KEY))[TAB_KEY];
+      if (Number.isInteger(lease?.tabId) || Number.isInteger(lease?.windowId)) {
+        if (Number.isInteger(lease.tabId))
+          await chrome.tabs.remove(lease.tabId).catch(() => {
+          });
+        await closeIdleTab(lease);
+        await storageCall("session", "remove", TAB_KEY);
+      }
+      await recoverQuick();
       const saved = data[BATCH_KEY];
-      if (!saved?.items?.length) {
-        return;
+      if (!Array.isArray(saved?.items) || !saved.items.length) return;
+      const items = saved.items.filter(
+        (item) => typeof item?.url === "string" && normalizeUrls([item.url]).length
+      ).slice(0, 500);
+      batch = {
+        ...idleBatch(),
+        ...saved,
+        version: 2,
+        settings: normalizeSettings(
+          config.defaultSettings,
+          config.migrateSettings ? config.migrateSettings(saved.settings) : saved.settings
+        ),
+        needVerify: null,
+        items: items.map((item, i) => ({
+          ...makeItem(item.url, i + 1),
+          ...item,
+          chargeFree: item.chargeFree ?? !saved.pro,
+          status: ["success", "failed", "cancelled", "downloading"].includes(
+            item.status
+          ) ? item.status : "pending"
+        }))
+      };
+      batch.total = batch.items.length;
+      if (!batch.folder)
+        batch.folder = `${config.brand}/${folderNameFor(batch.items.map((i) => i.url))}`;
+      recount(batch);
+      if (saved.running) {
+        const run = reserveRun(true);
+        run.job = batch;
+        if (saved.cancelRequested) run.controller.abort();
+        batch.current = saved.cancelRequested ? "Stopping\u2026" : "Resuming interrupted batch\u2026";
+        await persist(batch);
+        void runBatch(batch, run);
       }
-      batch = { ...idleBatch(), ...saved };
-      batch.settings = { ...config.defaultSettings, ...saved.settings || {} };
-      batch.items = saved.items.map((item) => ({
-        url: item.url || "",
-        index: item.index || 0,
-        status: item.status === "running" ? "pending" : item.status || "pending",
-        fileName: item.fileName || "",
-        error: item.error || "",
-        warning: item.warning || "",
-        usageRecorded: item.usageRecorded || false
-      }));
-      batch.done = batch.items.filter((item) => item.status === "success" || item.status === "failed").length;
-      batch.success = batch.items.filter((item) => item.status === "success").length;
-      batch.failed = batch.items.filter((item) => item.status === "failed").length;
-      batch.needVerify = null;
-      batch.skipVerify = false;
-      if (saved.running && batch.items.some((item) => item.status === "pending")) {
-        batch.running = true;
-        batch.cancelRequested = false;
-        batch.current = "Resuming interrupted batch\u2026";
-        await persistBatch();
-        runBatch(batch.settings).catch(async (error) => {
-          batch.running = false;
-          batch.current = normalizeError(error);
-          await persistBatch();
-        });
-      } else if (saved.running) {
-        batch.running = false;
-        batch.current = "Done";
-        await persistBatch();
+    }
+    async function handleMessage(message) {
+      await restorePromise;
+      switch (message?.type) {
+        case `${prefix}_START`:
+          return startBatch(message.urls, message.settings);
+        case `${prefix}_CAPTURE_CURRENT`:
+        case `${prefix}_CONVERT_CURRENT`:
+          return quickCapture(message.tabId, message.settings);
+        case `${prefix}_CANCEL`:
+          if (activeRun) {
+            activeRun.controller.abort();
+            if (activeRun.job) {
+              activeRun.job.cancelRequested = true;
+              activeRun.job.current = "Stopping\u2026";
+              await persist(activeRun.job);
+            }
+          } else if (batch.running) {
+            const run = reserveRun(true);
+            if (run) {
+              run.job = batch;
+              batch.cancelRequested = true;
+              batch.current = "Stopping\u2026";
+              run.controller.abort();
+              await persist(batch).catch(() => {
+              });
+              void runBatch(batch, run);
+            }
+          }
+          return { ok: true, batch: publicBatch() };
+        case `${prefix}_CLEAR_BATCH`: {
+          const run = reserveRun(true);
+          if (!run)
+            return {
+              ok: false,
+              error: "Stop the running task before clearing it"
+            };
+          try {
+            run.job = batch;
+            if (batch.running || batch.items.some((item) => item.status === "downloading")) {
+              batch.cancelRequested = true;
+              run.controller.abort();
+              await runBatch(batch, run, { keepLock: true });
+              if (batch.running)
+                throw new Error(
+                  "Downloads could not be confirmed. Results were kept; retry Stop or Clear."
+                );
+            }
+            await storageRemove(BATCH_KEY);
+            batch = idleBatch();
+          } finally {
+            releaseRun(run);
+          }
+          return {
+            ok: true,
+            batch: publicBatch(),
+            quota: await getQuota(true)
+          };
+        }
+        case `${prefix}_SKIP_VERIFY`:
+          if (activeRun) activeRun.skipVerify = true;
+          return { ok: true };
+        case `${prefix}_STATE`:
+          return {
+            ok: true,
+            batch: publicBatch(),
+            quota: await getQuota(true)
+          };
+        case `${prefix}_ACTIVATE`:
+          await licensing.activate(message.code);
+          return { ok: true, quota: await getQuota(true) };
+        case `${prefix}_REFRESH_LICENSE`:
+          return { ok: true, quota: await getQuota(false, true) };
+        case `${prefix}_CLEAR_LICENSE`:
+          await licensing.deactivate();
+          return { ok: true, quota: await getQuota(true) };
+        default:
+          return { ok: false, error: "Unknown message" };
       }
     }
+    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+      if (message?.target === "offscreen" || sender.id && sender.id !== chrome.runtime.id)
+        return false;
+      handleMessage(message).then(sendResponse).catch(
+        (error) => sendResponse({ ok: false, error: normalizeError(error) })
+      );
+      return true;
+    });
+    chrome.runtime.onInstalled.addListener(() => {
+      void restorePromise.catch(() => {
+      });
+    });
     function setBadge(text) {
       chrome.action.setBadgeText({ text });
       chrome.action.setBadgeBackgroundColor({ color: config.badgeColor });
     }
+    restorePromise = restoreBatch();
+  }
+
+  // src/capture-budget.js
+  var CAPTURE_LIMITS = {
+    maxEdgeDevicePx: 16384,
+    maxDevicePixels: 64 * 1024 * 1024
+  };
+  function captureScale(dpr) {
+    return Number.isFinite(dpr) && dpr > 0 ? dpr : 1;
+  }
+  function captureFits(width, height, dpr) {
+    const scale = captureScale(dpr);
+    return [width, height].every((n) => Number.isFinite(n) && n > 0) && width * scale <= CAPTURE_LIMITS.maxEdgeDevicePx && height * scale <= CAPTURE_LIMITS.maxEdgeDevicePx && width * height * scale ** 2 <= CAPTURE_LIMITS.maxDevicePixels;
+  }
+  function assertCaptureFits(width, height, dpr, message) {
+    if (!captureFits(width, height, dpr)) throw new Error(message);
+  }
+  function captureBudget(dpr) {
+    const scale = captureScale(dpr);
+    return {
+      maxEdge: Math.floor(CAPTURE_LIMITS.maxEdgeDevicePx / scale),
+      maxArea: Math.floor(CAPTURE_LIMITS.maxDevicePixels / scale ** 2)
+    };
+  }
+  async function readDevicePixelRatio(ctx) {
+    const result = await ctx.send("Runtime.evaluate", {
+      expression: "devicePixelRatio || 1",
+      returnByValue: true
+    });
+    return captureScale(result?.result?.value);
   }
 
   // src/background.entry.ts
-  globalThis.ZuckerExt = { init: initExtension };
+  globalThis.ZuckerExt = {
+    init: initExtension,
+    limits: CAPTURE_LIMITS,
+    pageDecorations: { hide: hidePageCaptureDecorations, show: showPageCaptureDecorations },
+    captureFits,
+    assertCaptureFits,
+    captureBudget,
+    readDevicePixelRatio
+  };
 })();