tabctl 0.6.0-alpha.9 → 0.6.0-rc.10

package/dist/extension/background.js

@@ -1,455 +1,766 @@
 (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // dist/extension/lib/screenshot.js
-  var require_screenshot = __commonJS({
-    "dist/extension/lib/screenshot.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.SCREENSHOT_PROCESS_TIMEOUT_MS = exports.SCREENSHOT_CAPTURE_DELAY_MS = exports.SCREENSHOT_SCROLL_DELAY_MS = exports.SCREENSHOT_QUALITY = exports.SCREENSHOT_MAX_BYTES = exports.SCREENSHOT_TILE_MAX_DIM = void 0;
-      exports.estimateDataUrlBytes = estimateDataUrlBytes;
-      exports.arrayBufferToBase64 = arrayBufferToBase64;
-      exports.resizeDataUrl = resizeDataUrl;
-      exports.resizeDataUrlToMaxDim = resizeDataUrlToMaxDim;
-      exports.cropDataUrl = cropDataUrl;
-      exports.ensureMaxBytes = ensureMaxBytes;
-      exports.constrainDataUrl = constrainDataUrl;
-      exports.captureVisible = captureVisible;
-      exports.getPageMetrics = getPageMetrics;
-      exports.scrollToPosition = scrollToPosition;
-      exports.captureTabTiles = captureTabTiles;
-      exports.SCREENSHOT_TILE_MAX_DIM = 2e3;
-      exports.SCREENSHOT_MAX_BYTES = 2e6;
-      exports.SCREENSHOT_QUALITY = 80;
-      exports.SCREENSHOT_SCROLL_DELAY_MS = 150;
-      exports.SCREENSHOT_CAPTURE_DELAY_MS = 350;
-      exports.SCREENSHOT_PROCESS_TIMEOUT_MS = 8e3;
-      function estimateDataUrlBytes(dataUrl) {
-        const commaIndex = dataUrl.indexOf(",");
-        if (commaIndex < 0) {
-          return dataUrl.length;
-        }
-        const base64 = dataUrl.slice(commaIndex + 1);
-        const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
-        return Math.max(0, Math.floor(base64.length * 3 / 4) - padding);
-      }
-      function arrayBufferToBase64(buffer) {
-        const bytes = new Uint8Array(buffer);
-        let binary = "";
-        for (let i = 0; i < bytes.length; i += 1) {
-          binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-      }
-      async function resizeDataUrl(dataUrl, format, quality, scale) {
-        if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
-          return null;
-        }
-        const response = await fetch(dataUrl);
-        const blob = await response.blob();
-        const bitmap = await createImageBitmap(blob);
-        const width = Math.max(1, Math.floor(bitmap.width * scale));
-        const height = Math.max(1, Math.floor(bitmap.height * scale));
-        const canvas = new OffscreenCanvas(width, height);
-        const ctx = canvas.getContext("2d");
-        if (!ctx) {
-          return null;
-        }
-        ctx.drawImage(bitmap, 0, 0, width, height);
-        const type = format === "jpeg" ? "image/jpeg" : "image/png";
-        const blobOut = await canvas.convertToBlob({ type, quality: format === "jpeg" ? quality / 100 : void 0 });
-        const buffer = await blobOut.arrayBuffer();
-        const base64 = arrayBufferToBase64(buffer);
-        return {
-          dataUrl: `data:${type};base64,${base64}`,
-          bytes: buffer.byteLength
-        };
-      }
-      async function resizeDataUrlToMaxDim(dataUrl, format, quality, maxDim) {
-        if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
-          return null;
-        }
-        const response = await fetch(dataUrl);
-        const blob = await response.blob();
-        const bitmap = await createImageBitmap(blob);
-        const maxSize = Math.max(bitmap.width, bitmap.height);
-        if (!Number.isFinite(maxSize) || maxSize <= maxDim) {
-          return null;
-        }
-        const scale = maxDim / maxSize;
-        return resizeDataUrl(dataUrl, format, quality, scale);
+  // src/extension/lib/screenshot.ts
+  var screenshot_exports = {};
+  __export(screenshot_exports, {
+    SCREENSHOT_CAPTURE_DELAY_MS: () => SCREENSHOT_CAPTURE_DELAY_MS,
+    SCREENSHOT_MAX_BYTES: () => SCREENSHOT_MAX_BYTES,
+    SCREENSHOT_PROCESS_TIMEOUT_MS: () => SCREENSHOT_PROCESS_TIMEOUT_MS,
+    SCREENSHOT_QUALITY: () => SCREENSHOT_QUALITY,
+    SCREENSHOT_SCROLL_DELAY_MS: () => SCREENSHOT_SCROLL_DELAY_MS,
+    SCREENSHOT_TILE_MAX_DIM: () => SCREENSHOT_TILE_MAX_DIM,
+    arrayBufferToBase64: () => arrayBufferToBase64,
+    captureTabTiles: () => captureTabTiles,
+    captureVisible: () => captureVisible,
+    constrainDataUrl: () => constrainDataUrl,
+    cropDataUrl: () => cropDataUrl,
+    ensureMaxBytes: () => ensureMaxBytes,
+    estimateDataUrlBytes: () => estimateDataUrlBytes,
+    getPageMetrics: () => getPageMetrics,
+    resizeDataUrl: () => resizeDataUrl,
+    resizeDataUrlToMaxDim: () => resizeDataUrlToMaxDim,
+    scrollToPosition: () => scrollToPosition
+  });
+  function estimateDataUrlBytes(dataUrl) {
+    const commaIndex = dataUrl.indexOf(",");
+    if (commaIndex < 0) {
+      return dataUrl.length;
+    }
+    const base64 = dataUrl.slice(commaIndex + 1);
+    const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+    return Math.max(0, Math.floor(base64.length * 3 / 4) - padding);
+  }
+  function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += 1) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  async function resizeDataUrl(dataUrl, format, quality, scale) {
+    if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
+      return null;
+    }
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob);
+    const width = Math.max(1, Math.floor(bitmap.width * scale));
+    const height = Math.max(1, Math.floor(bitmap.height * scale));
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return null;
+    }
+    ctx.drawImage(bitmap, 0, 0, width, height);
+    const type = format === "jpeg" ? "image/jpeg" : "image/png";
+    const blobOut = await canvas.convertToBlob({ type, quality: format === "jpeg" ? quality / 100 : void 0 });
+    const buffer = await blobOut.arrayBuffer();
+    const base64 = arrayBufferToBase64(buffer);
+    return {
+      dataUrl: `data:${type};base64,${base64}`,
+      bytes: buffer.byteLength
+    };
+  }
+  async function resizeDataUrlToMaxDim(dataUrl, format, quality, maxDim) {
+    if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
+      return null;
+    }
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob);
+    const maxSize = Math.max(bitmap.width, bitmap.height);
+    if (!Number.isFinite(maxSize) || maxSize <= maxDim) {
+      return null;
+    }
+    const scale = maxDim / maxSize;
+    return resizeDataUrl(dataUrl, format, quality, scale);
+  }
+  async function cropDataUrl(dataUrl, format, quality, width, height, devicePixelRatio) {
+    if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
+      return dataUrl;
+    }
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob);
+    const targetWidth = Math.min(bitmap.width, Math.max(1, Math.round(width * devicePixelRatio)));
+    const targetHeight = Math.min(bitmap.height, Math.max(1, Math.round(height * devicePixelRatio)));
+    if (targetWidth === bitmap.width && targetHeight === bitmap.height) {
+      return dataUrl;
+    }
+    const canvas = new OffscreenCanvas(targetWidth, targetHeight);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return dataUrl;
+    }
+    ctx.drawImage(bitmap, 0, 0, targetWidth, targetHeight, 0, 0, targetWidth, targetHeight);
+    const type = format === "jpeg" ? "image/jpeg" : "image/png";
+    const blobOut = await canvas.convertToBlob({ type, quality: format === "jpeg" ? quality / 100 : void 0 });
+    const buffer = await blobOut.arrayBuffer();
+    const base64 = arrayBufferToBase64(buffer);
+    return `data:${type};base64,${base64}`;
+  }
+  async function ensureMaxBytes(dataUrl, format, quality, maxBytes) {
+    let currentUrl = dataUrl;
+    let currentBytes = estimateDataUrlBytes(currentUrl);
+    if (currentBytes <= maxBytes) {
+      return { dataUrl: currentUrl, bytes: currentBytes, scaled: false, oversized: false };
+    }
+    let scaled = false;
+    let attempts = 0;
+    while (currentBytes > maxBytes && attempts < 3) {
+      const scale = Math.max(0.2, Math.sqrt(maxBytes / currentBytes) * 0.95);
+      if (scale >= 0.99) {
+        break;
       }
-      async function cropDataUrl(dataUrl, format, quality, width, height, devicePixelRatio) {
-        if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
-          return dataUrl;
-        }
-        const response = await fetch(dataUrl);
-        const blob = await response.blob();
-        const bitmap = await createImageBitmap(blob);
-        const targetWidth = Math.min(bitmap.width, Math.max(1, Math.round(width * devicePixelRatio)));
-        const targetHeight = Math.min(bitmap.height, Math.max(1, Math.round(height * devicePixelRatio)));
-        if (targetWidth === bitmap.width && targetHeight === bitmap.height) {
-          return dataUrl;
-        }
-        const canvas = new OffscreenCanvas(targetWidth, targetHeight);
-        const ctx = canvas.getContext("2d");
-        if (!ctx) {
-          return dataUrl;
-        }
-        ctx.drawImage(bitmap, 0, 0, targetWidth, targetHeight, 0, 0, targetWidth, targetHeight);
-        const type = format === "jpeg" ? "image/jpeg" : "image/png";
-        const blobOut = await canvas.convertToBlob({ type, quality: format === "jpeg" ? quality / 100 : void 0 });
-        const buffer = await blobOut.arrayBuffer();
-        const base64 = arrayBufferToBase64(buffer);
-        return `data:${type};base64,${base64}`;
-      }
-      async function ensureMaxBytes(dataUrl, format, quality, maxBytes) {
-        let currentUrl = dataUrl;
-        let currentBytes = estimateDataUrlBytes(currentUrl);
-        if (currentBytes <= maxBytes) {
-          return { dataUrl: currentUrl, bytes: currentBytes, scaled: false, oversized: false };
-        }
-        let scaled = false;
-        let attempts = 0;
-        while (currentBytes > maxBytes && attempts < 3) {
-          const scale = Math.max(0.2, Math.sqrt(maxBytes / currentBytes) * 0.95);
-          if (scale >= 0.99) {
-            break;
-          }
-          const resized = await resizeDataUrl(currentUrl, format, quality, scale);
-          if (!resized) {
-            break;
-          }
-          currentUrl = resized.dataUrl;
-          currentBytes = resized.bytes;
-          scaled = true;
-          attempts += 1;
-        }
-        return {
-          dataUrl: currentUrl,
-          bytes: currentBytes,
-          scaled,
-          oversized: currentBytes > maxBytes
-        };
+      const resized = await resizeDataUrl(currentUrl, format, quality, scale);
+      if (!resized) {
+        break;
       }
-      async function constrainDataUrl(dataUrl, format, quality, maxDim, maxBytes) {
-        let currentUrl = dataUrl;
-        let currentBytes = estimateDataUrlBytes(currentUrl);
-        let scaled = false;
-        if (Number.isFinite(maxDim) && maxDim > 0) {
-          const resized = await resizeDataUrlToMaxDim(currentUrl, format, quality, maxDim);
-          if (resized) {
-            currentUrl = resized.dataUrl;
-            currentBytes = resized.bytes;
-            scaled = true;
-          }
-        }
-        if (currentBytes > maxBytes) {
-          const resized = await ensureMaxBytes(currentUrl, format, quality, maxBytes);
-          return {
-            dataUrl: resized.dataUrl,
-            bytes: resized.bytes,
-            scaled: scaled || resized.scaled,
-            oversized: resized.oversized
-          };
-        }
-        return { dataUrl: currentUrl, bytes: currentBytes, scaled, oversized: false };
+      currentUrl = resized.dataUrl;
+      currentBytes = resized.bytes;
+      scaled = true;
+      attempts += 1;
+    }
+    return {
+      dataUrl: currentUrl,
+      bytes: currentBytes,
+      scaled,
+      oversized: currentBytes > maxBytes
+    };
+  }
+  async function constrainDataUrl(dataUrl, format, quality, maxDim, maxBytes) {
+    let currentUrl = dataUrl;
+    let currentBytes = estimateDataUrlBytes(currentUrl);
+    let scaled = false;
+    if (Number.isFinite(maxDim) && maxDim > 0) {
+      const resized = await resizeDataUrlToMaxDim(currentUrl, format, quality, maxDim);
+      if (resized) {
+        currentUrl = resized.dataUrl;
+        currentBytes = resized.bytes;
+        scaled = true;
       }
-      async function captureVisible(windowId, format, quality) {
-        const options = { format };
-        if (format === "jpeg") {
-          options.quality = quality;
-        }
-        return chrome.tabs.captureVisibleTab(windowId, options);
-      }
-      async function getPageMetrics(tabId, timeoutMs, deps) {
-        const result = await deps.executeWithTimeout(tabId, timeoutMs, () => {
-          const doc = document.documentElement;
-          const body = document.body;
-          const pageWidth = Math.max(doc.scrollWidth, doc.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
-          const pageHeight = Math.max(doc.scrollHeight, doc.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
-          return {
-            pageWidth,
-            pageHeight,
-            viewportWidth: window.innerWidth,
-            viewportHeight: window.innerHeight,
-            devicePixelRatio: window.devicePixelRatio || 1,
-            scrollX: window.scrollX || window.pageXOffset || 0,
-            scrollY: window.scrollY || window.pageYOffset || 0
-          };
-        });
-        if (!result || typeof result !== "object") {
-          return null;
-        }
-        return result;
+    }
+    if (currentBytes > maxBytes) {
+      const resized = await ensureMaxBytes(currentUrl, format, quality, maxBytes);
+      return {
+        dataUrl: resized.dataUrl,
+        bytes: resized.bytes,
+        scaled: scaled || resized.scaled,
+        oversized: resized.oversized
+      };
+    }
+    return { dataUrl: currentUrl, bytes: currentBytes, scaled, oversized: false };
+  }
+  async function captureVisible(windowId, format, quality) {
+    const options = { format };
+    if (format === "jpeg") {
+      options.quality = quality;
+    }
+    try {
+      return await chrome.tabs.captureVisibleTab(windowId, options);
+    } catch {
+      await new Promise((r) => setTimeout(r, 500));
+      return chrome.tabs.captureVisibleTab(windowId, options);
+    }
+  }
+  async function getPageMetrics(tabId, timeoutMs, deps) {
+    const result = await deps.executeWithTimeout(tabId, timeoutMs, () => {
+      const doc = document.documentElement;
+      const body = document.body;
+      const pageWidth = Math.max(
+        doc.scrollWidth,
+        doc.clientWidth,
+        body ? body.scrollWidth : 0,
+        body ? body.clientWidth : 0
+      );
+      const pageHeight = Math.max(
+        doc.scrollHeight,
+        doc.clientHeight,
+        body ? body.scrollHeight : 0,
+        body ? body.clientHeight : 0
+      );
+      return {
+        pageWidth,
+        pageHeight,
+        viewportWidth: window.innerWidth,
+        viewportHeight: window.innerHeight,
+        devicePixelRatio: window.devicePixelRatio || 1,
+        scrollX: window.scrollX || window.pageXOffset || 0,
+        scrollY: window.scrollY || window.pageYOffset || 0
+      };
+    });
+    if (!result || typeof result !== "object") {
+      return null;
+    }
+    return result;
+  }
+  async function scrollToPosition(tabId, timeoutMs, x, y, deps) {
+    const result = await deps.executeWithTimeout(tabId, timeoutMs, (scrollX, scrollY) => {
+      window.scrollTo(scrollX, scrollY);
+      return {
+        scrollX: window.scrollX || window.pageXOffset || 0,
+        scrollY: window.scrollY || window.pageYOffset || 0
+      };
+    }, [x, y]);
+    if (!result || typeof result !== "object") {
+      return null;
+    }
+    return result;
+  }
+  async function captureTabTiles(tab, options, deps) {
+    const tabId = tab.tabId;
+    const windowId = tab.windowId;
+    if (!Number.isFinite(tabId) || !Number.isFinite(windowId)) {
+      throw new Error("Missing tab/window id");
+    }
+    const metrics = await getPageMetrics(tabId, SCREENSHOT_PROCESS_TIMEOUT_MS, deps);
+    if (!metrics) {
+      throw new Error("Failed to read page metrics");
+    }
+    const pageWidth = Number(metrics.pageWidth);
+    const pageHeight = Number(metrics.pageHeight);
+    const viewportWidth = Number(metrics.viewportWidth);
+    const viewportHeight = Number(metrics.viewportHeight);
+    const devicePixelRatio = Number(metrics.devicePixelRatio) || 1;
+    const startScrollX = Number(metrics.scrollX) || 0;
+    const startScrollY = Number(metrics.scrollY) || 0;
+    if (!Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight)) {
+      throw new Error("Viewport size unavailable");
+    }
+    const tiles = [];
+    let tileIndex = 0;
+    const captureTile = async (x, y, width, height, total) => {
+      if (tileIndex > 0) {
+        await deps.delay(SCREENSHOT_CAPTURE_DELAY_MS);
       }
-      async function scrollToPosition(tabId, timeoutMs, x, y, deps) {
-        const result = await deps.executeWithTimeout(tabId, timeoutMs, (scrollX, scrollY) => {
-          window.scrollTo(scrollX, scrollY);
-          return {
-            scrollX: window.scrollX || window.pageXOffset || 0,
-            scrollY: window.scrollY || window.pageYOffset || 0
-          };
-        }, [x, y]);
-        if (!result || typeof result !== "object") {
-          return null;
-        }
-        return result;
+      const rawDataUrl = await captureVisible(windowId, options.format, options.quality);
+      if (!rawDataUrl) {
+        throw new Error("Capture failed");
       }
-      async function captureTabTiles(tab, options, deps) {
-        const tabId = tab.tabId;
-        const windowId = tab.windowId;
-        if (!Number.isFinite(tabId) || !Number.isFinite(windowId)) {
-          throw new Error("Missing tab/window id");
-        }
-        const metrics = await getPageMetrics(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, deps);
-        if (!metrics) {
-          throw new Error("Failed to read page metrics");
-        }
-        const pageWidth = Number(metrics.pageWidth);
-        const pageHeight = Number(metrics.pageHeight);
-        const viewportWidth = Number(metrics.viewportWidth);
-        const viewportHeight = Number(metrics.viewportHeight);
-        const devicePixelRatio = Number(metrics.devicePixelRatio) || 1;
-        const startScrollX = Number(metrics.scrollX) || 0;
-        const startScrollY = Number(metrics.scrollY) || 0;
-        if (!Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight)) {
-          throw new Error("Viewport size unavailable");
-        }
-        const tiles = [];
-        let tileIndex = 0;
-        const captureTile = async (x, y, width, height, total) => {
-          if (tileIndex > 0) {
-            await deps.delay(exports.SCREENSHOT_CAPTURE_DELAY_MS);
-          }
-          const rawDataUrl = await captureVisible(windowId, options.format, options.quality);
-          if (!rawDataUrl) {
-            throw new Error("Capture failed");
-          }
-          const croppedUrl = await cropDataUrl(rawDataUrl, options.format, options.quality, width, height, devicePixelRatio);
-          const sizeResult = await constrainDataUrl(croppedUrl, options.format, options.quality, options.tileMaxDim, options.maxBytes);
-          tiles.push({
-            index: tileIndex,
-            total,
-            x,
-            y,
-            width,
-            height,
-            scale: devicePixelRatio,
-            format: options.format,
-            bytes: sizeResult.bytes,
-            scaled: sizeResult.scaled,
-            oversized: sizeResult.oversized,
-            dataUrl: sizeResult.dataUrl
-          });
-          tileIndex += 1;
-        };
-        if (options.mode === "viewport") {
-          await captureTile(startScrollX, startScrollY, viewportWidth, viewportHeight, 1);
-          return tiles;
-        }
-        const stepX = viewportWidth;
-        const stepY = Math.min(viewportHeight, options.tileMaxDim);
-        const maxX = viewportWidth;
-        const maxY = Math.max(viewportHeight, pageHeight);
-        const tileCount = Math.ceil(maxX / stepX) * Math.ceil(maxY / stepY);
-        for (let y = 0; y < maxY; y += stepY) {
-          for (let x = 0; x < maxX; x += stepX) {
-            await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, x, y, deps);
-            await deps.delay(exports.SCREENSHOT_SCROLL_DELAY_MS);
-            const width = Math.min(stepX, maxX - x);
-            const height = Math.min(stepY, maxY - y);
-            try {
-              await captureTile(x, y, width, height, tileCount);
-            } catch (err) {
-              const message = err instanceof Error ? err.message : "capture_failed";
-              if (message.includes("MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND")) {
-                await deps.delay(1e3);
-                await captureTile(x, y, width, height, tileCount);
-              } else {
-                throw err;
-              }
-            }
+      const croppedUrl = await cropDataUrl(
+        rawDataUrl,
+        options.format,
+        options.quality,
+        width,
+        height,
+        devicePixelRatio
+      );
+      const sizeResult = await constrainDataUrl(
+        croppedUrl,
+        options.format,
+        options.quality,
+        options.tileMaxDim,
+        options.maxBytes
+      );
+      tiles.push({
+        index: tileIndex,
+        total,
+        x,
+        y,
+        width,
+        height,
+        scale: devicePixelRatio,
+        format: options.format,
+        bytes: sizeResult.bytes,
+        scaled: sizeResult.scaled,
+        oversized: sizeResult.oversized,
+        dataUrl: sizeResult.dataUrl
+      });
+      tileIndex += 1;
+    };
+    if (options.mode === "viewport") {
+      await captureTile(startScrollX, startScrollY, viewportWidth, viewportHeight, 1);
+      return tiles;
+    }
+    const stepX = viewportWidth;
+    const stepY = Math.min(viewportHeight, options.tileMaxDim);
+    const maxX = viewportWidth;
+    const maxY = Math.max(viewportHeight, pageHeight);
+    const tileCount = Math.ceil(maxX / stepX) * Math.ceil(maxY / stepY);
+    for (let y = 0; y < maxY; y += stepY) {
+      for (let x = 0; x < maxX; x += stepX) {
+        await scrollToPosition(tabId, SCREENSHOT_PROCESS_TIMEOUT_MS, x, y, deps);
+        await deps.delay(SCREENSHOT_SCROLL_DELAY_MS);
+        const width = Math.min(stepX, maxX - x);
+        const height = Math.min(stepY, maxY - y);
+        try {
+          await captureTile(x, y, width, height, tileCount);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "capture_failed";
+          if (message.includes("MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND")) {
+            await deps.delay(1e3);
+            await captureTile(x, y, width, height, tileCount);
+          } else {
+            throw err;
           }
         }
-        await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps);
-        return tiles;
       }
     }
+    await scrollToPosition(tabId, SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps);
+    return tiles;
+  }
+  var SCREENSHOT_TILE_MAX_DIM, SCREENSHOT_MAX_BYTES, SCREENSHOT_QUALITY, SCREENSHOT_SCROLL_DELAY_MS, SCREENSHOT_CAPTURE_DELAY_MS, SCREENSHOT_PROCESS_TIMEOUT_MS;
+  var init_screenshot = __esm({
+    "src/extension/lib/screenshot.ts"() {
+      SCREENSHOT_TILE_MAX_DIM = 2e3;
+      SCREENSHOT_MAX_BYTES = 2e6;
+      SCREENSHOT_QUALITY = 80;
+      SCREENSHOT_SCROLL_DELAY_MS = 150;
+      SCREENSHOT_CAPTURE_DELAY_MS = 350;
+      SCREENSHOT_PROCESS_TIMEOUT_MS = 8e3;
+    }
   });
 
-  // dist/extension/lib/content.js
-  var require_content = __commonJS({
-    "dist/extension/lib/content.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.delay = delay2;
-      exports.executeWithTimeout = executeWithTimeout2;
-      exports.extractPageMeta = extractPageMeta;
-      exports.extractSelectorSignal = extractSelectorSignal;
-      function delay2(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-      }
-      async function executeWithTimeout2(tabId, timeoutMs, func, args = []) {
-        const execPromise = chrome.scripting.executeScript({
-          target: { tabId },
-          func,
-          args
-        });
-        const timeoutPromise = new Promise((resolve) => {
-          const handle = setTimeout(() => {
-            clearTimeout(handle);
-            resolve(null);
-          }, timeoutMs);
-        });
-        try {
-          const result = await Promise.race([execPromise, timeoutPromise]);
-          if (!result || !Array.isArray(result)) {
-            return null;
-          }
-          const [{ result: value }] = result;
-          return value ?? null;
-        } catch {
-          return null;
-        }
+  // src/extension/lib/content.ts
+  var content_exports = {};
+  __export(content_exports, {
+    delay: () => delay,
+    executeWithTimeout: () => executeWithTimeout,
+    executeWithTimeoutDetailed: () => executeWithTimeoutDetailed,
+    extractPageHtml: () => extractPageHtml,
+    extractPageMarkdown: () => extractPageMarkdown,
+    extractPageMeta: () => extractPageMeta,
+    extractSelectorSignal: () => extractSelectorSignal,
+    probePageQuiescence: () => probePageQuiescence
+  });
+  function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function executeWithTimeout(tabId, timeoutMs, func, args = []) {
+    const execPromise = chrome.scripting.executeScript({
+      target: { tabId },
+      func,
+      args
+    });
+    const timeoutPromise = new Promise((resolve) => {
+      const handle = setTimeout(() => {
+        clearTimeout(handle);
+        resolve(null);
+      }, timeoutMs);
+    });
+    try {
+      const result = await Promise.race([execPromise, timeoutPromise]);
+      if (!result || !Array.isArray(result)) {
+        return null;
       }
-      async function extractPageMeta(tabId, timeoutMs, descriptionMaxLength) {
-        const result = await executeWithTimeout2(tabId, timeoutMs, () => {
-          const pickContent = (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) {
-              return "";
+      const [{ result: value }] = result;
+      return value ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async function executeWithTimeoutDetailed(tabId, timeoutMs, func, args = []) {
+    const execPromise = chrome.scripting.executeScript({
+      target: { tabId },
+      func,
+      args
+    }).then((result) => {
+      if (!result || !Array.isArray(result)) {
+        return { kind: "ok", value: null };
+      }
+      const [{ result: value }] = result;
+      return { kind: "ok", value: value ?? null };
+    }).catch((err) => ({
+      kind: "error",
+      message: err instanceof Error ? err.message : String(err)
+    }));
+    const timeoutPromise = new Promise((resolve) => {
+      const handle = setTimeout(() => {
+        clearTimeout(handle);
+        resolve({ kind: "timeout" });
+      }, timeoutMs);
+    });
+    return Promise.race([execPromise, timeoutPromise]);
+  }
+  async function extractPageMeta(tabId, timeoutMs, descriptionMaxLength) {
+    const result = await executeWithTimeout(tabId, timeoutMs, () => {
+      const pickContent = (selector) => {
+        const el = document.querySelector(selector);
+        if (!el) {
+          return "";
+        }
+        const content2 = el.getAttribute("content") || el.textContent || "";
+        return content2.trim();
+      };
+      const description = pickContent("meta[name='description']") || pickContent("meta[property='og:description']") || pickContent("meta[name='twitter:description']");
+      const h1 = document.querySelector("h1");
+      const h1Text = h1 ? h1.textContent?.trim() : "";
+      return {
+        description: description.replace(/\s+/g, " ").trim(),
+        h1: (h1Text || "").replace(/\s+/g, " ").trim()
+      };
+    });
+    if (!result || typeof result !== "object") {
+      return null;
+    }
+    const meta = result;
+    return {
+      description: (meta.description || "").slice(0, descriptionMaxLength),
+      h1: (meta.h1 || "").slice(0, descriptionMaxLength)
+    };
+  }
+  async function extractPageMarkdown(tabId, timeoutMs, maxHtmlChars) {
+    const result = await executeWithTimeout(tabId, timeoutMs, (cap) => {
+      const raw = document.documentElement?.outerHTML || "";
+      return raw.length > cap ? raw.slice(0, cap) : raw;
+    }, [maxHtmlChars]);
+    return typeof result === "string" ? result : "";
+  }
+  function injectionStatus(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("cannot access") || lower.includes("permission") || lower.includes("extensions gallery")) {
+      return "PROTECTED";
+    }
+    return "INJECTION_FAILED";
+  }
+  async function extractPageHtml(tabId, timeoutMs, maxHtmlChars) {
+    const result = await executeWithTimeoutDetailed(tabId, timeoutMs, (cap) => {
+      const raw = document.documentElement?.outerHTML || "";
+      const text = document.body?.innerText || document.documentElement?.textContent || "";
+      return {
+        html: raw.length > cap ? raw.slice(0, cap) : raw,
+        sourceHtmlChars: raw.length,
+        sourceTextChars: text.length,
+        documentReadyState: document.readyState,
+        truncatedHtml: raw.length > cap
+      };
+    }, [maxHtmlChars]);
+    if (result.kind === "timeout") {
+      return {
+        status: "TIMED_OUT",
+        html: "",
+        sourceHtmlChars: 0,
+        sourceTextChars: 0,
+        documentReadyState: null,
+        truncatedHtml: false,
+        error: `Timed out after ${timeoutMs}ms`
+      };
+    }
+    if (result.kind === "error") {
+      return {
+        status: injectionStatus(result.message),
+        html: "",
+        sourceHtmlChars: 0,
+        sourceTextChars: 0,
+        documentReadyState: null,
+        truncatedHtml: false,
+        error: result.message
+      };
+    }
+    if (!result.value) {
+      return {
+        status: "EXTRACTION_FAILED",
+        html: "",
+        sourceHtmlChars: 0,
+        sourceTextChars: 0,
+        documentReadyState: null,
+        truncatedHtml: false,
+        error: "Content script returned no page HTML payload"
+      };
+    }
+    const status = result.value.documentReadyState === "loading" ? "NOT_LOADED" : "READ";
+    return {
+      status,
+      ...result.value,
+      error: null
+    };
+  }
+  async function probePageQuiescence(tabId, timeoutMs, sampleWindowMs) {
+    const result = await executeWithTimeoutDetailed(tabId, timeoutMs, async (rawWindowMs) => {
+      const startedAt = Date.now();
+      const windowMs = Math.max(50, Math.min(Number(rawWindowMs) || 350, 1500));
+      const htmlCap = 25e4;
+      const sample = () => {
+        const root = document.documentElement;
+        const bodyText = document.body?.innerText || root?.textContent || "";
+        const html = root?.outerHTML || "";
+        const resources = typeof performance !== "undefined" && typeof performance.getEntriesByType === "function" ? performance.getEntriesByType("resource").length : null;
+        return {
+          textChars: bodyText.length,
+          htmlChars: Math.min(html.length, htmlCap),
+          domElements: document.getElementsByTagName("*").length,
+          resourceCount: resources
+        };
+      };
+      const waitForIdleWindow = () => new Promise((resolve) => {
+        const win = window;
+        const done = () => setTimeout(resolve, windowMs);
+        if (typeof win.requestIdleCallback === "function") {
+          let resolved = false;
+          const finish = () => {
+            if (resolved) {
+              return;
             }
-            const content2 = el.getAttribute("content") || el.textContent || "";
-            return content2.trim();
+            resolved = true;
+            done();
           };
-          const description = pickContent("meta[name='description']") || pickContent("meta[property='og:description']") || pickContent("meta[name='twitter:description']");
-          const h1 = document.querySelector("h1");
-          const h1Text = h1 ? h1.textContent?.trim() : "";
+          const fallback = setTimeout(finish, windowMs + 100);
+          win.requestIdleCallback(() => {
+            clearTimeout(fallback);
+            finish();
+          }, { timeout: windowMs });
+          return;
+        }
+        setTimeout(resolve, windowMs);
+      });
+      try {
+        const readyState = document.readyState;
+        if (readyState !== "interactive" && readyState !== "complete") {
           return {
-            description: description.replace(/\s+/g, " ").trim(),
-            h1: (h1Text || "").replace(/\s+/g, " ").trim()
+            quiet: false,
+            reason: "not-ready",
+            documentReadyState: readyState,
+            before: null,
+            after: null,
+            elapsedMs: Date.now() - startedAt,
+            error: null
           };
-        });
-        if (!result || typeof result !== "object") {
-          return null;
         }
-        const meta = result;
+        const before = sample();
+        await waitForIdleWindow();
+        const after = sample();
+        const stable = before.textChars === after.textChars && before.htmlChars === after.htmlChars && before.domElements === after.domElements && before.resourceCount === after.resourceCount;
+        return {
+          quiet: stable,
+          reason: stable ? "stable" : "changed",
+          documentReadyState: document.readyState,
+          before,
+          after,
+          elapsedMs: Date.now() - startedAt,
+          error: null
+        };
+      } catch (err) {
         return {
-          description: (meta.description || "").slice(0, descriptionMaxLength),
-          h1: (meta.h1 || "").slice(0, descriptionMaxLength)
+          quiet: false,
+          reason: "probe-error",
+          documentReadyState: typeof document !== "undefined" ? document.readyState : null,
+          before: null,
+          after: null,
+          elapsedMs: Date.now() - startedAt,
+          error: err instanceof Error ? err.message : String(err)
         };
       }
-      async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLength) {
-        if (!specs.length) {
-          return null;
+    }, [sampleWindowMs]);
+    if (result.kind === "timeout") {
+      return {
+        quiet: false,
+        reason: "timed-out",
+        documentReadyState: null,
+        before: null,
+        after: null,
+        elapsedMs: timeoutMs,
+        error: `Timed out after ${timeoutMs}ms`
+      };
+    }
+    if (result.kind === "error") {
+      return {
+        quiet: false,
+        reason: "injection-error",
+        documentReadyState: null,
+        before: null,
+        after: null,
+        elapsedMs: 0,
+        error: result.message
+      };
+    }
+    return result.value ?? {
+      quiet: false,
+      reason: "no-result",
+      documentReadyState: null,
+      before: null,
+      after: null,
+      elapsedMs: 0,
+      error: "Content script returned no quiescence probe payload"
+    };
+  }
+  async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLength) {
+    if (!specs.length) {
+      return null;
+    }
+    const result = await executeWithTimeout(tabId, timeoutMs, (rawSpecs, maxLen) => {
+      const values = {};
+      const missing = [];
+      const errors = {};
+      const hints = {};
+      const stringCap = typeof maxLen === "number" && maxLen > 0 ? maxLen : 500;
+      const htmlCap = typeof maxLen === "number" && maxLen > 0 ? maxLen : 4096;
+      const normalizeStringValue = (value, cap) => value.replace(/\s+/g, " ").trim().slice(0, cap);
+      for (const raw of rawSpecs) {
+        const selector = typeof raw.selector === "string" ? raw.selector : "";
+        if (!selector) {
+          continue;
+        }
+        const name = typeof raw.name === "string" && raw.name ? raw.name : selector;
+        const attr = typeof raw.attr === "string" ? raw.attr : "text";
+        const all = Boolean(raw.all);
+        const text = typeof raw.text === "string" ? raw.text.trim() : "";
+        const textMode = typeof raw.textMode === "string" ? raw.textMode.trim().toLowerCase() : "";
+        const normalizedTextMode = textMode === "includes" ? "contains" : textMode;
+        const textModes = /* @__PURE__ */ new Set(["", "contains", "exact", "starts-with"]);
+        const styleProps = Array.isArray(raw.styleProps) ? raw.styleProps.filter((prop) => typeof prop === "string").map((prop) => prop.trim()).filter(Boolean) : [];
+        if (!textModes.has(normalizedTextMode)) {
+          errors[name] = `Unsupported textMode: ${textMode || "unknown"}`;
+          hints[name] = "Use textMode: contains | exact | starts-with";
+          continue;
         }
-        const result = await executeWithTimeout2(tabId, timeoutMs, (rawSpecs, maxLen) => {
-          const values = {};
-          const missing = [];
-          const errors = {};
-          const hints = {};
-          for (const raw of rawSpecs) {
-            const selector = typeof raw.selector === "string" ? raw.selector : "";
-            if (!selector) {
-              continue;
+        try {
+          const elements = Array.from(document.querySelectorAll(selector));
+          const matchesText = (el) => {
+            if (!text) {
+              return true;
             }
-            const name = typeof raw.name === "string" && raw.name ? raw.name : selector;
-            const attr = typeof raw.attr === "string" ? raw.attr : "text";
-            const all = Boolean(raw.all);
-            const text = typeof raw.text === "string" ? raw.text.trim() : "";
-            const textMode = typeof raw.textMode === "string" ? raw.textMode.trim().toLowerCase() : "";
-            const normalizedTextMode = textMode === "includes" ? "contains" : textMode;
-            const textModes = /* @__PURE__ */ new Set(["", "contains", "exact", "starts-with"]);
-            if (!textModes.has(normalizedTextMode)) {
-              errors[name] = `Unsupported textMode: ${textMode || "unknown"}`;
-              hints[name] = "Use textMode: contains | exact | starts-with";
-              continue;
+            const content2 = (el.textContent || "").replace(/\s+/g, " ").trim();
+            if (normalizedTextMode === "exact") {
+              return content2 === text;
             }
-            try {
-              const elements = Array.from(document.querySelectorAll(selector));
-              if (!elements.length) {
-                missing.push(name);
-                if (selector.includes(":contains(")) {
-                  hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
-                } else {
-                  hints[name] = "No matches found; capture a screenshot for context or adjust the selector.";
-                }
-                continue;
+            if (normalizedTextMode === "starts-with") {
+              return content2.startsWith(text);
+            }
+            return content2.includes(text);
+          };
+          const filtered = text ? elements.filter(matchesText) : elements;
+          if (attr === "count") {
+            values[name] = filtered.length;
+            continue;
+          }
+          if (!elements.length) {
+            missing.push(name);
+            if (selector.includes(":contains(")) {
+              hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
+            } else {
+              hints[name] = "No matches found; capture a screenshot for context or adjust the selector.";
+            }
+            continue;
+          }
+          if (!filtered.length) {
+            missing.push(name);
+            hints[name] = "Selector matched elements, but none matched the text filter; capture a screenshot for context or adjust text/textMode.";
+            continue;
+          }
+          const getValue = (el) => {
+            if (attr === "text") {
+              return normalizeStringValue(el.textContent || "", stringCap);
+            }
+            if (attr === "html") {
+              return normalizeStringValue(el.outerHTML || "", htmlCap);
+            }
+            if (attr === "href-url" || attr === "src-url") {
+              const rawValue = el.getAttribute(attr === "href-url" ? "href" : "src") || "";
+              if (!rawValue) {
+                return "";
               }
-              const matchesText = (el) => {
-                if (!text) {
-                  return true;
+              try {
+                const resolved = new URL(rawValue, document.baseURI);
+                if (resolved.protocol === "http:" || resolved.protocol === "https:") {
+                  return normalizeStringValue(resolved.toString(), stringCap);
                 }
-                const content2 = (el.textContent || "").replace(/\s+/g, " ").trim();
-                if (normalizedTextMode === "exact") {
-                  return content2 === text;
-                }
-                if (normalizedTextMode === "starts-with") {
-                  return content2.startsWith(text);
-                }
-                return content2.includes(text);
-              };
-              const filtered = text ? elements.filter(matchesText) : elements;
-              if (!filtered.length) {
-                missing.push(name);
-                hints[name] = "Selector matched elements, but none matched the text filter; capture a screenshot for context or adjust text/textMode.";
-                continue;
+                return "";
+              } catch {
+                return "";
               }
-              const getValue = (el) => {
-                let value = "";
-                if (attr === "text") {
-                  value = el.textContent || "";
-                } else if (attr === "href-url" || attr === "src-url") {
-                  const rawValue = el.getAttribute(attr === "href-url" ? "href" : "src") || "";
-                  if (!rawValue) {
-                    value = "";
-                  } else {
-                    try {
-                      const resolved = new URL(rawValue, document.baseURI);
-                      if (resolved.protocol === "http:" || resolved.protocol === "https:") {
-                        value = resolved.toString();
-                      } else {
-                        value = "";
-                      }
-                    } catch {
-                      value = "";
-                    }
-                  }
-                } else {
-                  value = el.getAttribute(attr) || "";
-                }
-                return value.replace(/\s+/g, " ").trim().slice(0, maxLen);
+            }
+            if (attr === "value") {
+              if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+                return el.value;
+              }
+              return null;
+            }
+            if (attr === "box") {
+              const rect = el.getBoundingClientRect();
+              return {
+                x: rect.x,
+                y: rect.y,
+                width: rect.width,
+                height: rect.height,
+                top: rect.top,
+                right: rect.right,
+                bottom: rect.bottom,
+                left: rect.left
               };
-              if (all) {
-                values[name] = filtered.map(getValue).filter((val) => val.length > 0);
-              } else {
-                values[name] = getValue(filtered[0]);
+            }
+            if (attr === "styles") {
+              if (!styleProps.length) {
+                return {};
               }
-            } catch (err) {
-              const message = err instanceof Error ? err.message : "selector_error";
-              errors[name] = message;
-              if (selector.includes(":contains(")) {
-                hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
-              } else {
-                hints[name] = "Selector failed to evaluate; capture a screenshot for context or adjust the selector.";
+              const computed = window.getComputedStyle(el);
+              const selected = {};
+              for (const prop of styleProps) {
+                selected[prop] = computed.getPropertyValue(prop);
               }
+              return selected;
+            }
+            if (attr === "visible") {
+              const computed = window.getComputedStyle(el);
+              const rect = el.getBoundingClientRect();
+              const styleVisible = computed.display !== "none" && computed.visibility !== "hidden" && computed.opacity !== "0";
+              const hasRenderedBox = rect.width > 0 || rect.height > 0;
+              return styleVisible && hasRenderedBox;
+            }
+            if (attr === "enabled") {
+              const candidate = el;
+              return candidate.disabled !== true && el.getAttribute("aria-disabled") !== "true";
             }
+            if (attr === "checked") {
+              if (el instanceof HTMLInputElement) {
+                return el.checked;
+              }
+              return el.getAttribute("aria-checked") === "true";
+            }
+            return normalizeStringValue(el.getAttribute(attr) || "", stringCap);
+          };
+          if (attr === "box") {
+            values[name] = getValue(filtered[0]);
+            continue;
+          }
+          if (all) {
+            values[name] = filtered.map(getValue).filter((val) => typeof val !== "string" || val.length > 0);
+          } else {
+            values[name] = getValue(filtered[0]);
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "selector_error";
+          errors[name] = message;
+          if (selector.includes(":contains(")) {
+            hints[name] = "CSS :contains() is not supported; use selector text filters or a different selector.";
+          } else {
+            hints[name] = "Selector failed to evaluate; capture a screenshot for context or adjust the selector.";
           }
-          return { values, missing, errors, hints };
-        }, [specs, selectorValueMaxLength]);
-        if (!result || typeof result !== "object") {
-          return null;
         }
-        return result;
       }
+      return { values, missing, errors, hints };
+    }, [specs, selectorValueMaxLength]);
+    if (!result || typeof result !== "object") {
+      return null;
+    }
+    return result;
+  }
+  var init_content = __esm({
+    "src/extension/lib/content.ts"() {
     }
   });
 
-  // dist/extension/background.js
+  // src/extension/background.ts
   var HOST_NAME = "com.erwinkroon.tabctl";
   var manifest = chrome.runtime.getManifest();
   var MANIFEST_VERSION = manifest.version || "0.0.0";
@@ -469,36 +780,128 @@
     dirty: parsed.dirty
   };
   var KEEPALIVE_ALARM = "tabctl-keepalive";
+  var RECONNECT_ALARM = "tabctl-reconnect";
   var KEEPALIVE_INTERVAL_MINUTES = 1;
-  var screenshot = require_screenshot();
-  var content = require_content();
-  var { delay, executeWithTimeout } = content;
+  var BROWSER_STATE_SYNC_DEBOUNCE_MS = 750;
+  var ACTIVE_PAGE_CACHE_DEBOUNCE_MS = 1e3;
+  var ACTIVE_PAGE_CACHE_TIMEOUT_MS = 5e3;
+  var MAX_PAGE_HTML_CHARS = 10 * 1024 * 1024;
+  var ACTIVE_PAGE_CACHE_MAX_HTML_CHARS = MAX_PAGE_HTML_CHARS;
+  var ACTIVE_PAGE_CACHE_QUIESCENT_DELAY_MS = 6e3;
+  var ACTIVE_PAGE_CACHE_QUIESCENT_RETRY_MS = 1e3;
+  var ACTIVE_PAGE_CACHE_QUIESCENT_TIMEOUT_MS = 2500;
+  var ACTIVE_PAGE_CACHE_QUIESCENT_SAMPLE_MS = 350;
+  var ACTIVE_PAGE_CACHE_QUIESCENT_COOLDOWN_MS = 3e4;
+  var ACTIVE_PAGE_CACHE_STATUS_TIMEOUT_MS = 3e4;
+  var CACHE_AVAILABLE_BADGE_TEXT = "C";
+  var CACHE_AVAILABLE_BADGE_COLOR = "#2da44e";
+  var RECONNECT_INITIAL_DELAY_MS = 250;
+  var RECONNECT_MAX_DELAY_MS = 3e4;
+  var RECONNECT_ALARM_MIN_DELAY_MS = 3e4;
+  var RECONNECT_STABLE_RESET_MS = 5e3;
+  var screenshot = (init_screenshot(), __toCommonJS(screenshot_exports));
+  var content = (init_content(), __toCommonJS(content_exports));
+  var { delay: delay2, executeWithTimeout: executeWithTimeout2 } = content;
   var DESCRIPTION_MAX_LENGTH = 250;
   function requireFiniteId(value, name) {
     const n = Number(value);
-    if (!Number.isFinite(n))
-      throw new Error(`${name} must be a finite number, got: ${String(value)}`);
+    if (!Number.isFinite(n)) throw new Error(`${name} must be a finite number, got: ${String(value)}`);
     return n;
   }
   var state = {
     port: null,
-    lastFocused: {},
-    lastFocusedLoaded: false
+    reconnectTimer: null,
+    reconnectStableTimer: null,
+    reconnectAttempt: 0
+  };
+  var browserState = {
+    nextId: 1,
+    syncTimer: null,
+    pendingEvents: [],
+    incognitoWindowIds: /* @__PURE__ */ new Set(),
+    incognitoTabIds: /* @__PURE__ */ new Set(),
+    incognitoGroupIds: /* @__PURE__ */ new Set()
+  };
+  var activePageCache = {
+    nextId: 1,
+    timer: null,
+    pending: null,
+    quiescentTimer: null,
+    quiescentPending: null,
+    inFlightKeys: /* @__PURE__ */ new Set(),
+    lastCapturedKey: null,
+    lastQuiescentCapturedKey: null,
+    lastQuiescentCapturedAt: 0,
+    statusRequests: /* @__PURE__ */ new Map()
   };
   function log(...args) {
     console.log("[tabctl]", ...args);
   }
-  function sendResponse(id, ok, payload) {
-    if (!state.port) {
+  function reconnectDelayMs(attempt) {
+    return Math.min(RECONNECT_INITIAL_DELAY_MS * 2 ** attempt, RECONNECT_MAX_DELAY_MS);
+  }
+  function clearReconnectTimer() {
+    if (!state.reconnectTimer) {
+      return;
+    }
+    clearTimeout(state.reconnectTimer);
+    state.reconnectTimer = null;
+  }
+  function clearReconnectAlarm() {
+    chrome.alarms.clear(RECONNECT_ALARM);
+  }
+  function clearReconnectStableTimer() {
+    if (!state.reconnectStableTimer) {
       return;
     }
-    if (ok) {
-      const data = typeof payload === "object" && payload !== null ? payload : { payload };
-      state.port.postMessage({ id, ok: true, data });
+    clearTimeout(state.reconnectStableTimer);
+    state.reconnectStableTimer = null;
+  }
+  function scheduleReconnect(reason) {
+    if (state.port || state.reconnectTimer) {
+      return;
+    }
+    const attempt = state.reconnectAttempt;
+    const delayMs = reconnectDelayMs(attempt);
+    state.reconnectAttempt += 1;
+    log("Scheduling native host reconnect", { reason, delayMs, attempt });
+    chrome.alarms.create(RECONNECT_ALARM, {
+      delayInMinutes: Math.max(delayMs, RECONNECT_ALARM_MIN_DELAY_MS) / 6e4
+    });
+    state.reconnectTimer = setTimeout(() => {
+      state.reconnectTimer = null;
+      clearReconnectAlarm();
+      connectNative();
+    }, delayMs);
+  }
+  function resetReconnectBackoffAfterStablePort(port) {
+    clearReconnectStableTimer();
+    state.reconnectStableTimer = setTimeout(() => {
+      state.reconnectStableTimer = null;
+      if (state.port === port) {
+        state.reconnectAttempt = 0;
+      }
+    }, RECONNECT_STABLE_RESET_MS);
+  }
+  function ensureKeepaliveAlarm() {
+    chrome.alarms.create(KEEPALIVE_ALARM, { periodInMinutes: KEEPALIVE_INTERVAL_MINUTES });
+  }
+  function sendResponse(port, id, ok, payload) {
+    if (!port) {
+      log("dropping response because native port is unavailable", { id, ok });
       return;
     }
-    const error = payload instanceof Error ? { message: payload.message, stack: payload.stack } : payload;
-    state.port.postMessage({ id, ok: false, error });
+    try {
+      if (ok) {
+        const data = typeof payload === "object" && payload !== null ? payload : { payload };
+        port.postMessage({ id, ok: true, data });
+        return;
+      }
+      const error = payload instanceof Error ? { message: payload.message, stack: payload.stack } : payload;
+      port.postMessage({ id, ok: false, error });
+    } catch (error) {
+      log("failed to send native response", { id, ok, error });
+    }
   }
   function connectNative() {
     if (state.port) {
@@ -506,8 +909,16 @@
     }
     try {
       const port = chrome.runtime.connectNative(HOST_NAME);
+      clearReconnectTimer();
+      clearReconnectAlarm();
       state.port = port;
-      port.onMessage.addListener(handleNativeMessage);
+      resetReconnectBackoffAfterStablePort(port);
+      port.onMessage.addListener((message) => {
+        if (handlePageCacheStatusMessage(message)) {
+          return;
+        }
+        void handleNativeMessage(port, message);
+      });
       port.onDisconnect.addListener(() => {
         const lastError = chrome.runtime.lastError;
         if (lastError) {
@@ -515,62 +926,617 @@
         } else {
           log("Native host disconnected");
         }
-        state.port = null;
+        if (state.port === port) {
+          state.port = null;
+        }
+        activePageCache.statusRequests.clear();
+        clearReconnectStableTimer();
+        scheduleReconnect("disconnect");
       });
       log("Native host connected");
+      queueBrowserStateSync("startup");
+      void refreshActivePageCacheIndicator("connectNative");
     } catch (error) {
       log("Native host connection failed", error);
+      scheduleReconnect("connect-failed");
     }
   }
-  chrome.runtime.onInstalled.addListener(() => {
-    connectNative();
-    chrome.alarms.create(KEEPALIVE_ALARM, { periodInMinutes: KEEPALIVE_INTERVAL_MINUTES });
-  });
-  chrome.runtime.onStartup.addListener(() => {
-    connectNative();
-    chrome.alarms.create(KEEPALIVE_ALARM, { periodInMinutes: KEEPALIVE_INTERVAL_MINUTES });
-  });
-  chrome.alarms.onAlarm.addListener((alarm) => {
-    if (alarm.name === KEEPALIVE_ALARM) {
+  function nextBrowserStateId() {
+    const id = browserState.nextId;
+    browserState.nextId += 1;
+    return `browser-state-${Date.now()}-${id}`;
+  }
+  function nextActivePageCacheId() {
+    const id = activePageCache.nextId;
+    activePageCache.nextId += 1;
+    return `page-cache-capture-${Date.now()}-${id}`;
+  }
+  function nextActivePageCacheStatusId() {
+    const id = activePageCache.nextId;
+    activePageCache.nextId += 1;
+    return `page-cache-status-${Date.now()}-${id}`;
+  }
+  function trackPageCacheStatusRequest(id, tabId, url) {
+    activePageCache.statusRequests.set(id, { tabId, url });
+    setTimeout(() => {
+      activePageCache.statusRequests.delete(id);
+    }, ACTIVE_PAGE_CACHE_STATUS_TIMEOUT_MS);
+  }
+  function isScriptableUrl(url) {
+    const lower = url.toLowerCase();
+    return lower.startsWith("http://") || lower.startsWith("https://");
+  }
+  function activePageCacheKey(tab, url) {
+    return `${tab.id}:${url}`;
+  }
+  function activePageCacheUrl(tab) {
+    return tab.url || tab.pendingUrl || "";
+  }
+  async function tabUrlMatches(tabId, expectedUrl) {
+    try {
+      return activePageCacheUrl(await chrome.tabs.get(tabId)) === expectedUrl;
+    } catch {
+      return false;
+    }
+  }
+  async function clearCacheAvailableIndicator(tabId) {
+    try {
+      await chrome.action?.setBadgeText?.({ tabId, text: "" });
+      await chrome.action?.setTitle?.({ tabId, title: "Tab Control" });
+    } catch (error) {
+      log("clear cache indicator failed", { tabId, error });
+    }
+  }
+  async function setCacheAvailableIndicator(tabId, expectedUrl) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      if (!isEligibleActivePageCacheTab(tab) || activePageCacheUrl(tab) !== expectedUrl) {
+        await clearCacheAvailableIndicator(tabId);
+        return;
+      }
+      await chrome.action?.setBadgeBackgroundColor?.({ tabId, color: CACHE_AVAILABLE_BADGE_COLOR });
+      await chrome.action?.setBadgeText?.({ tabId, text: CACHE_AVAILABLE_BADGE_TEXT });
+      await chrome.action?.setTitle?.({ tabId, title: "Tab Control - page cache available" });
+    } catch (error) {
+      log("set cache indicator failed", { tabId, error });
+    }
+  }
+  async function applyPageCacheStatus(tabId, expectedUrl, available) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      if (activePageCacheUrl(tab) !== expectedUrl) {
+        return;
+      }
+      if (!isEligibleActivePageCacheTab(tab) || !available) {
+        await clearCacheAvailableIndicator(tabId);
+        return;
+      }
+      await setCacheAvailableIndicator(tabId, expectedUrl);
+    } catch {
+      await clearCacheAvailableIndicator(tabId);
+    }
+  }
+  function handlePageCacheStatusMessage(message) {
+    if (!message || typeof message !== "object" || message.action) {
+      return false;
+    }
+    const requestId = typeof message.id === "string" ? message.id : "";
+    const pending = activePageCache.statusRequests.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    activePageCache.statusRequests.delete(requestId);
+    const data = message.data && typeof message.data === "object" ? message.data : {};
+    const tabId = typeof data.tabId === "number" ? data.tabId : pending.tabId;
+    const url = typeof data.url === "string" ? data.url : pending.url;
+    const available = message.ok === true && data.available === true && tabId === pending.tabId && url === pending.url;
+    void applyPageCacheStatus(pending.tabId, pending.url, available);
+    return true;
+  }
+  function requestPageCacheStatus(tab, reason) {
+    const url = activePageCacheUrl(tab);
+    if (typeof tab.id !== "number" || !isEligibleActivePageCacheTab(tab)) {
+      if (typeof tab.id === "number") {
+        void clearCacheAvailableIndicator(tab.id);
+      }
+      return;
+    }
+    const port = state.port;
+    if (!port) {
       connectNative();
+      void clearCacheAvailableIndicator(tab.id);
+      return;
     }
-  });
-  async function ensureLastFocusedLoaded() {
-    if (state.lastFocusedLoaded) {
+    const id = nextActivePageCacheStatusId();
+    trackPageCacheStatusRequest(id, tab.id, url);
+    port.postMessage({
+      id,
+      action: "page-cache-status",
+      ok: true,
+      data: {
+        reason,
+        requestedAt: Date.now(),
+        tab: {
+          tabId: tab.id,
+          url,
+          incognito: tab.incognito || false,
+          discarded: tab.discarded || false,
+          status: tab.status || null
+        }
+      }
+    });
+  }
+  async function requestPageCacheStatusForTab(tabId, reason) {
+    try {
+      requestPageCacheStatus(await chrome.tabs.get(tabId), reason);
+    } catch {
+      await clearCacheAvailableIndicator(tabId);
+    }
+  }
+  async function refreshActivePageCacheIndicator(reason) {
+    try {
+      const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+      if (tab) {
+        requestPageCacheStatus(tab, reason);
+      }
+    } catch (error) {
+      log("active page cache indicator refresh failed", { reason, error });
+    }
+  }
+  function urlMismatchPageHtmlResponse(expectedUrl) {
+    return {
+      status: "URL_MISMATCH",
+      html: "",
+      sourceHtmlChars: 0,
+      sourceTextChars: 0,
+      documentReadyState: null,
+      truncatedHtml: false,
+      error: `Tab URL changed before page HTML extraction completed: expected ${expectedUrl}`
+    };
+  }
+  function isEligibleActivePageCacheTab(tab) {
+    const url = activePageCacheUrl(tab);
+    return typeof tab.id === "number" && Boolean(url) && tab.incognito !== true && !browserState.incognitoTabIds.has(tab.id) && (typeof tab.windowId !== "number" || !browserState.incognitoWindowIds.has(tab.windowId)) && tab.discarded !== true && tab.status !== "loading" && isScriptableUrl(url);
+  }
+  function clearPendingActivePageCacheCapture() {
+    if (activePageCache.timer) {
+      clearTimeout(activePageCache.timer);
+      activePageCache.timer = null;
+    }
+    activePageCache.pending = null;
+  }
+  function clearPendingQuiescentActivePageCacheCapture() {
+    if (activePageCache.quiescentTimer) {
+      clearTimeout(activePageCache.quiescentTimer);
+      activePageCache.quiescentTimer = null;
+    }
+    activePageCache.quiescentPending = null;
+  }
+  function isQuiescentCaptureCoolingDown(key) {
+    return activePageCache.lastQuiescentCapturedKey === key && Date.now() - activePageCache.lastQuiescentCapturedAt < ACTIVE_PAGE_CACHE_QUIESCENT_COOLDOWN_MS;
+  }
+  function scheduleQuiescentActivePageCacheCapture(tab, reason, key) {
+    if (isQuiescentCaptureCoolingDown(key)) {
+      return;
+    }
+    clearPendingQuiescentActivePageCacheCapture();
+    activePageCache.quiescentPending = {
+      tabId: tab.id,
+      key,
+      reason: `${reason}:quiescent`,
+      attempts: 0
+    };
+    activePageCache.quiescentTimer = setTimeout(() => {
+      activePageCache.quiescentTimer = null;
+      const pending = activePageCache.quiescentPending;
+      activePageCache.quiescentPending = null;
+      if (pending) {
+        void captureQuiescentActivePageCache(pending);
+      }
+    }, ACTIVE_PAGE_CACHE_QUIESCENT_DELAY_MS);
+  }
+  function scheduleActivePageCacheCapture(tab, reason) {
+    if (!isEligibleActivePageCacheTab(tab)) {
+      if (typeof tab.id === "number") {
+        void clearCacheAvailableIndicator(tab.id);
+      }
+      clearPendingActivePageCacheCapture();
+      clearPendingQuiescentActivePageCacheCapture();
       return;
     }
-    const stored = await chrome.storage.local.get("lastFocused");
-    state.lastFocused = stored.lastFocused || {};
-    state.lastFocusedLoaded = true;
+    requestPageCacheStatus(tab, reason);
+    const url = activePageCacheUrl(tab);
+    const key = activePageCacheKey(tab, url);
+    scheduleQuiescentActivePageCacheCapture(tab, reason, key);
+    if (activePageCache.inFlightKeys.has(key) || activePageCache.lastCapturedKey === key) {
+      return;
+    }
+    clearPendingActivePageCacheCapture();
+    activePageCache.pending = { tab, reason, key };
+    activePageCache.timer = setTimeout(() => {
+      activePageCache.timer = null;
+      const pending = activePageCache.pending;
+      activePageCache.pending = null;
+      if (pending) {
+        void captureActivePageCache(pending.tab, pending.reason, pending.key);
+      }
+    }, ACTIVE_PAGE_CACHE_DEBOUNCE_MS);
   }
-  async function setLastFocused(tabId) {
-    await ensureLastFocusedLoaded();
-    state.lastFocused[String(tabId)] = Date.now();
-    await chrome.storage.local.set({ lastFocused: state.lastFocused });
+  async function scheduleActivePageCacheCaptureForTab(tabId, reason) {
+    try {
+      scheduleActivePageCacheCapture(await chrome.tabs.get(tabId), reason);
+    } catch (error) {
+      log("active page cache tab lookup failed", { tabId, reason, error });
+      await clearCacheAvailableIndicator(tabId);
+    }
   }
-  chrome.tabs.onActivated.addListener((info) => {
-    setLastFocused(info.tabId).catch((error) => log("Failed to set last focused", error));
-  });
-  chrome.tabs.onRemoved.addListener((tabId) => {
-    ensureLastFocusedLoaded().then(() => {
-      const key = String(tabId);
-      if (state.lastFocused[key]) {
-        delete state.lastFocused[key];
-        chrome.storage.local.set({ lastFocused: state.lastFocused });
-      }
-    }).catch((error) => log("Failed to prune last focused", error));
-  });
-  chrome.windows.onFocusChanged.addListener((windowId) => {
+  async function scheduleActivePageCacheCaptureForWindow(windowId, reason) {
     if (windowId === chrome.windows.WINDOW_ID_NONE) {
       return;
     }
-    chrome.tabs.query({ windowId, active: true }).then((tabs) => {
-      if (tabs[0] && tabs[0].id != null) {
-        setLastFocused(tabs[0].id).catch((error) => log("Failed to set last focused", error));
+    try {
+      const [tab] = await chrome.tabs.query({ active: true, windowId });
+      if (tab) {
+        scheduleActivePageCacheCapture(tab, reason);
+      }
+    } catch (error) {
+      log("active page cache window lookup failed", { windowId, reason, error });
+    }
+  }
+  async function currentActivePageCacheTab(tabId, key) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      const url = activePageCacheUrl(tab);
+      if (!tab.active || !isEligibleActivePageCacheTab(tab) || activePageCacheKey(tab, url) !== key) {
+        return null;
+      }
+      return tab;
+    } catch {
+      return null;
+    }
+  }
+  async function rescheduleQuiescentActivePageCacheCapture(pending) {
+    if (pending.attempts >= 2 || isQuiescentCaptureCoolingDown(pending.key)) {
+      return;
+    }
+    activePageCache.quiescentPending = { ...pending, attempts: pending.attempts + 1 };
+    activePageCache.quiescentTimer = setTimeout(() => {
+      activePageCache.quiescentTimer = null;
+      const retry = activePageCache.quiescentPending;
+      activePageCache.quiescentPending = null;
+      if (retry) {
+        void captureQuiescentActivePageCache(retry);
+      }
+    }, ACTIVE_PAGE_CACHE_QUIESCENT_RETRY_MS);
+  }
+  async function captureQuiescentActivePageCache(pending) {
+    if (isQuiescentCaptureCoolingDown(pending.key)) {
+      return;
+    }
+    if (activePageCache.inFlightKeys.has(pending.key)) {
+      await rescheduleQuiescentActivePageCacheCapture(pending);
+      return;
+    }
+    const tab = await currentActivePageCacheTab(pending.tabId, pending.key);
+    if (!tab) {
+      return;
+    }
+    const probe = await content.probePageQuiescence(
+      tab.id,
+      ACTIVE_PAGE_CACHE_QUIESCENT_TIMEOUT_MS,
+      ACTIVE_PAGE_CACHE_QUIESCENT_SAMPLE_MS
+    );
+    if (!probe.quiet) {
+      await rescheduleQuiescentActivePageCacheCapture(pending);
+      return;
+    }
+    const captured = await captureActivePageCache(tab, pending.reason, pending.key);
+    if (captured) {
+      activePageCache.lastQuiescentCapturedKey = pending.key;
+      activePageCache.lastQuiescentCapturedAt = Date.now();
+    }
+  }
+  async function captureActivePageCache(tab, reason, key) {
+    if (!state.port) {
+      connectNative();
+      return false;
+    }
+    if (!isEligibleActivePageCacheTab(tab) || activePageCache.inFlightKeys.has(key)) {
+      return false;
+    }
+    activePageCache.inFlightKeys.add(key);
+    try {
+      const captureTab = await currentActivePageCacheTab(tab.id, key);
+      if (!captureTab) {
+        return false;
+      }
+      const extraction = await content.extractPageHtml(captureTab.id, ACTIVE_PAGE_CACHE_TIMEOUT_MS, ACTIVE_PAGE_CACHE_MAX_HTML_CHARS);
+      if (extraction.status !== "READ" || typeof extraction.html !== "string" || extraction.html.length === 0) {
+        void requestPageCacheStatusForTab(captureTab.id, `${reason}:capture-failed`);
+        return false;
+      }
+      const verifiedTab = await currentActivePageCacheTab(captureTab.id, key);
+      if (!verifiedTab) {
+        return false;
+      }
+      const port = state.port;
+      if (!port) {
+        return false;
+      }
+      const id = nextActivePageCacheId();
+      trackPageCacheStatusRequest(id, verifiedTab.id, activePageCacheUrl(verifiedTab));
+      port.postMessage({
+        id,
+        action: "page-cache-capture",
+        ok: true,
+        data: {
+          reason,
+          capturedAt: Date.now(),
+          tab: {
+            tabId: verifiedTab.id,
+            windowId: verifiedTab.windowId,
+            index: verifiedTab.index,
+            url: activePageCacheUrl(verifiedTab),
+            title: verifiedTab.title,
+            groupId: verifiedTab.groupId,
+            favIconUrl: verifiedTab.favIconUrl || null,
+            status: verifiedTab.status || null,
+            pinned: verifiedTab.pinned || false,
+            active: verifiedTab.active || false,
+            incognito: verifiedTab.incognito || false,
+            discarded: verifiedTab.discarded || false,
+            lastAccessedAt: verifiedTab.lastAccessed || null
+          },
+          extraction
+        }
+      });
+      activePageCache.lastCapturedKey = key;
+      return true;
+    } catch (error) {
+      log("active page cache capture failed", { tabId: tab.id, reason, error });
+      void requestPageCacheStatusForTab(tab.id, `${reason}:capture-error`);
+      return false;
+    } finally {
+      activePageCache.inFlightKeys.delete(key);
+    }
+  }
+  function normalizeEventPayload(kind, payload) {
+    const event = {
+      kind,
+      occurredAt: Date.now()
+    };
+    for (const [key, value] of Object.entries(payload)) {
+      if (value === void 0) {
+        continue;
+      }
+      event[key] = value;
+    }
+    if (event.incognito !== true && inferIncognitoEvent(payload)) {
+      event.incognito = true;
+    }
+    return event;
+  }
+  function inferIncognitoEvent(payload) {
+    const tabId = typeof payload.tabId === "number" ? payload.tabId : null;
+    if (tabId !== null && browserState.incognitoTabIds.has(tabId)) {
+      return true;
+    }
+    const groupId = typeof payload.groupId === "number" ? payload.groupId : null;
+    if (groupId !== null && browserState.incognitoGroupIds.has(groupId)) {
+      return true;
+    }
+    const windowId = typeof payload.windowId === "number" ? payload.windowId : null;
+    return windowId !== null && browserState.incognitoWindowIds.has(windowId);
+  }
+  function updateIncognitoState(snapshot) {
+    browserState.incognitoWindowIds.clear();
+    browserState.incognitoTabIds.clear();
+    browserState.incognitoGroupIds.clear();
+    for (const window2 of snapshot.windows || []) {
+      if (window2.incognito !== true || typeof window2.windowId !== "number") {
+        continue;
+      }
+      browserState.incognitoWindowIds.add(window2.windowId);
+      for (const tab of window2.tabs || []) {
+        if (typeof tab.tabId === "number") {
+          browserState.incognitoTabIds.add(tab.tabId);
+        }
+      }
+      for (const group of window2.groups || []) {
+        if (typeof group.groupId === "number") {
+          browserState.incognitoGroupIds.add(group.groupId);
+        }
+      }
+    }
+  }
+  async function postBrowserStateSync(reason) {
+    if (!state.port) {
+      return;
+    }
+    const eventCount = browserState.pendingEvents.length;
+    const events = browserState.pendingEvents.slice(0, eventCount);
+    try {
+      const snapshot = await getTabSnapshot();
+      updateIncognitoState(snapshot);
+      state.port.postMessage({
+        id: nextBrowserStateId(),
+        action: "browser-state-sync",
+        ok: true,
+        data: {
+          reason,
+          recordedAt: Date.now(),
+          events,
+          snapshot
+        }
+      });
+      browserState.pendingEvents.splice(0, eventCount);
+    } catch (error) {
+      log("Browser state sync failed", error);
+    }
+  }
+  function queueBrowserStateSync(reason) {
+    if (!state.port) {
+      connectNative();
+      return;
+    }
+    if (browserState.syncTimer) {
+      clearTimeout(browserState.syncTimer);
+    }
+    const delayMs = reason === "startup" ? 0 : BROWSER_STATE_SYNC_DEBOUNCE_MS;
+    browserState.syncTimer = setTimeout(() => {
+      browserState.syncTimer = null;
+      void postBrowserStateSync(reason);
+    }, delayMs);
+  }
+  function enqueueBrowserStateEvent(kind, payload, reason = "event") {
+    browserState.pendingEvents.push(normalizeEventPayload(kind, payload));
+    queueBrowserStateSync(reason);
+  }
+  function registerBrowserStateListeners() {
+    chrome.tabs?.onCreated?.addListener((tab) => {
+      enqueueBrowserStateEvent("tabs.onCreated", {
+        tabId: tab.id,
+        windowId: tab.windowId,
+        groupId: tab.groupId,
+        incognito: tab.incognito,
+        url: tab.url || tab.pendingUrl,
+        title: tab.title,
+        index: tab.index
+      });
+    });
+    chrome.tabs?.onUpdated?.addListener((tabId, changeInfo, tab) => {
+      const interesting = ["url", "title", "status", "pinned", "audible", "discarded", "favIconUrl"];
+      if (!interesting.some((key) => key in changeInfo)) {
+        return;
       }
-    }).catch((error) => log("Failed to query active tab", error));
+      enqueueBrowserStateEvent("tabs.onUpdated", {
+        tabId,
+        windowId: tab.windowId,
+        groupId: tab.groupId,
+        incognito: tab.incognito,
+        changeInfo
+      });
+      if ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo) {
+        void clearCacheAvailableIndicator(tabId);
+      }
+      if (tab.active && ("url" in changeInfo || "status" in changeInfo || "discarded" in changeInfo)) {
+        scheduleActivePageCacheCapture(tab, "tabs.onUpdated");
+      }
+    });
+    chrome.tabs?.onMoved?.addListener((tabId, moveInfo) => {
+      enqueueBrowserStateEvent("tabs.onMoved", {
+        tabId,
+        windowId: moveInfo.windowId,
+        fromIndex: moveInfo.fromIndex,
+        toIndex: moveInfo.toIndex
+      });
+    });
+    chrome.tabs?.onAttached?.addListener((tabId, attachInfo) => {
+      enqueueBrowserStateEvent("tabs.onAttached", {
+        tabId,
+        windowId: attachInfo.newWindowId,
+        newPosition: attachInfo.newPosition
+      });
+    });
+    chrome.tabs?.onDetached?.addListener((tabId, detachInfo) => {
+      enqueueBrowserStateEvent("tabs.onDetached", {
+        tabId,
+        windowId: detachInfo.oldWindowId,
+        oldPosition: detachInfo.oldPosition
+      });
+    });
+    chrome.tabs?.onRemoved?.addListener((tabId, removeInfo) => {
+      enqueueBrowserStateEvent("tabs.onRemoved", {
+        tabId,
+        windowId: removeInfo.windowId,
+        isWindowClosing: removeInfo.isWindowClosing
+      });
+      activePageCache.statusRequests.forEach((pending, requestId) => {
+        if (pending.tabId === tabId) {
+          activePageCache.statusRequests.delete(requestId);
+        }
+      });
+      void clearCacheAvailableIndicator(tabId);
+    });
+    chrome.tabs?.onActivated?.addListener((activeInfo) => {
+      enqueueBrowserStateEvent("tabs.onActivated", {
+        tabId: activeInfo.tabId,
+        windowId: activeInfo.windowId
+      });
+      void scheduleActivePageCacheCaptureForTab(activeInfo.tabId, "tabs.onActivated");
+    });
+    chrome.tabGroups?.onCreated?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onCreated", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.tabGroups?.onUpdated?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onUpdated", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.tabGroups?.onMoved?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onMoved", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.tabGroups?.onRemoved?.addListener((group) => {
+      enqueueBrowserStateEvent("tabGroups.onRemoved", {
+        groupId: group.id,
+        windowId: group.windowId,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      });
+    });
+    chrome.windows?.onCreated?.addListener((window2) => {
+      enqueueBrowserStateEvent("windows.onCreated", {
+        windowId: window2.id,
+        incognito: window2.incognito,
+        focused: window2.focused,
+        state: window2.state
+      });
+    });
+    chrome.windows?.onRemoved?.addListener((windowId) => {
+      enqueueBrowserStateEvent("windows.onRemoved", { windowId });
+    });
+    chrome.windows?.onFocusChanged?.addListener((windowId) => {
+      enqueueBrowserStateEvent("windows.onFocusChanged", { windowId });
+      void scheduleActivePageCacheCaptureForWindow(windowId, "windows.onFocusChanged");
+    });
+  }
+  connectNative();
+  registerBrowserStateListeners();
+  ensureKeepaliveAlarm();
+  chrome.runtime.onInstalled.addListener(() => {
+    connectNative();
+    ensureKeepaliveAlarm();
+  });
+  chrome.runtime.onStartup.addListener(() => {
+    connectNative();
+    ensureKeepaliveAlarm();
+  });
+  chrome.alarms.onAlarm.addListener((alarm) => {
+    if (alarm.name === KEEPALIVE_ALARM) {
+      connectNative();
+    } else if (alarm.name === RECONNECT_ALARM) {
+      clearReconnectTimer();
+      connectNative();
+    }
   });
-  async function handleNativeMessage(message) {
+  async function handleNativeMessage(requestPort, message) {
     if (!message || typeof message !== "object") {
       return;
     }
@@ -580,9 +1546,9 @@
     }
     try {
       const data = await handleAction(action, params || {}, id);
-      sendResponse(id, true, data);
+      sendResponse(requestPort, id, true, data);
     } catch (error) {
-      sendResponse(id, false, error);
+      sendResponse(requestPort, id, false, error);
     }
   }
   async function handleAction(action, params, requestId) {
@@ -602,6 +1568,9 @@
           component: "extension"
         };
       case "reload":
+        chrome.alarms.create(RECONNECT_ALARM, {
+          delayInMinutes: RECONNECT_ALARM_MIN_DELAY_MS / 6e4
+        });
         setTimeout(() => chrome.runtime.reload(), 100);
         return { reloading: true };
       // --- Primitives: thin Chrome API wrappers (p: prefix) ---
@@ -655,8 +1624,7 @@
             return await content.extractPageMeta(targetTabId, timeoutMs, funcArgs[0] || DESCRIPTION_MAX_LENGTH);
           case "extractSelectorSignal": {
             const specs = funcArgs[0];
-            if (!Array.isArray(specs))
-              throw new Error("extractSelectorSignal requires specs array as first arg");
+            if (!Array.isArray(specs)) throw new Error("extractSelectorSignal requires specs array as first arg");
             const selectorMaxLen = funcArgs[1] || 500;
             return await content.extractSelectorSignal(targetTabId, specs, timeoutMs, selectorMaxLen);
           }
@@ -671,14 +1639,31 @@
         const quality = typeof opts.quality === "number" ? Math.max(1, Math.min(100, opts.quality)) : 80;
         const tileMaxDim = typeof opts.tileMaxDim === "number" ? Math.max(50, opts.tileMaxDim) : 50;
         const maxBytes = typeof opts.maxBytes === "number" ? Math.max(5e4, opts.maxBytes) : 5e4;
-        return await screenshot.captureTabTiles(params.tab, { mode, format: fmt, quality, tileMaxDim, maxBytes }, { delay, executeWithTimeout });
+        return await screenshot.captureTabTiles(
+          params.tab,
+          { mode, format: fmt, quality, tileMaxDim, maxBytes },
+          { delay: delay2, executeWithTimeout: executeWithTimeout2 }
+        );
+      }
+      case "p:page-html": {
+        const targetTabId = requireFiniteId(params.tabId, "tabId");
+        const expectedUrl = typeof params.expectedUrl === "string" ? params.expectedUrl : "";
+        const maxHtmlChars = typeof params.maxHtmlChars === "number" ? Math.max(1, Math.min(params.maxHtmlChars, MAX_PAGE_HTML_CHARS)) : MAX_PAGE_HTML_CHARS;
+        const timeoutMs = typeof params.timeoutMs === "number" ? Math.max(1, params.timeoutMs) : 15e3;
+        if (expectedUrl && !await tabUrlMatches(targetTabId, expectedUrl)) {
+          return urlMismatchPageHtmlResponse(expectedUrl);
+        }
+        const result = await content.extractPageHtml(targetTabId, timeoutMs, maxHtmlChars);
+        if (expectedUrl && !await tabUrlMatches(targetTabId, expectedUrl)) {
+          return urlMismatchPageHtmlResponse(expectedUrl);
+        }
+        return result;
       }
       default:
         throw new Error(`Unknown action: ${action}`);
     }
   }
   async function getTabSnapshot() {
-    await ensureLastFocusedLoaded();
     const windows = await chrome.windows.getAll({ populate: true, windowTypes: ["normal"] });
     const groups = await chrome.tabGroups.query({});
     const groupById = new Map(groups.map((group) => [group.id, group]));
@@ -689,7 +1674,8 @@
           tabId: tab.id,
           windowId: win.id,
           index: tab.index,
-          url: tab.url,
+          incognito: win.incognito || false,
+          url: tab.url || tab.pendingUrl,
           title: tab.title,
           active: tab.active,
           pinned: tab.pinned,
@@ -697,7 +1683,11 @@
           groupTitle: group ? group.title : null,
           groupColor: group ? group.color : null,
           groupCollapsed: group ? group.collapsed : null,
-          lastFocusedAt: state.lastFocused[String(tab.id)] || null
+          lastAccessedAt: tab.lastAccessed || null,
+          favIconUrl: tab.favIconUrl || null,
+          status: tab.status || null,
+          discarded: tab.discarded || false,
+          audible: tab.audible || false
         };
       });
       const windowGroups = groups.filter((group) => group.windowId === win.id).map((group) => ({
@@ -709,6 +1699,7 @@
       return {
         windowId: win.id,
         focused: win.focused,
+        incognito: win.incognito || false,
         state: win.state,
         tabs,
         groups: windowGroups