@zucker-framework/ext-kit 1.0.2 → 1.0.6

package/dist/index.js

@@ -21,47 +21,89 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CAPTURE_LIMITS: () => CAPTURE_LIMITS,
+  assertCaptureFits: () => assertCaptureFits,
   buildBatchFileName: () => buildBatchFileName,
   buildQuickFileName: () => buildQuickFileName,
+  captureBudget: () => captureBudget,
+  captureFits: () => captureFits,
+  collectSameOriginLinks: () => collectSameOriginLinks,
+  createDownloader: () => createDownloader,
   createLicensing: () => createLicensing,
   fileStamp: () => fileStamp,
   folderNameFor: () => folderNameFor,
+  hidePageCaptureDecorations: () => hidePageCaptureDecorations,
   hostOf: () => hostOf,
   initExtension: () => initExtension,
   initPopup: () => initPopup,
   normalizeUrls: () => normalizeUrls,
+  readDevicePixelRatio: () => readDevicePixelRatio,
   sanitize: () => sanitize,
+  scrollCapture: () => scroll_capture_exports,
   sessionStamp: () => sessionStamp,
+  showPageCaptureDecorations: () => showPageCaptureDecorations,
   todayString: () => todayString,
   urlBaseName: () => urlBaseName
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/util.ts
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+// src/util.js
+function cancelled() {
+  return new Error("Cancelled");
 }
-__name(delay, "delay");
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
+__name(cancelled, "cancelled");
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw cancelled();
+}
+__name(throwIfAborted, "throwIfAborted");
+function withAbort(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    promise.catch(() => {
+    });
+    return Promise.reject(cancelled());
+  }
+  return new Promise((resolve, reject) => {
+    const abort = /* @__PURE__ */ __name(() => reject(cancelled()), "abort");
+    signal.addEventListener("abort", abort, {
+      once: true
+    });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+__name(withAbort, "withAbort");
+function delay(ms, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const finish = /* @__PURE__ */ __name(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, "finish");
+    const timer = setTimeout(finish, ms);
+    const abort = /* @__PURE__ */ __name(() => {
+      clearTimeout(timer);
+      reject(cancelled());
+    }, "abort");
+    signal?.addEventListener("abort", abort, {
+      once: true
+    });
+  });
 }
-__name(clamp, "clamp");
+__name(delay, "delay");
 function normalizeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 __name(normalizeError, "normalizeError");
-function storageGet(keys) {
-  return new Promise((resolve) => chrome.storage.local.get(keys, resolve));
-}
-__name(storageGet, "storageGet");
-function storageSet(value) {
-  return new Promise((resolve) => chrome.storage.local.set(value, () => 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);
+  }));
 }
-__name(storageSet, "storageSet");
-function storageRemove(keys) {
-  return new Promise((resolve) => chrome.storage.local.remove(keys, () => resolve()));
-}
-__name(storageRemove, "storageRemove");
+__name(storageCall, "storageCall");
+var storageGet = /* @__PURE__ */ __name((keys) => storageCall("local", "get", keys), "storageGet");
+var storageSet = /* @__PURE__ */ __name((value) => storageCall("local", "set", value), "storageSet");
+var storageRemove = /* @__PURE__ */ __name((keys) => storageCall("local", "remove", keys), "storageRemove");
 
 // src/naming.ts
 function sanitize(value) {
@@ -79,7 +121,7 @@ __name(hostOf, "hostOf");
 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;
@@ -87,7 +129,6 @@ function normalizeUrls(urls) {
     let key = value;
     try {
       const parsed = new URL(value);
-      parsed.hash = "";
       key = parsed.toString();
     } catch {
       continue;
@@ -167,25 +208,67 @@ function buildQuickFileName(brand, quickFolder, pageUrl, extension) {
 }
 __name(buildQuickFileName, "buildQuickFileName");
 
-// 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 || {};
-}
-__name(unwrap, "unwrap");
+// 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 = /* @__PURE__ */ __name(() => ({
+    state: "unavailable",
+    message: "Could not verify your saved Pro license. Check your connection and use Recheck Pro in License. Your activation is still saved."
+  }), "unavailable");
+  const proStatus = /* @__PURE__ */ __name((entitlement) => ({
+    state: "pro",
+    entitlement
+  }), "proStatus");
+  function fallbackStatus(cached) {
+    if (lastStatus?.state === "invalid") return lastStatus;
+    const cachedEntitlement = usableCache(cached);
+    return cachedEntitlement ? proStatus(cachedEntitlement) : unavailable();
+  }
+  __name(fallbackStatus, "fallbackStatus");
+  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;
+  }
+  __name(normalize, "normalize");
+  function usableCache(cached) {
+    const age = Date.now() - Number(cached?.checkedAt);
+    return Number.isFinite(age) && age >= 0 && age < config.offlineGraceMs ? normalize(cached) : null;
+  }
+  __name(usableCache, "usableCache");
+  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("");
+  }
+  __name(request, "request");
+  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
     });
@@ -193,256 +276,730 @@ function createLicensing(product, brand, config) {
   }
   __name(getDeviceId, "getDeviceId");
   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
       });
-    } 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.");
+      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()
+        }
+      });
+      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;
   }
   __name(activate, "activate");
-  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 || ""
-    };
   }
-  __name(normalize, "normalize");
-  async function getEntitlement() {
+  __name(refreshEntitlement, "refreshEntitlement");
+  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)
+    };
   }
-  __name(getEntitlement, "getEntitlement");
-  async function isPro() {
-    return Boolean(await getEntitlement());
+  __name(getStatus, "getStatus");
+  async function getEntitlement(options) {
+    return (await getStatus(options)).entitlement || null;
   }
-  __name(isPro, "isPro");
-  async function clear() {
-    await storageRemove([
-      TOKEN_KEY,
-      ENTITLEMENT_KEY
-    ]);
+  __name(getEntitlement, "getEntitlement");
+  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;
+    }
   }
-  __name(clear, "clear");
+  __name(deactivate, "deactivate");
   return {
     activate,
     getEntitlement,
-    isPro,
-    clear,
+    getStatus,
+    deactivate,
     purchaseUrl: config.purchaseUrl
   };
 }
 __name(createLicensing, "createLicensing");
 
-// 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,
+    const filename = names.get(item.url) || names.get(item.finalUrl);
+    if (filename) suggest({
+      filename,
       conflictAction: "uniquify"
     });
-    return true;
+  });
+  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",
+    if (!offscreenSetup) offscreenSetup = (async () => {
+      if (!await chrome.offscreen.hasDocument()) await chrome.offscreen.createDocument({
+        url: options.offscreenUrl || "offscreen.html",
         reasons: [
           chrome.offscreen.Reason.BLOBS
         ],
         justification
-      }).catch((error) => {
-        if (!String(error?.message || "").includes("Only a single")) {
-          throw error;
-        }
-      }).finally(() => {
-        offscreenSetup = null;
       });
-    }
+    })().finally(() => {
+      offscreenSetup = null;
+    });
     return offscreenSetup;
   }
   __name(ensureOffscreen, "ensureOffscreen");
-  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(() => {
+    });
+  }
+  __name(cleanup, "cleanup");
+  async function waitForDownload(id, signal) {
+    return new Promise((resolve, reject) => {
+      let finished = false;
+      let deadlineError;
+      const finish = /* @__PURE__ */ __name((error, item) => {
+        if (finished) return;
+        finished = true;
+        clearInterval(poll);
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", abort);
+        waiters.delete(id);
+        error ? reject(error) : resolve(item);
+      }, "finish");
+      const inspect = /* @__PURE__ */ __name(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);
+        }
+      }, "inspect");
+      const abort = /* @__PURE__ */ __name(async () => {
+        await chrome.downloads.cancel(id).catch(() => {
+        });
+        const [item] = await chrome.downloads.search({
+          id
+        }).catch(() => []);
+        item?.state === "complete" ? finish(null, item) : finish(cancelled());
+      }, "abort");
+      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();
+    });
+  }
+  __name(waitForDownload, "waitForDownload");
+  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);
+    }
+  }
+  __name(recover, "recover");
+  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) {
-      throw new Error(created?.error || "Failed to prepare download");
-    }
+    if (!created?.ok || !created.url) throw new Error(created?.error || "Failed to prepare download");
     const url = created.url;
-    pendingDownloadNames.set(url, filename);
-    const cleanup = /* @__PURE__ */ __name(() => {
-      pendingDownloadNames.delete(url);
-      chrome.runtime.sendMessage({
-        target: "offscreen",
-        type: "REVOKE_BLOB_URL",
-        url
-      }).catch(() => {
-      });
-    }, "cleanup");
+    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);
     }
   }
   __name(downloadViaBlob, "downloadViaBlob");
   return {
-    downloadViaBlob
+    downloadViaBlob,
+    recover
   };
 }
 __name(createDownloader, "createDownloader");
 
-// src/session.ts
-function debuggerAttach(target, version) {
-  return new Promise((resolve, reject) => {
-    chrome.debugger.attach(target, version, () => {
-      const error = chrome.runtime.lastError;
-      error ? reject(new Error(error.message)) : resolve();
+// 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 = /* @__PURE__ */ __name((el, property, old) => old.value ? el.style.setProperty(property, old.value, old.priority) : el.style.removeProperty(property), "restoreProperty");
+      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 {};
+}
+__name(pageTask, "pageTask");
+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 || {};
+}
+__name(command, "command");
+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.");
+}
+__name(prepare, "prepare");
+async function restore(ctx) {
+  const id = sessions.get(ctx);
+  if (!id) return;
+  sessions.delete(ctx);
+  await command(ctx, id, "restore");
+}
+__name(restore, "restore");
+
+// src/session.js
+function debuggerAttach(target, version) {
+  return new Promise((resolve, reject) => chrome.debugger.attach(target, version, () => {
+    const error = chrome.runtime.lastError;
+    error ? reject(new Error(error.message)) : resolve();
+  }));
 }
 __name(debuggerAttach, "debuggerAttach");
 function debuggerDetach(target) {
-  return new Promise((resolve, reject) => {
-    chrome.debugger.detach(target, () => {
-      const error = chrome.runtime.lastError;
-      error ? reject(new Error(error.message)) : resolve();
-    });
-  });
+  return new Promise((resolve, reject) => chrome.debugger.detach(target, () => {
+    const error = chrome.runtime.lastError;
+    error ? reject(new Error(error.message)) : resolve();
+  }));
 }
 __name(debuggerDetach, "debuggerDetach");
-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);
 }
 __name(sendCommand, "sendCommand");
-function waitForLoad(tabId, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = /* @__PURE__ */ __name((fn, value) => {
-      if (!settled) {
-        settled = true;
-        chrome.tabs.onUpdated.removeListener(listener);
-        clearTimeout(timer);
-        fn(value);
-      }
-    }, "finish");
-    const listener = /* @__PURE__ */ __name((updatedTabId, changeInfo) => {
-      if (updatedTabId === tabId && changeInfo.status === "complete") {
-        finish(resolve);
-      }
-    }, "listener");
-    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(() => {
-    });
-  });
+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");
 }
 __name(waitForLoad, "waitForLoad");
+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;
+}
+__name(evaluatePage, "evaluatePage");
+function watchNetwork(target) {
+  const pending = /* @__PURE__ */ new Set();
+  let changedAt = Date.now();
+  const listener = /* @__PURE__ */ __name((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();
+  }, "listener");
+  chrome.debugger.onEvent.addListener(listener);
+  return {
+    busy: /* @__PURE__ */ __name(() => pending.size > 0 || Date.now() - changedAt < 750, "busy"),
+    reset: /* @__PURE__ */ __name(() => {
+      pending.clear();
+      changedAt = Date.now();
+    }, "reset"),
+    dispose: /* @__PURE__ */ __name(() => chrome.debugger.onEvent.removeListener(listener), "dispose")
+  };
+}
+__name(watchNetwork, "watchNetwork");
+async function preparePageForCapture(target, signal) {
+  await sendCommand(target, "Emulation.setFocusEmulationEnabled", {
+    enabled: true
+  }, signal).catch((error) => {
+    throwIfAborted(signal);
+  });
+}
+__name(preparePageForCapture, "preparePageForCapture");
+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;
+  }
+  __name(visible, "visible");
+  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("|")
+  };
+}
+__name(pageMetrics, "pageMetrics");
+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.`);
+}
+__name(waitForPageStable, "waitForPageStable");
 function challengeError(name) {
   const error = new Error(`Blocked by ${name} verification`);
   error.isChallenge = true;
@@ -453,135 +1010,100 @@ function isChallengeError(error) {
   return Boolean(error?.isChallenge);
 }
 __name(isChallengeError, "isChallengeError");
-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};
-    })()`
-  });
-  const value = r.result?.value;
-  return value || {
+function pageProbe() {
+  if (document.documentURI.startsWith("chrome-error://")) return {
+    error: "Page failed to load (DNS or network error)",
+    challenge: ""
+  };
+  const shown = /* @__PURE__ */ __name((selector) => [
+    ...document.querySelectorAll(selector)
+  ].some((el) => {
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0 && el.checkVisibility({
+      checkOpacity: true,
+      checkVisibilityCSS: true
+    });
+  }), "shown");
+  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
+  };
+}
+__name(pageProbe, "pageProbe");
+async function probePage(target, signal) {
+  return await evaluatePage(target, pageProbe, null, signal) || {
     error: "",
     challenge: ""
   };
 }
 __name(probePage, "probePage");
-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;
 }
 __name(waitForVerification, "waitForVerification");
 async function focusTab(tabId) {
-  await chrome.tabs.update(tabId, {
+  const tab = 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 {
-  }
+  await chrome.windows.update(tab.windowId, {
+    focused: true
+  });
 }
 __name(focusTab, "focusTab");
-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);
+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;
 }
 __name(autoScroll, "autoScroll");
-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);
-}
-__name(revealAnimations, "revealAnimations");
 async function getScrollPosition(target) {
   const result = await sendCommand(target, "Runtime.evaluate", {
     returnByValue: true,
@@ -594,76 +1116,89 @@ async function getScrollPosition(target) {
   };
 }
 __name(getScrollPosition, "getScrollPosition");
+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
+  };
+}
+__name(hidePageCaptureDecorations, "hidePageCaptureDecorations");
+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;
+}
+__name(showPageCaptureDecorations, "showPageCaptureDecorations");
+function suppressCaptureDecorations(target, signal) {
+  return sendCommand(target, "Runtime.evaluate", {
+    expression: `(${hidePageCaptureDecorations.toString()})()`
+  }, signal);
+}
+__name(suppressCaptureDecorations, "suppressCaptureDecorations");
+function restoreCaptureDecorations(target) {
+  return sendCommand(target, "Runtime.evaluate", {
+    expression: `(${showPageCaptureDecorations.toString()})()`
+  });
+}
+__name(restoreCaptureDecorations, "restoreCaptureDecorations");
 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" })`
   });
 }
 __name(restorePageAfterQuick, "restorePageAfterQuick");
 
-// 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: /* @__PURE__ */ __name((challenge) => `Complete the ${challenge} verification before capturing this page.`, "challengeBeforeQuick"),
-  quickFolder: "Quick Captures"
-};
+// src/engine.js
 function initExtension(config) {
+  if (!Number.isSafeInteger(config.freeDailyLimit) || config.freeDailyLimit < 0) throw new RangeError("freeDailyLimit must be an explicit non-negative integer");
+  const normalizeSettings = /* @__PURE__ */ __name((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
+    };
+  }, "normalizeSettings");
+  const scrollCapture = config.scrollCapture || scroll_capture_exports;
   const texts = {
-    ...DEFAULT_TEXTS,
-    ...config.texts || {}
+    alreadyRunning: "Another capture is already running",
+    cannotQuick: "Open an http(s) website first.",
+    challengeBeforeQuick: /* @__PURE__ */ __name((name) => `Complete the ${name} verification, or enable Capture verification page in Settings if this is a normal page.`, "challengeBeforeQuick"),
+    quickFolder: "Quick Captures",
+    ...config.texts
   };
-  const freeDailyLimit = config.freeDailyLimit ?? 30;
-  const USAGE_KEY = `${config.product}_free_usage`;
-  const BATCH_KEY = `${config.product}_batch_state`;
   const prefix = config.messagePrefix;
+  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.`);
+  const downloader = createDownloader(`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,
@@ -672,529 +1207,762 @@ function initExtension(config) {
       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: []
     };
   }
   __name(idleBatch, "idleBatch");
-  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;
   }
-  __name(handleMessage, "handleMessage");
-  async function getQuota() {
-    const entitlement = await licensing.getEntitlement().catch(() => null);
-    if (entitlement) {
-      return {
-        pro: true,
-        expiresAt: entitlement.expiresAt,
-        limit: null,
-        used: 0,
-        remaining: 999999
-      };
+  __name(reserveRun, "reserveRun");
+  function releaseRun(run) {
+    if (activeRun === run) {
+      activeRun = null;
+      setBadge("");
     }
-    const data = await storageGet(USAGE_KEY);
+  }
+  __name(releaseRun, "releaseRun");
+  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;
+  }
+  __name(recount, "recount");
+  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
+      }))
+    };
+  }
+  __name(publicBatch, "publicBatch");
+  const persist = /* @__PURE__ */ __name((job) => storageSet({
+    [BATCH_KEY]: job
+  }), "persist");
+  function usageFrom(data) {
     const usage = data[USAGE_KEY];
-    const today = todayString();
-    const used = usage && usage.date === today ? usage.used || 0 : 0;
+    return usage?.date === todayString() && Number.isSafeInteger(usage.used) && usage.used >= 0 ? usage.used : 0;
+  }
+  __name(usageFrom, "usageFrom");
+  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 {
+      ...license,
+      pro: true,
+      expiresAt: status.entitlement.expiresAt,
+      limit: null,
+      used: 0,
+      remaining: null
+    };
+    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: freeDailyLimit,
+      limit,
       used,
-      remaining: Math.max(0, freeDailyLimit - used)
+      remaining: Math.max(0, limit - used)
     };
   }
   __name(getQuota, "getQuota");
-  async function recordUsage(count) {
-    const data = await storageGet(USAGE_KEY);
-    const today = todayString();
-    const usage = data[USAGE_KEY];
-    const used = usage && usage.date === today ? usage.used || 0 : 0;
-    await storageSet({
-      [USAGE_KEY]: {
-        date: today,
-        used: used + count
-      }
-    });
+  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.`);
   }
-  __name(recordUsage, "recordUsage");
-  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) {
-      return {
-        ok: false,
-        error: `Daily free limit reached (${quota.limit} pages/day). Go Pro for unlimited pages.`
-      };
-    }
-    const freeLimited = !quota.pro && normalized.length > quota.remaining;
-    const accepted = quota.pro ? normalized : normalized.slice(0, quota.remaining);
-    const options = {
-      ...config.defaultSettings,
-      ...settings || {}
+  __name(assertQuota, "assertQuota");
+  async function commitResult(job, item, status, error = "", quick = false) {
+    const previous = {
+      status: item.status,
+      error: item.error,
+      usageRecorded: item.usageRecorded
     };
-    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
-      }))
-    };
-    await persistBatch();
-    runBatch(options).catch((error) => {
-      batch.running = false;
-      batch.current = normalizeError(error);
-      persistBatch();
-    });
+    let used;
+    if (status === "success" && item.chargeFree && !item.usageRecorded) {
+      used = usageFrom(await storageGet(USAGE_KEY)) + 1;
+    }
+    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;
+    }
+  }
+  __name(commitResult, "commitResult");
+  function makeItem(url, index) {
     return {
-      ok: true,
-      batch: publicBatch(),
-      quota: await getQuota()
+      url,
+      index,
+      status: "pending",
+      fileName: "",
+      error: "",
+      warning: "",
+      usageRecorded: false
     };
   }
-  __name(startBatch, "startBatch");
-  async function quickCapture(tabId, settings) {
-    if (batch.running || quickRunning) {
-      return {
-        ok: false,
-        error: texts.alreadyRunning
-      };
+  __name(makeItem, "makeItem");
+  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;
     }
-    if (!Number.isInteger(tabId)) {
-      return {
-        ok: false,
-        error: "No active web page"
-      };
+    let recovered = false;
+    try {
+      await downloader.recover(quick, signal);
+      recovered = true;
+    } catch {
+      await storageRemove(QUICK_KEY);
     }
-    const tab = await chrome.tabs.get(tabId).catch(() => null);
-    if (!tab?.url || !/^https?:\/\//i.test(tab.url)) {
-      return {
-        ok: false,
-        error: texts.cannotQuick
+    if (recovered) await commitResult(null, quick, "success", "", true);
+  }
+  __name(recoverQuick, "recoverQuick");
+  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))
       };
-    }
-    const quota = await getQuota();
-    if (!quota.pro && quota.remaining <= 0) {
+      run.job = batch;
+      await persist(batch);
+      void runBatch(batch, run);
       return {
-        ok: false,
-        error: `Daily free limit reached (${quota.limit} pages/day). Go Pro for unlimited pages.`
+        ok: true,
+        batch: publicBatch(),
+        quota
       };
+    } catch (error) {
+      releaseRun(run);
+      throw error;
     }
-    quickRunning = true;
-    setBadge("1");
+  }
+  __name(startBatch, "startBatch");
+  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);
+      }
     }
   }
-  __name(quickCapture, "quickCapture");
-  async function captureExistingTab(tabId, pageUrl, options) {
-    const target = {
-      tabId
-    };
-    let attached = false;
-    let scrollPosition = {
-      x: 0,
-      y: 0
+  __name(runBatch, "runBatch");
+  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);
+    } catch (error) {
+      const saved = (await storageGet(QUICK_KEY))[QUICK_KEY];
+      if (!saved?.downloadId && !saved?.downloadUrl) await storageRemove(QUICK_KEY);
       return {
-        fileName,
-        warning: output.warning || ""
+        ok: false,
+        error: normalizeError(error),
+        quota: await getQuota(true)
       };
     } finally {
-      if (attached) {
-        await restorePageAfterQuick(target, scrollPosition).catch(() => {
-        });
-        await debuggerDetach(target).catch(() => {
-        });
-      }
+      releaseRun(run);
     }
   }
-  __name(captureExistingTab, "captureExistingTab");
-  async function cancelBatch() {
-    if (batch.running) {
-      batch.cancelRequested = true;
-      batch.current = "Stopping\u2026";
-      await persistBatch();
-    }
+  __name(quickCapture, "quickCapture");
+  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,
-      batch: publicBatch()
+      result: {
+        fileName: item.fileName,
+        warning: item.warning
+      },
+      quota: await getQuota(true)
     };
   }
-  __name(cancelBatch, "cancelBatch");
-  async function clearBatch() {
-    if (batch.running) {
+  __name(deliverQuick, "deliverQuick");
+  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;
+    }
+  }
+  __name(isCurrentQuickPage, "isCurrentQuickPage");
+  async function assertCurrentQuickPage(ctx) {
+    if (!await isCurrentQuickPage(ctx)) throw new Error("The page changed during capture. Return to the requested page and try again.");
+  }
+  __name(assertCurrentQuickPage, "assertCurrentQuickPage");
+  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 {
-        ok: false,
-        error: "Stop the running batch before clearing it"
+        ...output,
+        warning: [
+          ...warnings
+        ].join(" ")
       };
+    } finally {
+      if (expand) await scrollCapture?.restore(ctx);
     }
-    batch = idleBatch();
-    await storageRemove(BATCH_KEY);
-    setBadge("");
-    return {
-      ok: true,
-      batch: publicBatch()
-    };
   }
-  __name(clearBatch, "clearBatch");
-  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;
-        }
-      } 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);
+  __name(capturePrepared, "capturePrepared");
+  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(" ");
   }
-  __name(runBatch, "runBatch");
-  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");
-      }
+  __name(prepareCapture, "prepareCapture");
+  async function saveOutput(item, output, signal, save) {
+    throwIfAborted(signal);
+    await downloader.downloadViaBlob(output.base64, output.mime, item.fileName, {
+      signal,
+      onPrepared: /* @__PURE__ */ __name(async (url) => {
+        item.downloadUrl = url;
+        item.status = "downloading";
+        await save();
+      }, "onPrepared"),
+      onCreated: /* @__PURE__ */ __name(async (id) => {
+        item.downloadId = id;
+        await save();
+      }, "onCreated")
+    });
+  }
+  __name(saveOutput, "saveOutput");
+  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);
-      } 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);
-        }
+        return await captureOnce(item, job, run, attempt === 3);
+      } catch (error) {
+        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;
   }
   __name(captureUrl, "captureUrl");
-  async function captureOnce(item, options, interactive) {
+  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 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;
+  }
+  __name(ensureBatchWindow, "ensureBatchWindow");
+  function saveTabLease(run, tabId = null) {
+    return storageCall("session", "set", {
+      [TAB_KEY]: {
+        tabId,
+        jobId: run.job?.id,
+        windowId: run.windowId,
+        idleTabId: run.idleTabId
+      }
+    });
+  }
+  __name(saveTabLease, "saveTabLease");
+  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(() => {
+    });
+  }
+  __name(closeIdleTab, "closeIdleTab");
+  async function closeBatchWindow(run) {
+    await closeIdleTab(run);
+    run.windowId = null;
+    run.idleTabId = null;
+    await storageCall("session", "remove", TAB_KEY).catch(() => {
+    });
+  }
+  __name(closeBatchWindow, "closeBatchWindow");
+  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: item.url,
-      active: Boolean(interactive)
+      url: "about:blank",
+      active: interactive,
+      ...Number.isInteger(windowId) ? {
+        windowId
+      } : {}
     });
-    const tabId = tab.id;
-    if (!tabId) {
-      throw new Error("Could not open tab");
-    }
-    const target = {
+    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 = {
+        job.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.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");
+        network.reset();
+        await sendCommand(target, "Network.enable", {}, signal);
+        await preparePageForCapture(target, signal);
       }
-      const ctx = makeContext("batch", tabId, item.url, options, target);
-      if (config.beforeScroll) {
-        await config.beforeScroll(ctx);
-      }
-      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);
     }
   }
   __name(captureOnce, "captureOnce");
-  function makeContext(mode, tabId, url, options, target) {
+  function makeContext(mode, tabId, url, options, target, signal) {
     return {
       mode,
       tabId,
       url,
       options,
-      send: /* @__PURE__ */ __name((method, params) => sendCommand(target, method, params), "send")
+      send: /* @__PURE__ */ __name((method, params) => sendCommand(target, method, params, signal), "send"),
+      cleanup: /* @__PURE__ */ __name((method, params) => sendCommand(target, method, params), "cleanup")
     };
   }
   __name(makeContext, "makeContext");
-  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
-      }))
-    };
-  }
-  __name(publicBatch, "publicBatch");
-  async function persistBatch() {
-    await storageSet({
-      [BATCH_KEY]: batch
-    });
-  }
-  __name(persistBatch, "persistBatch");
   async function restoreBatch() {
-    const data = await storageGet(BATCH_KEY);
-    const saved = data[BATCH_KEY];
-    if (!saved?.items?.length) {
-      return;
+    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 (!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
-    };
-    batch.settings = {
-      ...config.defaultSettings,
-      ...saved.settings || {}
+      ...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.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();
+    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);
     }
   }
   __name(restoreBatch, "restoreBatch");
+  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"
+        };
+    }
+  }
+  __name(handleMessage, "handleMessage");
+  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
@@ -1204,10 +1972,11 @@ function initExtension(config) {
     });
   }
   __name(setBadge, "setBadge");
+  restorePromise = restoreBatch();
 }
 __name(initExtension, "initExtension");
 
-// src/popup.ts
+// src/popup.js
 function initPopup(config) {
   const byId = /* @__PURE__ */ __name((id) => document.getElementById(id), "byId");
   const el = {
@@ -1243,20 +2012,66 @@ function initPopup(config) {
     licenseCode: byId("licenseCode"),
     activateBtn: byId("activateBtn"),
     deactivateBtn: byId("deactivateBtn"),
+    recheckLicense: byId("recheckLicense"),
+    licenseHint: byId("licenseHint"),
     status: byId("status")
   };
   let pollTimer = null;
+  let disposed = false;
+  window.addEventListener("pagehide", () => {
+    disposed = true;
+    pollGeneration++;
+    clearTimeout(pollTimer);
+    if (scanJob) {
+      const job = scanJob;
+      scanJob = null;
+      void chrome.scripting.executeScript({
+        target: {
+          tabId: job.tabId
+        },
+        func: collectSameOriginLinks,
+        args: [
+          {
+            phase: "cancel",
+            id: job.id
+          }
+        ]
+      }).catch(() => {
+      });
+    }
+  }, {
+    once: true
+  });
   let queue = [];
   let queueLocked = false;
+  let operationBusy = false;
+  let editingIndex = -1;
+  let scanJob = null;
+  let pollGeneration = 0;
+  const settingsKey = config.settingsKey || config.queueKey.replace(/_url_queue$/, "_settings");
+  const settingFields = /* @__PURE__ */ __name(() => document.querySelectorAll(".settings select, .settings input[data-setting]"), "settingFields");
+  let savedSettings = {};
   const prefix = config.messagePrefix;
-  void init();
+  void init().catch((error) => setStatus(errText(error), true));
   async function init() {
     el.urls.addEventListener("input", updateUrlCount);
     el.addUrls.addEventListener("click", addInputUrls);
     el.scanSite.addEventListener("click", scanCurrentSite);
     el.selectAll.addEventListener("click", () => setAllSelected(true));
     el.selectNone.addEventListener("click", () => setAllSelected(false));
-    el.moreQueueActions.addEventListener("click", () => el.queueMenu.classList.toggle("hidden"));
+    el.moreQueueActions.addEventListener("click", (event) => {
+      event.stopPropagation();
+      setQueueMenu(el.queueMenu.classList.contains("hidden"));
+    });
+    document.addEventListener("click", (event) => {
+      if (!el.queueMenu.classList.contains("hidden") && !el.queueMenu.contains(event.target)) setQueueMenu(false);
+    });
+    document.addEventListener("keydown", (event) => {
+      if (event.key === "Escape" && !el.queueMenu.classList.contains("hidden")) {
+        setQueueMenu(false);
+        el.moreQueueActions.focus();
+      }
+    });
     el.removeUnselected.addEventListener("click", removeUnselected);
     el.clearQueue.addEventListener("click", clearQueue);
     el.captureCurrent.addEventListener("click", quickCapture);
@@ -1269,12 +2084,28 @@ function initPopup(config) {
     el.haveCode.addEventListener("click", () => el.licensePanel.classList.toggle("hidden"));
     el.activateBtn.addEventListener("click", activateLicense);
     el.deactivateBtn.addEventListener("click", deactivateLicense);
-    await loadQueue();
+    el.recheckLicense?.addEventListener("click", recheckLicense);
+    el.start.disabled = true;
+    el.captureCurrent.disabled = true;
+    await Promise.all([
+      loadQueue(),
+      loadSettings()
+    ]);
+    config.onSettingsLoaded?.();
+    settingFields().forEach((field) => {
+      field.addEventListener("change", saveSettings);
+      if (field.type === "number") field.addEventListener("input", saveSettings);
+    });
     updateUrlCount();
     renderQueue();
     await refreshState();
   }
   __name(init, "init");
+  function setQueueMenu(open) {
+    el.queueMenu.classList.toggle("hidden", !open);
+    el.moreQueueActions.setAttribute("aria-expanded", String(open));
+  }
+  __name(setQueueMenu, "setQueueMenu");
   async function activateLicense() {
     const code = el.licenseCode.value.trim();
     if (!code) {
@@ -1299,15 +2130,29 @@ function initPopup(config) {
   }
   __name(activateLicense, "activateLicense");
   async function deactivateLicense() {
+    el.deactivateBtn.disabled = true;
     const response = await send({
       type: `${prefix}_CLEAR_LICENSE`
     });
+    el.deactivateBtn.disabled = false;
     if (response.ok) {
       renderQuota(response.quota);
-      setStatus("License removed from this device");
-    }
+      setStatus("Device released. Its license slot is now available.");
+    } else setStatus(response.error || "Could not release this device", true);
   }
   __name(deactivateLicense, "deactivateLicense");
+  async function recheckLicense() {
+    el.recheckLicense.disabled = true;
+    setStatus("Checking your Pro license\u2026");
+    const response = await send({
+      type: `${prefix}_REFRESH_LICENSE`
+    });
+    el.recheckLicense.disabled = false;
+    if (!response.ok) return setStatus(response.error || "Could not check your license", true);
+    renderQuota(response.quota);
+    setStatus(response.quota.pro ? "Pro confirmed \u2014 unlimited exports." : response.quota.licenseMessage || "Enter your original activation code to restore Pro in this extension.", !response.quota.pro);
+  }
+  __name(recheckLicense, "recheckLicense");
   function parseUrls() {
     return normalizeInputUrls(el.urls.value.split(/\s+/));
   }
@@ -1325,7 +2170,6 @@ function initPopup(config) {
         if (!/^https?:$/.test(url.protocol)) {
           continue;
         }
-        url.hash = "";
         const normalized = url.toString();
         if (!seen.has(normalized)) {
           seen.add(normalized);
@@ -1370,35 +2214,80 @@ function initPopup(config) {
   }
   __name(addUrlsToQueue, "addUrlsToQueue");
   async function scanCurrentSite() {
-    setStatus("Scanning current tab\u2026");
+    if (scanJob) {
+      const stopped = scanJob;
+      scanJob = null;
+      await chrome.scripting.executeScript({
+        target: {
+          tabId: stopped.tabId
+        },
+        func: collectSameOriginLinks,
+        args: [
+          {
+            phase: "cancel",
+            id: stopped.id
+          }
+        ]
+      }).catch(() => {
+      });
+      el.scanSite.textContent = "\u2316 Scan site";
+      setStatus("Scan stopped; imported links are kept");
+      return;
+    }
+    if (queueLocked || operationBusy) return;
+    let job;
     try {
       const [tab] = await chrome.tabs.query({
         active: true,
         currentWindow: true
       });
-      if (!tab?.id) {
-        throw new Error("No active tab");
-      }
-      const [result] = await chrome.scripting.executeScript({
+      if (!tab?.id || !/^https?:\/\//i.test(tab.url || "")) throw new Error("Open an http(s) website first");
+      job = {
+        tabId: tab.id,
+        id: crypto.randomUUID()
+      };
+      scanJob = job;
+      el.scanSite.textContent = "Stop scan";
+      const [links] = await chrome.scripting.executeScript({
         target: {
           tabId: tab.id
         },
-        func: collectSameOriginLinks
+        func: collectSameOriginLinks,
+        args: [
+          {
+            phase: "links"
+          }
+        ]
       });
-      const scan = result?.result || {
-        urls: [],
-        sitemapCount: 0
-      };
-      const found = scan.urls || [];
-      if (!found.length) {
-        setStatus("No same-site links found on this page", true);
+      if (scanJob !== job) return;
+      const added = addUrlsToQueue(links?.result?.urls || []);
+      setStatus(`Added ${added} page links; checking sitemap\u2026`);
+      const [maps] = await chrome.scripting.executeScript({
+        target: {
+          tabId: tab.id
+        },
+        func: collectSameOriginLinks,
+        args: [
+          {
+            phase: "sitemap",
+            id: job.id
+          }
+        ]
+      });
+      if (scanJob !== job) return;
+      if (queueLocked || operationBusy) {
+        setStatus("Scan stopped when the task started; page links are kept");
         return;
       }
-      const added = addUrlsToQueue(found);
-      const sitemapNote = scan.sitemapCount ? `, including ${scan.sitemapCount} from sitemap` : "";
-      setStatus(`Found ${found.length} same-site URLs${sitemapNote}; added ${added} new`);
+      const extra = addUrlsToQueue(maps?.result?.urls || []);
+      setStatus(`Added ${added + extra} URLs${maps?.result?.incomplete ? "; some sitemaps could not be read" : ""}`);
     } catch (error) {
       setStatus(errText(error), true);
+    } finally {
+      if (scanJob === job) {
+        scanJob = null;
+        el.scanSite.textContent = "\u2316 Scan site";
+      }
     }
   }
   __name(scanCurrentSite, "scanCurrentSite");
@@ -1408,14 +2297,24 @@ function initPopup(config) {
       setStatus("Select at least one URL from the queue", true);
       return;
     }
-    el.start.disabled = true;
+    operationBusy = true;
+    renderQueue();
     setStatus("Starting\u2026");
-    const response = await send({
-      type: `${prefix}_START`,
-      urls,
-      settings: config.collectSettings()
-    });
-    el.start.disabled = false;
+    let response;
+    try {
+      response = await send({
+        type: `${prefix}_START`,
+        urls,
+        settings: await config.collectSettings()
+      });
+    } catch (error) {
+      response = {
+        ok: false,
+        error: errText(error)
+      };
+    }
+    operationBusy = false;
+    renderQueue();
     if (!response.ok) {
       setStatus(response.error || "Failed to start", true);
       return;
@@ -1435,15 +2334,25 @@ function initPopup(config) {
       setStatus("Open an http(s) website first", true);
       return;
     }
-    el.captureCurrent.disabled = true;
-    el.start.disabled = true;
+    operationBusy = true;
+    renderQueue();
+    el.cancel.classList.remove("hidden");
     setStatus(config.texts.quickIng);
-    const response = await send({
-      type: `${prefix}_${config.quickType}`,
-      tabId: tab.id,
-      settings: config.collectQuickSettings()
-    });
-    el.captureCurrent.disabled = false;
+    let response;
+    try {
+      response = await send({
+        type: `${prefix}_${config.quickType}`,
+        tabId: tab.id,
+        settings: await config.collectQuickSettings()
+      });
+    } catch (error) {
+      response = {
+        ok: false,
+        error: errText(error)
+      };
+    }
+    operationBusy = false;
+    await refreshState();
     renderQueue();
     if (!response.ok || !response.result) {
       setStatus(response.error || config.texts.quickFailed, true);
@@ -1472,6 +2381,7 @@ function initPopup(config) {
     }
     renderBatch(response.batch);
     setStatus("Batch results cleared");
+    renderQuota(response.quota);
   }
   __name(clearBatchResults, "clearBatchResults");
   async function refreshState() {
@@ -1483,45 +2393,46 @@ function initPopup(config) {
     }
     renderQuota(response.quota);
     renderBatch(response.batch);
-    if (response.batch?.running) {
+    if (response.batch?.running || response.batch?.busy || response.quota?.licenseRefreshing) {
       schedulePoll();
     }
   }
   __name(refreshState, "refreshState");
   function schedulePoll() {
-    if (pollTimer) {
-      clearInterval(pollTimer);
-    }
-    pollTimer = setInterval(async () => {
+    if (disposed) return;
+    clearTimeout(pollTimer);
+    const generation = ++pollGeneration;
+    async function poll() {
       const response = await send({
         type: `${prefix}_STATE`
       });
-      if (!response.ok) {
-        return;
+      if (disposed || generation !== pollGeneration) return;
+      if (response.ok) {
+        renderQuota(response.quota);
+        renderBatch(response.batch);
       }
-      renderQuota(response.quota);
-      renderBatch(response.batch);
-      if (!response.batch?.running && pollTimer) {
-        clearInterval(pollTimer);
-      }
-    }, 800);
+      if (!response.ok || response.batch?.running || response.batch?.busy || response.quota?.licenseRefreshing) pollTimer = setTimeout(poll, 800);
+    }
+    __name(poll, "poll");
+    pollTimer = setTimeout(poll, 800);
   }
   __name(schedulePoll, "schedulePoll");
   function renderQuota(quota) {
     if (!quota) {
       return;
     }
+    if (el.licenseHint) el.licenseHint.textContent = quota.licenseMessage || (quota.pro ? "Your Pro license includes unlimited exports." : "Already purchased? Enter your original activation code to restore Pro in this extension and browser.");
+    el.recheckLicense?.classList.toggle("hidden", !quota.hasLicense);
+    el.proLink.classList.toggle("hidden", quota.pro || quota.hasLicense);
+    el.deactivateBtn.classList.toggle("hidden", !quota.hasLicense);
+    el.activateBtn.classList.toggle("hidden", quota.pro);
     if (quota.pro) {
       const until = quota.expiresAt ? ` \xB7 ${String(quota.expiresAt).slice(0, 10)}` : "";
       el.quotaText.textContent = `unlimited${until}`;
-      el.proLink.classList.add("hidden");
-      el.deactivateBtn.classList.remove("hidden");
-      el.activateBtn.classList.add("hidden");
+    } else if (quota.hasLicense) {
+      el.quotaText.textContent = quota.licenseStatus === "checking" ? "Checking Pro\u2026" : "Pro needs verification";
     } else {
       el.quotaText.textContent = `${quota.remaining}/${quota.limit} today`;
-      el.proLink.classList.remove("hidden");
-      el.deactivateBtn.classList.add("hidden");
-      el.activateBtn.classList.remove("hidden");
     }
   }
   __name(renderQuota, "renderQuota");
@@ -1529,13 +2440,15 @@ function initPopup(config) {
     if (!batch) {
       return;
     }
-    el.start.classList.toggle("hidden", batch.running);
-    el.captureCurrent.classList.toggle("hidden", batch.running);
-    el.cancel.classList.toggle("hidden", !batch.running);
-    queueLocked = batch.running;
-    renderQueue();
+    const busy = batch.running || batch.busy;
+    const stalled = Boolean(batch.stalled);
+    el.start.classList.toggle("hidden", busy);
+    el.captureCurrent.classList.toggle("hidden", busy);
+    el.cancel.classList.toggle("hidden", !busy);
+    queueLocked = busy && !stalled;
+    renderQueue(true);
     el.progressWrap.classList.toggle("hidden", !batch.total);
-    el.clearBatch.classList.toggle("hidden", batch.running || !batch.total);
+    el.clearBatch.classList.toggle("hidden", busy && !stalled || !batch.total);
     if (batch.total) {
       el.progressText.textContent = `${batch.done} / ${batch.total}`;
       el.progressCurrent.textContent = batch.current || "";
@@ -1555,6 +2468,8 @@ function initPopup(config) {
       state.textContent = {
         pending: "\xB7",
         running: "\u2026",
+        downloading: "\u2193",
+        cancelled: "\u2013",
         success: "\u2713",
         failed: "\u2717"
       }[item.status] || "\xB7";
@@ -1576,7 +2491,7 @@ function initPopup(config) {
       }
       el.resultList.append(rowEl);
     }
-    if (batch.folder && batch.done > 0) {
+    if (batch.folder && batch.success > 0) {
       el.folderNote.classList.remove("hidden");
       el.folderNote.textContent = `Saved to Downloads/${batch.folder}/`;
     } else {
@@ -1585,6 +2500,35 @@ function initPopup(config) {
     }
   }
   __name(renderBatch, "renderBatch");
+  async function loadSettings() {
+    const data = await chrome.storage.local.get(settingsKey);
+    const saved = data[settingsKey];
+    if (!saved || typeof saved !== "object") return;
+    settingFields().forEach((field) => {
+      const value = String(saved[field.id]);
+      if (field.tagName === "SELECT" && [
+        ...field.options
+      ].some((option) => option.value === value)) field.value = value;
+      if (field.type === "number" && value.trim() && Number.isFinite(Number(value))) {
+        const fallback = field.value;
+        field.value = value;
+        if (!field.checkValidity()) field.value = fallback;
+      }
+      savedSettings[field.id] = field.value;
+    });
+  }
+  __name(loadSettings, "loadSettings");
+  function saveSettings() {
+    settingFields().forEach((field) => {
+      if (field.type !== "number" || field.value.trim() && Number.isFinite(field.valueAsNumber) && field.checkValidity()) savedSettings[field.id] = field.value;
+    });
+    void chrome.storage.local.set({
+      [settingsKey]: {
+        ...savedSettings
+      }
+    }).catch((error) => setStatus(errText(error), true));
+  }
+  __name(saveSettings, "saveSettings");
   async function loadQueue() {
     const data = await chrome.storage.local.get(config.queueKey);
     const saved = Array.isArray(data[config.queueKey]) ? data[config.queueKey] : [];
@@ -1597,20 +2541,23 @@ function initPopup(config) {
   function saveQueue() {
     void chrome.storage.local.set({
       [config.queueKey]: queue
-    });
+    }).catch((error) => setStatus(errText(error), true));
   }
   __name(saveQueue, "saveQueue");
-  function renderQueue() {
+  function renderQueue(preserveEditor = false) {
+    if (queueLocked || operationBusy) editingIndex = -1;
+    if (editingIndex >= queue.length) editingIndex = -1;
     const selected = queue.filter((item) => item.selected).length;
     el.queueSummary.textContent = `${selected}/${queue.length} selected`;
     el.start.textContent = selected ? config.texts.startSome(selected) : config.texts.startNone;
-    el.start.disabled = selected === 0;
-    el.selectAll.disabled = queueLocked || !queue.length;
-    el.selectNone.disabled = queueLocked || !queue.length;
-    el.moreQueueActions.disabled = queueLocked || !queue.length;
-    el.addUrls.disabled = queueLocked;
-    el.scanSite.disabled = queueLocked;
-    el.captureCurrent.disabled = queueLocked;
+    el.start.disabled = operationBusy || queueLocked || selected === 0;
+    el.selectAll.disabled = queueLocked || operationBusy || !queue.length;
+    el.selectNone.disabled = queueLocked || operationBusy || !queue.length;
+    el.moreQueueActions.disabled = queueLocked || operationBusy || !queue.length;
+    el.addUrls.disabled = queueLocked || operationBusy;
+    el.scanSite.disabled = queueLocked || operationBusy;
+    el.captureCurrent.disabled = queueLocked || operationBusy;
+    if (preserveEditor && editingIndex >= 0 && el.queueList.querySelector(".queueEdit")) return;
     el.queueList.replaceChildren();
     if (!queue.length) {
       const empty = document.createElement("p");
@@ -1625,28 +2572,23 @@ function initPopup(config) {
       const checkbox = document.createElement("input");
       checkbox.type = "checkbox";
       checkbox.checked = item.selected;
-      checkbox.disabled = queueLocked;
+      checkbox.disabled = queueLocked || operationBusy;
       checkbox.setAttribute("aria-label", `Include ${item.url}`);
       checkbox.addEventListener("change", () => {
         item.selected = checkbox.checked;
         saveQueue();
         renderQueue();
       });
-      const url = document.createElement("button");
-      url.type = "button";
-      url.className = "queueUrl";
-      url.textContent = item.url.replace(/^https?:\/\//, "");
-      url.title = item.url;
-      url.disabled = queueLocked;
-      url.addEventListener("click", () => editQueueItem(index));
+      const url = index === editingIndex ? buildQueueEditor(item, index) : buildQueueLabel(item, index);
       const remove = document.createElement("button");
       remove.type = "button";
       remove.className = "queueRemove";
       remove.textContent = "\xD7";
       remove.title = "Remove URL";
-      remove.disabled = queueLocked;
+      remove.disabled = queueLocked || operationBusy;
       remove.addEventListener("click", () => {
         queue.splice(index, 1);
+        editingIndex = -1;
         saveQueue();
         renderQueue();
       });
@@ -1655,30 +2597,82 @@ function initPopup(config) {
     });
   }
   __name(renderQueue, "renderQueue");
-  function editQueueItem(index) {
-    const current = queue[index];
-    const value = prompt("Edit URL", current.url);
-    if (value === null) {
-      return;
-    }
-    const [normalized] = normalizeInputUrls([
-      value
-    ]);
-    if (!normalized) {
-      setStatus("Enter a valid http(s) URL", true);
-      return;
-    }
-    if (queue.some((item, itemIndex) => itemIndex !== index && item.url === normalized)) {
-      setStatus("That URL is already in the queue", true);
-      return;
-    }
-    current.url = normalized;
-    saveQueue();
-    renderQueue();
+  function buildQueueLabel(item, index) {
+    const url = document.createElement("button");
+    url.type = "button";
+    url.className = "queueUrl";
+    url.textContent = item.url.replace(/^https?:\/\//, "");
+    url.title = `${item.url}
+Click to edit`;
+    url.disabled = queueLocked || operationBusy;
+    url.addEventListener("click", () => {
+      if (queueLocked || operationBusy) return;
+      editingIndex = index;
+      renderQueue();
+    });
+    return url;
+  }
+  __name(buildQueueLabel, "buildQueueLabel");
+  function buildQueueEditor(item, index) {
+    const input = document.createElement("input");
+    input.type = "text";
+    input.className = "queueEdit";
+    input.value = item.url;
+    input.spellcheck = false;
+    input.setAttribute("aria-label", `Edit ${item.url}`);
+    const leaveEditor = /* @__PURE__ */ __name(() => {
+      editingIndex = -1;
+      const label = buildQueueLabel(item, index);
+      input.parentElement?.querySelector('input[type="checkbox"]')?.setAttribute("aria-label", `Include ${item.url}`);
+      input.replaceWith(label);
+      return label;
+    }, "leaveEditor");
+    const finish = /* @__PURE__ */ __name((fromBlur) => {
+      if (editingIndex !== index) return;
+      const [normalized] = normalizeInputUrls([
+        input.value
+      ]);
+      const duplicate = normalized && queue.some((other, otherIndex) => otherIndex !== index && other.url === normalized);
+      if (!normalized || duplicate) {
+        const message = duplicate ? "That URL is already in the queue" : "Enter a valid http(s) URL";
+        if (fromBlur) {
+          setStatus(`${message} \u2014 edit discarded`, true);
+          leaveEditor();
+        } else {
+          setStatus(message, true);
+          input.focus();
+          input.select();
+        }
+        return;
+      }
+      if (normalized !== item.url) {
+        item.url = normalized;
+        saveQueue();
+        setStatus("URL updated");
+      }
+      const label = leaveEditor();
+      if (!fromBlur) label.focus();
+    }, "finish");
+    input.addEventListener("keydown", (event) => {
+      if (event.key === "Enter") {
+        event.preventDefault();
+        finish(false);
+      } else if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        leaveEditor().focus();
+      }
+    });
+    input.addEventListener("blur", () => finish(true));
+    queueMicrotask(() => {
+      input.focus();
+      input.select();
+    });
+    return input;
   }
-  __name(editQueueItem, "editQueueItem");
+  __name(buildQueueEditor, "buildQueueEditor");
   function setAllSelected(selected) {
-    if (queueLocked) {
+    if (queueLocked || operationBusy) {
       return;
     }
     queue.forEach((item) => {
@@ -1689,15 +2683,19 @@ function initPopup(config) {
   }
   __name(setAllSelected, "setAllSelected");
   function removeUnselected() {
+    if (queueLocked || operationBusy) return;
     queue = queue.filter((item) => item.selected);
-    el.queueMenu.classList.add("hidden");
+    editingIndex = -1;
+    setQueueMenu(false);
     saveQueue();
     renderQueue();
   }
   __name(removeUnselected, "removeUnselected");
   function clearQueue() {
+    if (queueLocked || operationBusy) return;
     queue = [];
-    el.queueMenu.classList.add("hidden");
+    editingIndex = -1;
+    setQueueMenu(false);
     saveQueue();
     renderQueue();
   }
@@ -1718,6 +2716,7 @@ function initPopup(config) {
   }
   __name(send, "send");
   function setStatus(text, isError = false) {
+    if (disposed) return;
     el.status.textContent = text;
     el.status.classList.toggle("error", isError);
   }
@@ -1728,91 +2727,211 @@ function initPopup(config) {
   __name(errText, "errText");
 }
 __name(initPopup, "initPopup");
-async function collectSameOriginLinks() {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  const origin = location.origin;
-  let sitemapCount = 0;
+async function collectSameOriginLinks(options = {}) {
+  const origin = location.origin, seen = /* @__PURE__ */ new Set(), urls = [];
   const add = /* @__PURE__ */ __name((value) => {
     try {
       const url = new URL(value || "", location.href);
-      url.hash = "";
-      if (url.origin === origin && /^https?:$/.test(url.protocol) && !seen.has(url.toString()) && out.length < 500) {
-        seen.add(url.toString());
-        out.push(url.toString());
+      if (url.origin === origin && /^https?:$/.test(url.protocol) && !seen.has(url.href) && urls.length < 500) {
+        seen.add(url.href);
+        urls.push(url.href);
         return true;
       }
     } catch {
     }
     return false;
   }, "add");
-  add(location.href);
-  for (const a of document.querySelectorAll("a[href]")) {
-    add(a.getAttribute("href"));
-    if (out.length >= 500) {
-      break;
+  if (options.phase === "cancel") {
+    const active = globalThis.__zuckerExtScan;
+    if (active?.id === options.id) {
+      active.cancelled = true;
+      active.controller?.abort();
     }
+    return {
+      urls: [],
+      cancelled: true
+    };
   }
-  const sitemapQueue = [
-    new URL("/sitemap.xml", origin).toString()
-  ];
-  const visitedSitemaps = /* @__PURE__ */ new Set();
-  while (sitemapQueue.length && visitedSitemaps.size < 8 && out.length < 500) {
-    const sitemapUrl = sitemapQueue.shift();
-    if (visitedSitemaps.has(sitemapUrl)) {
-      continue;
+  if (options.phase !== "sitemap") {
+    add(location.href);
+    for (const a of document.querySelectorAll("a[href]")) add(a.getAttribute("href"));
+  }
+  if (options.phase === "links") return {
+    urls,
+    sitemapCount: 0
+  };
+  const scan = {
+    id: options.id,
+    cancelled: false,
+    controller: null
+  };
+  globalThis.__zuckerExtScan?.controller?.abort();
+  globalThis.__zuckerExtScan = scan;
+  const deadline = Date.now() + 6e3;
+  let incomplete = false, sitemapCount = 0;
+  const queue = [
+    new URL("/sitemap.xml", origin).href
+  ], visited = /* @__PURE__ */ new Set();
+  const sameOrigin = /* @__PURE__ */ __name((value) => {
+    try {
+      const url = new URL(value, origin);
+      return url.origin === origin && /^https?:$/.test(url.protocol) ? url.href : null;
+    } catch {
+      return null;
+    }
+  }, "sameOrigin");
+  async function read(url) {
+    if (scan.cancelled || Date.now() >= deadline) {
+      incomplete = true;
+      return null;
     }
-    visitedSitemaps.add(sitemapUrl);
+    const controller = new AbortController();
+    scan.controller = controller;
+    const timer = setTimeout(() => controller.abort(), Math.min(1500, deadline - Date.now()));
     try {
-      const response = await fetch(sitemapUrl, {
-        credentials: "same-origin"
+      const response = await fetch(url, {
+        credentials: "same-origin",
+        signal: controller.signal
       });
-      if (!response.ok) {
-        continue;
-      }
-      const xml = new DOMParser().parseFromString(await response.text(), "application/xml");
-      for (const loc of xml.querySelectorAll("loc")) {
-        const value = loc.textContent?.trim();
-        if (!value) {
-          continue;
-        }
-        if (/\.xml(?:\.gz)?(?:$|\?)/i.test(value)) {
-          try {
-            const nested = new URL(value, sitemapUrl);
-            if (nested.origin === origin && !visitedSitemaps.has(nested.toString())) {
-              sitemapQueue.push(nested.toString());
-            }
-          } catch {
-          }
-        } else if (add(value)) {
-          sitemapCount += 1;
+      if (!response.ok) return null;
+      if (Number(response.headers.get("content-length")) > 2 * 1024 * 1024) throw new Error("Sitemap too large");
+      let stream = response.body;
+      const reader = stream.getReader();
+      const first = await reader.read();
+      const gzip = first.value?.[0] === 31 && first.value?.[1] === 139;
+      stream = new ReadableStream({
+        start(ctrl) {
+          if (first.value) ctrl.enqueue(first.value);
+          if (first.done) ctrl.close();
+        },
+        async pull(ctrl) {
+          const value = await reader.read();
+          value.done ? ctrl.close() : ctrl.enqueue(value.value);
+        },
+        cancel(reason) {
+          return reader.cancel(reason);
         }
-        if (out.length >= 500) {
-          break;
+      });
+      if (gzip) stream = stream.pipeThrough(new DecompressionStream("gzip"));
+      const decoded = stream.getReader(), chunks = [];
+      let size = 0;
+      try {
+        while (true) {
+          const next = await decoded.read();
+          if (next.done) break;
+          size += next.value.length;
+          if (size > 2 * 1024 * 1024) throw new Error("Sitemap too large");
+          chunks.push(next.value);
         }
+      } finally {
+        await decoded.cancel().catch(() => {
+        });
       }
+      return await new Blob(chunks).text();
     } catch {
+      incomplete = true;
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  __name(read, "read");
+  const robots = await read(new URL("/robots.txt", origin).href);
+  for (const match of (robots || "").matchAll(/^sitemap:\s*(\S+)/gim)) {
+    const url = sameOrigin(match[1]);
+    if (url) queue.push(url);
+  }
+  while (queue.length && visited.size < 8 && urls.length < 500 && !scan.cancelled && Date.now() < deadline) {
+    const url = queue.shift();
+    if (visited.has(url)) continue;
+    visited.add(url);
+    const content = await read(url);
+    if (!content) continue;
+    const xml = new DOMParser().parseFromString(content, "application/xml");
+    if (xml.querySelector("parsererror")) {
+      incomplete = true;
+      continue;
+    }
+    const index = xml.documentElement.localName === "sitemapindex";
+    for (const loc of xml.querySelectorAll("loc")) {
+      const value = sameOrigin(loc.textContent?.trim());
+      if (!value) continue;
+      if (index) {
+        if (!visited.has(value)) queue.push(value);
+      } else if (add(value)) sitemapCount++;
     }
   }
+  if (queue.length) incomplete = true;
+  if (globalThis.__zuckerExtScan === scan) delete globalThis.__zuckerExtScan;
   return {
-    urls: out,
-    sitemapCount
+    urls,
+    sitemapCount,
+    incomplete,
+    cancelled: scan.cancelled
   };
 }
 __name(collectSameOriginLinks, "collectSameOriginLinks");
+
+// src/capture-budget.js
+var CAPTURE_LIMITS = {
+  maxEdgeDevicePx: 16384,
+  maxDevicePixels: 64 * 1024 * 1024
+};
+function captureScale(dpr) {
+  return Number.isFinite(dpr) && dpr > 0 ? dpr : 1;
+}
+__name(captureScale, "captureScale");
+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;
+}
+__name(captureFits, "captureFits");
+function assertCaptureFits(width, height, dpr, message) {
+  if (!captureFits(width, height, dpr)) throw new Error(message);
+}
+__name(assertCaptureFits, "assertCaptureFits");
+function captureBudget(dpr) {
+  const scale = captureScale(dpr);
+  return {
+    maxEdge: Math.floor(CAPTURE_LIMITS.maxEdgeDevicePx / scale),
+    maxArea: Math.floor(CAPTURE_LIMITS.maxDevicePixels / scale ** 2)
+  };
+}
+__name(captureBudget, "captureBudget");
+async function readDevicePixelRatio(ctx) {
+  const result = await ctx.send("Runtime.evaluate", {
+    expression: "devicePixelRatio || 1",
+    returnByValue: true
+  });
+  return captureScale(result?.result?.value);
+}
+__name(readDevicePixelRatio, "readDevicePixelRatio");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CAPTURE_LIMITS,
+  assertCaptureFits,
   buildBatchFileName,
   buildQuickFileName,
+  captureBudget,
+  captureFits,
+  collectSameOriginLinks,
+  createDownloader,
   createLicensing,
   fileStamp,
   folderNameFor,
+  hidePageCaptureDecorations,
   hostOf,
   initExtension,
   initPopup,
   normalizeUrls,
+  readDevicePixelRatio,
   sanitize,
+  scrollCapture,
   sessionStamp,
+  showPageCaptureDecorations,
   todayString,
   urlBaseName
 });