@zucker-framework/ext-kit 1.0.0

package/dist/ext-kit.js

@@ -0,0 +1,955 @@
+"use strict";
+(() => {
+  // src/util.ts
+  function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+  }
+  function normalizeError(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  function storageGet(keys) {
+    return new Promise((resolve) => chrome.storage.local.get(keys, resolve));
+  }
+  function storageSet(value) {
+    return new Promise((resolve) => chrome.storage.local.set(value, () => resolve()));
+  }
+  function storageRemove(keys) {
+    return new Promise((resolve) => chrome.storage.local.remove(keys, () => resolve()));
+  }
+
+  // src/naming.ts
+  function sanitize(value) {
+    return String(value || "").replace(/[\\/:*?"<>|#&=%]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  function hostOf(url) {
+    try {
+      return new URL(url).host;
+    } catch {
+      return String(url || "");
+    }
+  }
+  function normalizeUrls(urls) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const raw of urls || []) {
+      const value = String(raw || "").trim();
+      if (!/^https?:\/\//i.test(value)) {
+        continue;
+      }
+      let key = value;
+      try {
+        const parsed = new URL(value);
+        parsed.hash = "";
+        key = parsed.toString();
+      } catch {
+        continue;
+      }
+      if (!seen.has(key)) {
+        seen.add(key);
+        out.push(key);
+      }
+      if (out.length >= 500) {
+        break;
+      }
+    }
+    return out;
+  }
+  function sessionStamp() {
+    const d = /* @__PURE__ */ new Date();
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}`;
+  }
+  function fileStamp() {
+    const d = /* @__PURE__ */ new Date();
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  }
+  function todayString() {
+    const d = /* @__PURE__ */ new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  }
+  function folderNameFor(urls) {
+    const hosts = /* @__PURE__ */ new Set();
+    for (const url of urls) {
+      try {
+        hosts.add(new URL(url).hostname.replace(/^www\./, ""));
+      } catch {
+      }
+    }
+    const stamp = sessionStamp();
+    if (hosts.size === 1) {
+      const host = sanitize([...hosts][0]).slice(0, 60);
+      return host ? `${host}-${stamp}` : stamp;
+    }
+    return stamp;
+  }
+  function urlBaseName(url, maxLength, includeQuery) {
+    let base = "page";
+    try {
+      const parsed = new URL(url);
+      const host = parsed.hostname.replace(/^www\./, "");
+      let rest = (parsed.pathname + (includeQuery ? parsed.search : "")).replace(/\/+$/, "");
+      try {
+        rest = decodeURIComponent(rest);
+      } catch {
+      }
+      base = host + rest;
+    } catch {
+      base = url;
+    }
+    return sanitize(base).slice(0, maxLength) || "page";
+  }
+  function buildBatchFileName(folder, item, extension) {
+    const base = urlBaseName(item.url, 120, true);
+    const index = String(item.index).padStart(3, "0");
+    return `${folder}/${index}_${base}.${extension}`;
+  }
+  function buildQuickFileName(brand, quickFolder, pageUrl, extension) {
+    const base = urlBaseName(pageUrl, 110, false);
+    return `${brand}/${quickFolder}/${base}-${fileStamp()}.${extension}`;
+  }
+
+  // src/licensing.ts
+  var CACHE_TTL_MS = 12 * 60 * 60 * 1e3;
+  function unwrap(payload) {
+    const obj = payload;
+    return obj && typeof obj === "object" && "result" in obj ? obj.result : obj || {};
+  }
+  function createLicensing(product, brand, config) {
+    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];
+      }
+      const bytes = new Uint8Array(16);
+      crypto.getRandomValues(bytes);
+      const id = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+      await storageSet({ [DEVICE_KEY]: id });
+      return id;
+    }
+    async function activate(code) {
+      const deviceId = await getDeviceId();
+      let response;
+      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}`
+          })
+        });
+      } 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.");
+      }
+      const data = unwrap(payload);
+      await storageSet({
+        [TOKEN_KEY]: data.token || "",
+        [ENTITLEMENT_KEY]: { ...data.entitlement || {}, checkedAt: Date.now() }
+      });
+      return data.entitlement;
+    }
+    function normalize(value) {
+      const v = value;
+      if (!v) {
+        return null;
+      }
+      const expired = v.expiresAt && new Date(v.expiresAt).getTime() <= Date.now();
+      return expired ? null : { plan: v.plan || "pro", expiresAt: v.expiresAt || "" };
+    }
+    async function getEntitlement() {
+      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}` }
+        });
+      } 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;
+      }
+      const payload = await response.json().catch(() => ({}));
+      const entitlement = unwrap(payload)?.entitlement;
+      await storageSet({
+        [ENTITLEMENT_KEY]: { ...entitlement || {}, checkedAt: Date.now() }
+      });
+      return normalize(entitlement);
+    }
+    async function isPro() {
+      return Boolean(await getEntitlement());
+    }
+    async function clear() {
+      await storageRemove([TOKEN_KEY, ENTITLEMENT_KEY]);
+    }
+    return { activate, getEntitlement, isPro, clear, purchaseUrl: config.purchaseUrl };
+  }
+
+  // src/download.ts
+  function createDownloader(justification) {
+    const pendingDownloadNames = /* @__PURE__ */ new Map();
+    let offscreenSetup = null;
+    chrome.downloads.onDeterminingFilename.addListener((item, suggest) => {
+      const fileName = pendingDownloadNames.get(item.url) || pendingDownloadNames.get(item.finalUrl || "");
+      if (!fileName) {
+        return;
+      }
+      suggest({ filename: fileName, conflictAction: "uniquify" });
+      return true;
+    });
+    async function ensureOffscreen() {
+      if (await chrome.offscreen.hasDocument()) {
+        return;
+      }
+      if (!offscreenSetup) {
+        offscreenSetup = chrome.offscreen.createDocument({
+          url: "offscreen.html",
+          reasons: [chrome.offscreen.Reason.BLOBS],
+          justification
+        }).catch((error) => {
+          if (!String(error?.message || "").includes("Only a single")) {
+            throw error;
+          }
+        }).finally(() => {
+          offscreenSetup = null;
+        });
+      }
+      return offscreenSetup;
+    }
+    async function downloadViaBlob(base64, mime, filename) {
+      await ensureOffscreen();
+      const created = await chrome.runtime.sendMessage({
+        target: "offscreen",
+        type: "CREATE_BLOB_URL",
+        base64,
+        mime
+      });
+      if (!created?.ok || !created.url) {
+        throw new Error(created?.error || "Failed to prepare download");
+      }
+      const url = created.url;
+      pendingDownloadNames.set(url, filename);
+      const cleanup = () => {
+        pendingDownloadNames.delete(url);
+        chrome.runtime.sendMessage({ target: "offscreen", type: "REVOKE_BLOB_URL", url }).catch(() => {
+        });
+      };
+      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);
+            }
+          );
+        });
+        setTimeout(cleanup, 6e4);
+        return downloadId;
+      } catch (error) {
+        cleanup();
+        throw error;
+      }
+    }
+    return { downloadViaBlob };
+  }
+
+  // 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();
+      });
+    });
+  }
+  function debuggerDetach(target) {
+    return new Promise((resolve, reject) => {
+      chrome.debugger.detach(target, () => {
+        const error = chrome.runtime.lastError;
+        error ? reject(new Error(error.message)) : resolve();
+      });
+    });
+  }
+  function sendCommand(target, method, params) {
+    return new Promise((resolve, reject) => {
+      chrome.debugger.sendCommand(target, method, params || {}, (result) => {
+        const error = chrome.runtime.lastError;
+        error ? reject(new Error(error.message)) : resolve(result || {});
+      });
+    });
+  }
+  function waitForLoad(tabId, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (fn, value) => {
+        if (!settled) {
+          settled = true;
+          chrome.tabs.onUpdated.removeListener(listener);
+          clearTimeout(timer);
+          fn(value);
+        }
+      };
+      const listener = (updatedTabId, changeInfo) => {
+        if (updatedTabId === tabId && changeInfo.status === "complete") {
+          finish(resolve);
+        }
+      };
+      const timer = setTimeout(() => finish(reject, new Error("Page load timeout")), timeoutMs);
+      chrome.tabs.onUpdated.addListener(listener);
+      chrome.tabs.get(tabId).then((tab) => {
+        if (tab.status === "complete") {
+          finish(resolve);
+        }
+      }).catch(() => {
+      });
+    });
+  }
+  function challengeError(name) {
+    const error = new Error(`Blocked by ${name} verification`);
+    error.isChallenge = true;
+    return error;
+  }
+  function isChallengeError(error) {
+    return Boolean(error?.isChallenge);
+  }
+  var CHALLENGE_TITLE_RE = /just a moment|checking your browser|attention required|verifying|security checkpoint|正在验证|安全检查点|verify you are human|are you a robot|请完成验证|人机验证|captcha/;
+  async function probePage(target) {
+    const r = await sendCommand(target, "Runtime.evaluate", {
+      returnByValue: true,
+      expression: `(function(){
+      var uri=document.documentURI||"";
+      if(uri.indexOf("chrome-error://")===0) return {error:"Page failed to load (DNS or network error)",challenge:""};
+      var t=(document.title||"").toLowerCase();
+      var b=(document.body?document.body.innerText:"").slice(0,500).toLowerCase();
+      var u=(location.href||"").toLowerCase();
+      var s=t+" "+b+" "+u;
+      var c="";
+      if(/just a moment|checking your browser|attention required|cf-browser-verification|challenges\\.cloudflare/.test(s)) c="Cloudflare";
+      else if(/verifying your browser|\u6B63\u5728\u9A8C\u8BC1\u60A8\u7684\u6D4F\u89C8\u5668|security checkpoint|\u5B89\u5168\u68C0\u67E5\u70B9/.test(s)) c="Vercel";
+      else if(/verify you are human|are you a robot|\u8BF7\u5B8C\u6210\u9A8C\u8BC1|\u4EBA\u673A\u9A8C\u8BC1|captcha/.test(s)) c="bot-check";
+      return {error:"",challenge:c};
+    })()`
+    });
+    const value = r.result?.value;
+    return value || { error: "", challenge: "" };
+  }
+  async function waitForVerification(tabId, shouldStop, timeoutMs = 18e4) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (shouldStop()) {
+        return false;
+      }
+      await delay(2500);
+      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;
+      }
+    }
+    return false;
+  }
+  async function focusTab(tabId) {
+    await chrome.tabs.update(tabId, { active: true }).catch(() => {
+    });
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      if (tab.windowId != null) {
+        await chrome.windows.update(tab.windowId, { focused: true });
+      }
+    } catch {
+    }
+  }
+  function autoScroll(target) {
+    return sendCommand(target, "Runtime.evaluate", {
+      awaitPromise: true,
+      expression: `new Promise(function(resolve){
+      var distance=600, scrolled=0, guard=0;
+      var maxHeight=Math.min(document.body?document.body.scrollHeight:0, 20000);
+      var timer=setInterval(function(){
+        window.scrollBy(0, distance);
+        scrolled+=distance; guard+=1;
+        var reached=scrolled>=Math.max(maxHeight, document.body?document.body.scrollHeight:0);
+        if(reached || guard>60){
+          clearInterval(timer);
+          setTimeout(function(){ window.scrollTo(0,0); setTimeout(resolve, 400); }, 300);
+        }
+      }, 120);
+    })`
+    }).catch(() => void 0);
+  }
+  function revealAnimations(target, reversible = false) {
+    return sendCommand(target, "Runtime.evaluate", {
+      expression: `(function(){
+      try{
+        var reversible=${reversible ? "true" : "false"};
+        var state=reversible?{style:null,aos:[],inline:[]}:null;
+        var css=document.createElement('style');
+        css.textContent=[
+          '[data-aos]{opacity:1!important;transform:none!important;transition:none!important;}',
+          '.wow{visibility:visible!important;opacity:1!important;animation-name:none!important;}',
+          '.animate__animated,.animated{opacity:1!important;}',
+          '[data-scroll]{opacity:1!important;transform:none!important;}',
+          '.reveal,[data-sr],[data-sr-id],.sr-reveal{opacity:1!important;transform:none!important;visibility:visible!important;}'
+        ].join('');
+        (document.head||document.documentElement).appendChild(css);
+        if(state) state.style=css;
+        document.querySelectorAll('[data-aos]').forEach(function(el){
+          if(state&&!el.classList.contains('aos-animate')) state.aos.push(el);
+          el.classList.add('aos-animate');
+        });
+        // \u901A\u7528\u515C\u5E95\uFF1A\u88AB\u52A8\u753B\u85CF\u8D77\u6765\u7684\u5185\u5BB9\u5757\uFF08opacity\u22480 \u4E14\u5E26 transition/animation\uFF09\u5F3A\u5236\u663E\u793A\u3002
+        // \u53EA\u5904\u7406 static/relative\uFF08\u666E\u901A\u5185\u5BB9\u6D41\uFF09\uFF0C\u8DF3\u8FC7 fixed/absolute\uFF08\u591A\u4E3A\u5F39\u7A97/\u83DC\u5355/\u8F6E\u64AD\uFF09\uFF0C\u907F\u514D\u8BEF\u4F24
+        var all=document.body?document.body.querySelectorAll('*'):[];
+        for(var i=0;i<all.length;i++){
+          var el=all[i], s=getComputedStyle(el);
+          if(parseFloat(s.opacity)<0.05 && (s.transitionDuration!=='0s'||s.animationName!=='none')){
+            var p=s.position;
+            if(p==='static'||p==='relative'){
+              if(state) state.inline.push({
+                el:el,
+                opacity:el.style.getPropertyValue('opacity'),
+                opacityPriority:el.style.getPropertyPriority('opacity'),
+                transform:el.style.getPropertyValue('transform'),
+                transformPriority:el.style.getPropertyPriority('transform')
+              });
+              el.style.setProperty('opacity','1','important');
+              el.style.setProperty('transform','none','important');
+            }
+          }
+        }
+        if(state) window.__zuckerExtRevealState=state;
+      }catch(e){}
+    })()`
+    }).catch(() => void 0);
+  }
+  async function getScrollPosition(target) {
+    const result = await sendCommand(target, "Runtime.evaluate", {
+      returnByValue: true,
+      expression: `({ x: window.scrollX || 0, y: window.scrollY || 0 })`
+    });
+    const value = result.result?.value;
+    return value || { x: 0, y: 0 };
+  }
+  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});
+    })()`
+    });
+  }
+
+  // src/engine.ts
+  var LOAD_TIMEOUT_MS = 3e4;
+  var SAME_HOST_MIN_GAP_MS = 1800;
+  var DEFAULT_TEXTS = {
+    alreadyRunning: "Another capture is already running",
+    cannotQuick: "This page cannot be captured. Open an http(s) website first.",
+    challengeBeforeQuick: (challenge) => `Complete the ${challenge} verification before capturing this page.`,
+    quickFolder: "Quick Captures"
+  };
+  function initExtension(config) {
+    const texts = { ...DEFAULT_TEXTS, ...config.texts || {} };
+    const freeDailyLimit = config.freeDailyLimit ?? 30;
+    const USAGE_KEY = `${config.product}_free_usage`;
+    const BATCH_KEY = `${config.product}_batch_state`;
+    const prefix = config.messagePrefix;
+    const licensing = createLicensing(config.product, config.brand, config.licensing);
+    const downloader = createDownloader(
+      `Convert large ${config.brand} output into a downloadable blob URL.`
+    );
+    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;
+    });
+    function idleBatch() {
+      return {
+        running: false,
+        cancelRequested: false,
+        startedAt: null,
+        folder: "",
+        total: 0,
+        done: 0,
+        success: 0,
+        failed: 0,
+        current: "",
+        freeLimited: false,
+        needVerify: null,
+        skipVerify: false,
+        settings: { ...config.defaultSettings },
+        pro: false,
+        items: []
+      };
+    }
+    async function handleMessage(message) {
+      await restorePromise;
+      switch (message.type) {
+        case `${prefix}_START`:
+          return startBatch(message.urls, message.settings);
+        // 两个后缀都接受：CAPTURE_CURRENT（截图类）/ CONVERT_CURRENT（转换类），兼容既有 popup
+        case `${prefix}_CAPTURE_CURRENT`:
+        case `${prefix}_CONVERT_CURRENT`:
+          return quickCapture(message.tabId, message.settings);
+        case `${prefix}_CANCEL`:
+          return cancelBatch();
+        case `${prefix}_CLEAR_BATCH`:
+          return clearBatch();
+        case `${prefix}_SKIP_VERIFY`:
+          batch.skipVerify = true;
+          await persistBatch();
+          return { ok: true };
+        case `${prefix}_STATE`:
+          return { ok: true, batch: publicBatch(), quota: await getQuota() };
+        case `${prefix}_ACTIVATE`:
+          await licensing.activate(message.code);
+          return { ok: true, quota: await getQuota() };
+        case `${prefix}_CLEAR_LICENSE`:
+          await licensing.clear();
+          return { ok: true, quota: await getQuota() };
+        default:
+          return { ok: false, error: "Unknown message" };
+      }
+    }
+    async function getQuota() {
+      const entitlement = await licensing.getEntitlement().catch(() => null);
+      if (entitlement) {
+        return { pro: true, expiresAt: entitlement.expiresAt, limit: null, used: 0, remaining: 999999 };
+      }
+      const data = await storageGet(USAGE_KEY);
+      const usage = data[USAGE_KEY];
+      const today = todayString();
+      const used = usage && usage.date === today ? usage.used || 0 : 0;
+      return { pro: false, limit: freeDailyLimit, used, remaining: Math.max(0, freeDailyLimit - used) };
+    }
+    async function recordUsage(count) {
+      const data = await storageGet(USAGE_KEY);
+      const today = todayString();
+      const usage = data[USAGE_KEY];
+      const used = usage && usage.date === today ? usage.used || 0 : 0;
+      await storageSet({ [USAGE_KEY]: { date: today, used: used + count } });
+    }
+    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 || {} };
+      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();
+      });
+      return { ok: true, batch: publicBatch(), quota: await getQuota() };
+    }
+    async function quickCapture(tabId, settings) {
+      if (batch.running || quickRunning) {
+        return { ok: false, error: texts.alreadyRunning };
+      }
+      if (!Number.isInteger(tabId)) {
+        return { ok: false, error: "No active web page" };
+      }
+      const tab = await chrome.tabs.get(tabId).catch(() => null);
+      if (!tab?.url || !/^https?:\/\//i.test(tab.url)) {
+        return { ok: false, error: texts.cannotQuick };
+      }
+      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.`
+        };
+      }
+      quickRunning = true;
+      setBadge("1");
+      try {
+        const options = { ...config.defaultSettings, ...settings || {} };
+        const result = await captureExistingTab(tabId, tab.url, options);
+        if (!quota.pro) {
+          await recordUsage(1);
+        }
+        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() };
+      } finally {
+        quickRunning = false;
+      }
+    }
+    async function captureExistingTab(tabId, pageUrl, options) {
+      const target = { tabId };
+      let attached = false;
+      let scrollPosition = { x: 0, y: 0 };
+      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));
+        }
+        scrollPosition = await getScrollPosition(target);
+        await delay(clamp(Number(options.delayMs) || Number(config.defaultSettings.delayMs) || 1500, 0, 1e4));
+        await autoScroll(target);
+        await revealAnimations(target, true);
+        await delay(400);
+        const output = await config.capture(makeContext("quick", tabId, pageUrl, options, target));
+        const fileName = buildQuickFileName(config.brand, texts.quickFolder, pageUrl, output.extension);
+        await downloader.downloadViaBlob(output.base64, output.mime, fileName);
+        return { fileName, warning: output.warning || "" };
+      } finally {
+        if (attached) {
+          await restorePageAfterQuick(target, scrollPosition).catch(() => {
+          });
+          await debuggerDetach(target).catch(() => {
+          });
+        }
+      }
+    }
+    async function cancelBatch() {
+      if (batch.running) {
+        batch.cancelRequested = true;
+        batch.current = "Stopping\u2026";
+        await persistBatch();
+      }
+      return { ok: true, batch: publicBatch() };
+    }
+    async function clearBatch() {
+      if (batch.running) {
+        return { ok: false, error: "Stop the running batch before clearing it" };
+      }
+      batch = idleBatch();
+      await storageRemove(BATCH_KEY);
+      setBadge("");
+      return { ok: true, batch: publicBatch() };
+    }
+    async function runBatch(options) {
+      const lastHostAt = {};
+      for (const item of batch.items) {
+        if (item.status !== "pending") {
+          continue;
+        }
+        if (batch.cancelRequested) {
+          break;
+        }
+        const host = hostOf(item.url);
+        const since = Date.now() - (lastHostAt[host] || 0);
+        if (lastHostAt[host] && since < SAME_HOST_MIN_GAP_MS) {
+          batch.current = "Pacing to avoid rate-limits\u2026";
+          await delay(SAME_HOST_MIN_GAP_MS - since);
+          if (batch.cancelRequested) {
+            break;
+          }
+        }
+        lastHostAt[host] = Date.now();
+        item.status = "running";
+        batch.current = item.url;
+        setBadge(`${batch.done + 1}/${batch.total}`);
+        await persistBatch();
+        let shouldCharge = false;
+        try {
+          const result = await captureUrl(item, options);
+          item.fileName = result.fileName;
+          item.warning = result.warning;
+          item.status = "success";
+          batch.success += 1;
+          if (!batch.pro && !item.usageRecorded) {
+            item.usageRecorded = true;
+            shouldCharge = true;
+          }
+        } catch (error) {
+          item.status = "failed";
+          item.error = normalizeError(error);
+          batch.failed += 1;
+        }
+        batch.done = batch.success + batch.failed;
+        await persistBatch();
+        if (shouldCharge) {
+          await recordUsage(1);
+        }
+      }
+      batch.running = false;
+      batch.current = batch.cancelRequested ? "Stopped" : "Done";
+      batch.needVerify = null;
+      await persistBatch();
+      setBadge(batch.failed ? "ERR" : "OK");
+      setTimeout(() => setBadge(""), 4e3);
+    }
+    async function captureUrl(item, options) {
+      const maxChallengeRetry = 2;
+      let lastError;
+      for (let attempt = 0; attempt <= maxChallengeRetry; attempt += 1) {
+        if (batch.cancelRequested) {
+          throw new Error("Cancelled");
+        }
+        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);
+          }
+        }
+      }
+      if (isChallengeError(lastError) && !batch.cancelRequested) {
+        return await captureOnce(item, options, true);
+      }
+      throw lastError;
+    }
+    async function captureOnce(item, options, interactive) {
+      const tab = await chrome.tabs.create({ url: item.url, active: Boolean(interactive) });
+      const tabId = tab.id;
+      if (!tabId) {
+        throw new Error("Could not open tab");
+      }
+      const target = { tabId };
+      let attached = false;
+      try {
+        await waitForLoad(tabId, LOAD_TIMEOUT_MS);
+        await delay(Number(options.delayMs) || 0);
+        if (batch.cancelRequested) {
+          throw new Error("Cancelled");
+        }
+        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(() => {
+          });
+          attached = false;
+          await focusTab(tabId);
+          batch.needVerify = { url: item.url, challenge: probe.challenge };
+          batch.current = `Complete ${probe.challenge} verification in the opened tab\u2026`;
+          await persistBatch();
+          batch.skipVerify = false;
+          const passed = await waitForVerification(tabId, () => batch.cancelRequested || batch.skipVerify);
+          batch.needVerify = null;
+          batch.current = item.url;
+          await persistBatch();
+          if (!passed) {
+            throw challengeError(`${probe.challenge} verification not completed`);
+          }
+          await delay(800);
+          await debuggerAttach(target, "1.3");
+          attached = true;
+          await sendCommand(target, "Page.enable");
+          await sendCommand(target, "Runtime.enable");
+        }
+        const ctx = makeContext("batch", tabId, item.url, options, target);
+        if (config.beforeScroll) {
+          await config.beforeScroll(ctx);
+        }
+        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 || "" };
+      } finally {
+        if (attached) {
+          await debuggerDetach(target).catch(() => {
+          });
+        }
+        await chrome.tabs.remove(tabId).catch(() => {
+        });
+      }
+    }
+    function makeContext(mode, tabId, url, options, target) {
+      return {
+        mode,
+        tabId,
+        url,
+        options,
+        send: (method, params) => sendCommand(target, method, params)
+      };
+    }
+    function publicBatch() {
+      return {
+        running: batch.running,
+        total: batch.total,
+        done: batch.done,
+        success: batch.success,
+        failed: batch.failed,
+        current: batch.current,
+        folder: batch.folder,
+        freeLimited: batch.freeLimited,
+        needVerify: batch.needVerify,
+        items: batch.items.map((item) => ({
+          url: item.url,
+          index: item.index,
+          status: item.status,
+          fileName: item.fileName,
+          error: item.error,
+          warning: item.warning
+        }))
+      };
+    }
+    async function persistBatch() {
+      await storageSet({ [BATCH_KEY]: batch });
+    }
+    async function restoreBatch() {
+      const data = await storageGet(BATCH_KEY);
+      const saved = data[BATCH_KEY];
+      if (!saved?.items?.length) {
+        return;
+      }
+      batch = { ...idleBatch(), ...saved };
+      batch.settings = { ...config.defaultSettings, ...saved.settings || {} };
+      batch.items = saved.items.map((item) => ({
+        url: item.url || "",
+        index: item.index || 0,
+        status: item.status === "running" ? "pending" : item.status || "pending",
+        fileName: item.fileName || "",
+        error: item.error || "",
+        warning: item.warning || "",
+        usageRecorded: item.usageRecorded || false
+      }));
+      batch.done = batch.items.filter((item) => item.status === "success" || item.status === "failed").length;
+      batch.success = batch.items.filter((item) => item.status === "success").length;
+      batch.failed = batch.items.filter((item) => item.status === "failed").length;
+      batch.needVerify = null;
+      batch.skipVerify = false;
+      if (saved.running && batch.items.some((item) => item.status === "pending")) {
+        batch.running = true;
+        batch.cancelRequested = false;
+        batch.current = "Resuming interrupted batch\u2026";
+        await persistBatch();
+        runBatch(batch.settings).catch(async (error) => {
+          batch.running = false;
+          batch.current = normalizeError(error);
+          await persistBatch();
+        });
+      } else if (saved.running) {
+        batch.running = false;
+        batch.current = "Done";
+        await persistBatch();
+      }
+    }
+    function setBadge(text) {
+      chrome.action.setBadgeText({ text });
+      chrome.action.setBadgeBackgroundColor({ color: config.badgeColor });
+    }
+  }
+
+  // src/background.entry.ts
+  globalThis.ZuckerExt = { init: initExtension };
+})();