tabctl 0.1.4 → 0.2.1

package/dist/extension/background.js

@@ -0,0 +1,3398 @@
+(() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+
+  // 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.screenshotTabs = screenshotTabs;
+      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);
+      }
+      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
+        };
+      }
+      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 };
+      }
+      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, deps2) {
+        const result = await deps2.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, deps2) {
+        const result = await deps2.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, deps2) {
+        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, deps2);
+        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 deps2.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, deps2);
+            await deps2.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 deps2.delay(1e3);
+                await captureTile(x, y, width, height, tileCount);
+              } else {
+                throw err;
+              }
+            }
+          }
+        }
+        await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps2);
+        return tiles;
+      }
+      async function screenshotTabs(params, requestId, deps2) {
+        const snapshot = await deps2.getTabSnapshot();
+        const selection = deps2.selectTabsByScope(snapshot, params);
+        if (selection.error) {
+          throw selection.error;
+        }
+        const mode = params.mode === "full" ? "full" : "viewport";
+        const format = params.format === "jpeg" ? "jpeg" : "png";
+        const qualityRaw = Number(params.quality);
+        const quality = Number.isFinite(qualityRaw) ? Math.min(100, Math.max(0, Math.floor(qualityRaw))) : exports.SCREENSHOT_QUALITY;
+        const tileMaxDimRaw = Number(params.tileMaxDim);
+        const tileMaxDim = Number.isFinite(tileMaxDimRaw) && tileMaxDimRaw > 0 ? Math.floor(tileMaxDimRaw) : exports.SCREENSHOT_TILE_MAX_DIM;
+        const adjustedTileMaxDim = tileMaxDim < 50 ? 50 : tileMaxDim;
+        const maxBytesRaw = Number(params.maxBytes);
+        const maxBytes = Number.isFinite(maxBytesRaw) && maxBytesRaw > 0 ? Math.floor(maxBytesRaw) : exports.SCREENSHOT_MAX_BYTES;
+        const adjustedMaxBytes = maxBytes < 5e4 ? 5e4 : maxBytes;
+        const progressEnabled = params.progress === true;
+        const tabs2 = selection.tabs;
+        const entries = [];
+        let totalTiles = 0;
+        const startedAt = Date.now();
+        for (let index = 0; index < tabs2.length; index += 1) {
+          const tab = tabs2[index];
+          const tabId = tab.tabId;
+          const url = tab.url;
+          if (!deps2.isScriptableUrl(url)) {
+            entries.push({
+              tabId,
+              windowId: tab.windowId,
+              groupId: tab.groupId,
+              url: tab.url,
+              title: tab.title,
+              error: { message: "unsupported_url" },
+              tiles: []
+            });
+            if (progressEnabled) {
+              deps2.sendProgress(requestId, { phase: "screenshot", processed: index + 1, total: tabs2.length, tabId });
+            }
+            continue;
+          }
+          let tiles = [];
+          let error = null;
+          try {
+            const windowId = tab.windowId;
+            const activeTabs = await chrome.tabs.query({ windowId, active: true });
+            const activeTabId = activeTabs[0]?.id ?? null;
+            if (activeTabId && activeTabId !== tabId) {
+              await chrome.tabs.update(tabId, { active: true });
+              await deps2.delay(exports.SCREENSHOT_SCROLL_DELAY_MS);
+            }
+            try {
+              await deps2.waitForTabReady(tabId, params, exports.SCREENSHOT_PROCESS_TIMEOUT_MS);
+              tiles = await captureTabTiles(tab, { mode, format, quality, tileMaxDim: adjustedTileMaxDim, maxBytes: adjustedMaxBytes }, deps2);
+            } finally {
+              if (activeTabId && activeTabId !== tabId) {
+                await chrome.tabs.update(activeTabId, { active: true });
+              }
+            }
+          } catch (err) {
+            const message = err instanceof Error ? err.message : "capture_failed";
+            error = { message };
+          }
+          totalTiles += tiles.length;
+          entries.push({
+            tabId: tab.tabId,
+            windowId: tab.windowId,
+            groupId: tab.groupId,
+            url: tab.url,
+            title: tab.title,
+            tiles,
+            ...error ? { error } : {}
+          });
+          if (progressEnabled) {
+            deps2.sendProgress(requestId, { phase: "screenshot", processed: index + 1, total: tabs2.length, tabId });
+          }
+        }
+        return {
+          generatedAt: Date.now(),
+          totals: { tabs: tabs2.length, tiles: totalTiles },
+          meta: {
+            durationMs: Date.now() - startedAt,
+            mode,
+            format,
+            quality: format === "jpeg" ? quality : null,
+            tileMaxDim: adjustedTileMaxDim,
+            maxBytes: adjustedMaxBytes
+          },
+          entries
+        };
+      }
+    }
+  });
+
+  // dist/extension/lib/content.js
+  var require_content = __commonJS({
+    "dist/extension/lib/content.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.SETTLE_POLL_INTERVAL_MS = exports.SETTLE_STABILITY_MS = void 0;
+      exports.isScriptableUrl = isScriptableUrl2;
+      exports.delay = delay2;
+      exports.executeWithTimeout = executeWithTimeout2;
+      exports.isGitHubIssueOrPr = isGitHubIssueOrPr2;
+      exports.detectGitHubState = detectGitHubState2;
+      exports.extractPageMeta = extractPageMeta2;
+      exports.extractSelectorSignal = extractSelectorSignal2;
+      exports.waitForTabLoad = waitForTabLoad2;
+      exports.waitForDomReady = waitForDomReady2;
+      exports.waitForSettle = waitForSettle2;
+      exports.waitForTabReady = waitForTabReady2;
+      exports.SETTLE_STABILITY_MS = 500;
+      exports.SETTLE_POLL_INTERVAL_MS = 50;
+      function isScriptableUrl2(url) {
+        return typeof url === "string" && (url.startsWith("http://") || url.startsWith("https://"));
+      }
+      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;
+        }
+      }
+      function isGitHubIssueOrPr2(url) {
+        if (!url) {
+          return false;
+        }
+        return /^https:\/\/github\.com\/[^/]+\/[^/]+\/(issues|pull)\/\d+/.test(url);
+      }
+      async function detectGitHubState2(tabId, timeoutMs) {
+        const result = await executeWithTimeout2(tabId, timeoutMs, () => {
+          const stateEl = document.querySelector(".gh-header-meta .State") || document.querySelector(".State") || document.querySelector(".js-issue-state");
+          if (!stateEl) {
+            return null;
+          }
+          const text = (stateEl.textContent || "").trim().toLowerCase();
+          if (text.includes("merged")) {
+            return "merged";
+          }
+          if (text.includes("closed")) {
+            return "closed";
+          }
+          if (text.includes("open")) {
+            return "open";
+          }
+          return null;
+        });
+        return typeof result === "string" ? result : null;
+      }
+      async function extractPageMeta2(tabId, timeoutMs, descriptionMaxLength) {
+        const result = await executeWithTimeout2(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 extractSelectorSignal2(tabId, specs, timeoutMs, selectorValueMaxLength) {
+        if (!specs.length) {
+          return null;
+        }
+        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;
+            }
+            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;
+            }
+            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;
+              }
+              const matchesText = (el) => {
+                if (!text) {
+                  return true;
+                }
+                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;
+              }
+              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 (all) {
+                values[name] = filtered.map(getValue).filter((val) => 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;
+      }
+      function waitForTabLoad2(tabId, timeoutMs) {
+        return new Promise((resolve) => {
+          let settled = false;
+          const done = () => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            chrome.tabs.onUpdated.removeListener(onUpdated);
+            resolve();
+          };
+          const onUpdated = (updatedTabId, info) => {
+            if (updatedTabId === tabId && info.status === "complete") {
+              done();
+            }
+          };
+          chrome.tabs.onUpdated.addListener(onUpdated);
+          chrome.tabs.get(tabId).then((tab) => {
+            if (tab.status === "complete") {
+              done();
+            }
+          }).catch(() => {
+            done();
+          });
+          setTimeout(done, timeoutMs);
+        });
+      }
+      async function waitForDomReady2(tabId, timeoutMs) {
+        const result = await executeWithTimeout2(tabId, timeoutMs, () => {
+          if (document.readyState === "interactive" || document.readyState === "complete") {
+            return true;
+          }
+          return new Promise((resolve) => {
+            const onReady = () => {
+              document.removeEventListener("DOMContentLoaded", onReady);
+              resolve(true);
+            };
+            document.addEventListener("DOMContentLoaded", onReady, { once: true });
+            setTimeout(() => {
+              document.removeEventListener("DOMContentLoaded", onReady);
+              resolve(false);
+            }, Math.max(0, timeoutMs - 50));
+          });
+        });
+        if (result === null) {
+          await delay2(Math.min(200, Math.max(50, Math.floor(timeoutMs / 10))));
+        }
+      }
+      async function waitForSettle2(tabId, timeoutMs) {
+        const startTime = Date.now();
+        let lastUrl = "";
+        let lastTitle = "";
+        let stableStart = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+          const tab = await chrome.tabs.get(tabId).catch(() => null);
+          if (!tab)
+            return;
+          const currentUrl = tab.url || "";
+          const currentTitle = tab.title || "";
+          if (currentUrl !== lastUrl || currentTitle !== lastTitle) {
+            lastUrl = currentUrl;
+            lastTitle = currentTitle;
+            stableStart = Date.now();
+          } else if (isScriptableUrl2(currentUrl) && tab.status === "complete" && Date.now() - stableStart >= exports.SETTLE_STABILITY_MS) {
+            return;
+          }
+          await delay2(exports.SETTLE_POLL_INTERVAL_MS);
+        }
+      }
+      async function waitForTabReady2(tabId, params, fallbackTimeoutMs) {
+        const waitFor = typeof params.waitFor === "string" ? params.waitFor.trim().toLowerCase() : "";
+        if (!waitFor || waitFor === "none") {
+          return;
+        }
+        const timeoutRaw = Number(params.waitTimeoutMs);
+        const timeoutMs = Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.floor(timeoutRaw) : fallbackTimeoutMs;
+        if (waitFor === "settle") {
+          await waitForSettle2(tabId, timeoutMs);
+          return;
+        }
+        try {
+          const tab = await chrome.tabs.get(tabId);
+          if (!isScriptableUrl2(tab.url)) {
+            return;
+          }
+        } catch {
+          return;
+        }
+        if (waitFor === "load") {
+          await waitForTabLoad2(tabId, timeoutMs);
+          return;
+        }
+        if (waitFor === "dom") {
+          await waitForDomReady2(tabId, timeoutMs);
+        }
+      }
+    }
+  });
+
+  // dist/extension/lib/groups.js
+  var require_groups = __commonJS({
+    "dist/extension/lib/groups.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getGroupTabs = getGroupTabs;
+      exports.listGroupSummaries = listGroupSummaries;
+      exports.summarizeGroupMatch = summarizeGroupMatch;
+      exports.findGroupMatches = findGroupMatches;
+      exports.resolveGroupByTitle = resolveGroupByTitle2;
+      exports.resolveGroupById = resolveGroupById2;
+      exports.listGroups = listGroups2;
+      exports.groupUpdate = groupUpdate2;
+      exports.groupUngroup = groupUngroup2;
+      exports.groupAssign = groupAssign2;
+      function getGroupTabs(windowSnapshot, groupId) {
+        return windowSnapshot.tabs.filter((tab) => tab.groupId === groupId).sort((a, b) => (Number(a.index) || 0) - (Number(b.index) || 0));
+      }
+      function listGroupSummaries(snapshot, buildWindowLabels2, windowId) {
+        const windowLabels = buildWindowLabels2(snapshot);
+        const summaries = [];
+        const windows = snapshot.windows;
+        for (const win of windows) {
+          if (windowId && win.windowId !== windowId) {
+            continue;
+          }
+          for (const group of win.groups) {
+            summaries.push({
+              windowId: win.windowId,
+              windowLabel: windowLabels.get(win.windowId) ?? null,
+              groupId: group.groupId,
+              title: typeof group.title === "string" ? group.title : null
+            });
+          }
+        }
+        return summaries;
+      }
+      function summarizeGroupMatch(match, windowLabels) {
+        return {
+          windowId: match.windowId,
+          windowLabel: windowLabels.get(match.windowId) ?? null,
+          groupId: match.group.groupId,
+          title: typeof match.group.title === "string" ? match.group.title : null
+        };
+      }
+      function findGroupMatches(snapshot, groupTitle, windowId) {
+        const matches = [];
+        const windows = snapshot.windows;
+        for (const win of windows) {
+          if (windowId && win.windowId !== windowId) {
+            continue;
+          }
+          for (const group of win.groups) {
+            if (group.title === groupTitle) {
+              matches.push({
+                windowId: win.windowId,
+                group,
+                tabs: getGroupTabs(win, group.groupId)
+              });
+            }
+          }
+        }
+        return matches;
+      }
+      function resolveGroupByTitle2(snapshot, buildWindowLabels2, groupTitle, windowId) {
+        const windowLabels = buildWindowLabels2(snapshot);
+        const allMatches = findGroupMatches(snapshot, groupTitle);
+        const matches = windowId ? allMatches.filter((match) => match.windowId === windowId) : allMatches;
+        const availableGroups = listGroupSummaries(snapshot, buildWindowLabels2);
+        if (matches.length === 0) {
+          const message = windowId && allMatches.length > 0 ? "Group title not found in specified window" : "No matching group title found";
+          return {
+            error: {
+              message,
+              hint: "Use tabctl group-list to see existing groups.",
+              matches: allMatches.map((match) => summarizeGroupMatch(match, windowLabels)),
+              availableGroups
+            }
+          };
+        }
+        if (matches.length > 1) {
+          return {
+            error: {
+              message: "Group title is ambiguous. Provide a windowId.",
+              hint: "Use --window to disambiguate group titles.",
+              matches: matches.map((match) => summarizeGroupMatch(match, windowLabels)),
+              availableGroups
+            }
+          };
+        }
+        return { match: matches[0] };
+      }
+      function resolveGroupById2(snapshot, buildWindowLabels2, groupId) {
+        const windows = snapshot.windows;
+        const matches = [];
+        for (const win of windows) {
+          const group = win.groups.find((entry) => entry.groupId === groupId);
+          if (group) {
+            matches.push({
+              windowId: win.windowId,
+              group,
+              tabs: getGroupTabs(win, groupId)
+            });
+          }
+        }
+        if (matches.length === 0) {
+          return {
+            error: {
+              message: "Group not found",
+              hint: "Use tabctl group-list to see existing groups.",
+              availableGroups: listGroupSummaries(snapshot, buildWindowLabels2)
+            }
+          };
+        }
+        if (matches.length > 1) {
+          const windowLabels = buildWindowLabels2(snapshot);
+          return {
+            error: {
+              message: "Group id is ambiguous. Provide a windowId.",
+              hint: "Use --window to disambiguate group ids.",
+              matches: matches.map((match) => summarizeGroupMatch(match, windowLabels)),
+              availableGroups: listGroupSummaries(snapshot, buildWindowLabels2)
+            }
+          };
+        }
+        return { match: matches[0] };
+      }
+      async function listGroups2(params, deps2) {
+        const snapshot = await deps2.getTabSnapshot();
+        const windows = snapshot.windows;
+        const windowLabels = deps2.buildWindowLabels(snapshot);
+        const windowIdParam = params.windowId != null ? deps2.resolveWindowIdFromParams(snapshot, params.windowId) : null;
+        if (windowIdParam && !windows.some((win) => win.windowId === windowIdParam)) {
+          throw new Error("Window not found");
+        }
+        const groups2 = [];
+        for (const win of windows) {
+          if (windowIdParam && win.windowId !== windowIdParam) {
+            continue;
+          }
+          const counts = /* @__PURE__ */ new Map();
+          for (const tab of win.tabs) {
+            const groupId = tab.groupId;
+            if (typeof groupId === "number" && groupId !== -1) {
+              counts.set(groupId, (counts.get(groupId) || 0) + 1);
+            }
+          }
+          for (const group of win.groups) {
+            const groupId = group.groupId;
+            groups2.push({
+              windowId: win.windowId,
+              windowLabel: windowLabels.get(win.windowId) ?? null,
+              groupId,
+              title: group.title ?? null,
+              color: group.color ?? null,
+              collapsed: group.collapsed ?? null,
+              tabCount: counts.get(groupId) || 0
+            });
+          }
+        }
+        return { groups: groups2 };
+      }
+      async function groupUpdate2(params, deps2) {
+        const groupId = Number.isFinite(params.groupId) ? Number(params.groupId) : null;
+        const groupTitle = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+        if (!groupId && !groupTitle) {
+          throw new Error("Missing group identifier");
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const windows = snapshot.windows;
+        const windowIdParam = params.windowId != null ? deps2.resolveWindowIdFromParams(snapshot, params.windowId) : null;
+        if (windowIdParam && !windows.some((win) => win.windowId === windowIdParam)) {
+          throw new Error("Window not found");
+        }
+        let match;
+        if (groupId != null) {
+          const resolved = resolveGroupById2(snapshot, deps2.buildWindowLabels, groupId);
+          if (resolved.error) {
+            throw resolved.error;
+          }
+          match = resolved.match;
+          if (windowIdParam && windowIdParam !== match.windowId) {
+            throw new Error("Group is not in the specified window");
+          }
+        } else {
+          const resolved = resolveGroupByTitle2(snapshot, deps2.buildWindowLabels, groupTitle, windowIdParam || void 0);
+          if (resolved.error) {
+            throw resolved.error;
+          }
+          match = resolved.match;
+        }
+        const update = {};
+        if (typeof params.title === "string") {
+          update.title = params.title;
+        }
+        if (typeof params.color === "string" && params.color.trim()) {
+          update.color = params.color.trim();
+        }
+        if (typeof params.collapsed === "boolean") {
+          update.collapsed = params.collapsed;
+        }
+        if (!Object.keys(update).length) {
+          throw new Error("Missing group update fields");
+        }
+        const updated = await chrome.tabGroups.update(match.group.groupId, update);
+        return {
+          groupId: updated.id,
+          windowId: updated.windowId,
+          title: updated.title,
+          color: updated.color,
+          collapsed: updated.collapsed,
+          undo: {
+            action: "group-update",
+            groupId: updated.id,
+            windowId: match.windowId,
+            previous: {
+              title: match.group.title ?? null,
+              color: match.group.color ?? null,
+              collapsed: match.group.collapsed ?? null
+            }
+          },
+          txid: params.txid || null
+        };
+      }
+      async function groupUngroup2(params, deps2) {
+        const groupId = Number.isFinite(params.groupId) ? Number(params.groupId) : null;
+        const groupTitle = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+        if (!groupId && !groupTitle) {
+          throw new Error("Missing group identifier");
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const windows = snapshot.windows;
+        const windowIdParam = params.windowId != null ? deps2.resolveWindowIdFromParams(snapshot, params.windowId) : null;
+        if (windowIdParam && !windows.some((win) => win.windowId === windowIdParam)) {
+          throw new Error("Window not found");
+        }
+        let match;
+        if (groupId != null) {
+          const resolved = resolveGroupById2(snapshot, deps2.buildWindowLabels, groupId);
+          if (resolved.error) {
+            throw resolved.error;
+          }
+          match = resolved.match;
+          if (windowIdParam && windowIdParam !== match.windowId) {
+            throw new Error("Group is not in the specified window");
+          }
+        } else {
+          const resolved = resolveGroupByTitle2(snapshot, deps2.buildWindowLabels, groupTitle, windowIdParam || void 0);
+          if (resolved.error) {
+            throw resolved.error;
+          }
+          match = resolved.match;
+        }
+        const undoTabs = match.tabs.map((tab) => ({
+          tabId: tab.tabId,
+          windowId: tab.windowId,
+          index: tab.index,
+          groupId: tab.groupId,
+          groupTitle: tab.groupTitle,
+          groupColor: tab.groupColor,
+          groupCollapsed: match.group.collapsed ?? null
+        })).filter((tab) => typeof tab.tabId === "number");
+        const tabIds = match.tabs.map((tab) => tab.tabId).filter((tabId) => typeof tabId === "number");
+        if (tabIds.length) {
+          await chrome.tabs.ungroup(tabIds);
+        }
+        return {
+          groupId: match.group.groupId,
+          groupTitle: match.group.title || null,
+          windowId: match.windowId,
+          summary: {
+            ungroupedTabs: tabIds.length
+          },
+          undo: {
+            action: "group-ungroup",
+            groupId: match.group.groupId,
+            windowId: match.windowId,
+            groupTitle: match.group.title || null,
+            groupColor: match.group.color || null,
+            groupCollapsed: match.group.collapsed ?? null,
+            tabs: undoTabs
+          },
+          txid: params.txid || null
+        };
+      }
+      async function groupAssign2(params, deps2) {
+        const rawTabIds = Array.isArray(params.tabIds) ? params.tabIds.map(Number) : [];
+        const tabIds = rawTabIds.filter((id) => Number.isFinite(id));
+        if (!tabIds.length) {
+          throw new Error("Missing tabIds");
+        }
+        const groupId = Number.isFinite(params.groupId) ? Number(params.groupId) : null;
+        const groupTitle = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+        if (!groupId && !groupTitle) {
+          throw new Error("Missing group identifier");
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const windows = snapshot.windows;
+        const windowIdParam = params.windowId != null ? deps2.resolveWindowIdFromParams(snapshot, params.windowId) : null;
+        if (windowIdParam && !windows.some((win) => win.windowId === windowIdParam)) {
+          throw new Error("Window not found");
+        }
+        const tabIndex = /* @__PURE__ */ new Map();
+        for (const win of windows) {
+          for (const tab of win.tabs) {
+            if (typeof tab.tabId === "number") {
+              tabIndex.set(tab.tabId, { tab, windowId: win.windowId });
+            }
+          }
+        }
+        const skipped = [];
+        const resolvedTabIds = [];
+        const sourceWindows = /* @__PURE__ */ new Set();
+        const undoTabs = [];
+        for (const tabId of tabIds) {
+          const entry = tabIndex.get(tabId);
+          if (!entry) {
+            skipped.push({ tabId, reason: "not_found" });
+            continue;
+          }
+          resolvedTabIds.push(tabId);
+          sourceWindows.add(entry.windowId);
+          const tab = entry.tab;
+          undoTabs.push({
+            tabId,
+            windowId: entry.windowId,
+            index: tab.index,
+            groupId: tab.groupId,
+            groupTitle: tab.groupTitle,
+            groupColor: tab.groupColor,
+            groupCollapsed: tab.groupCollapsed ?? null
+          });
+        }
+        if (!resolvedTabIds.length) {
+          throw new Error("No matching tabs found");
+        }
+        let targetGroupId = null;
+        let targetWindowId = null;
+        let targetTitle = null;
+        let created = false;
+        if (groupId != null) {
+          const resolved = resolveGroupById2(snapshot, deps2.buildWindowLabels, groupId);
+          if (resolved.error) {
+            throw resolved.error;
+          }
+          const match = resolved.match;
+          targetGroupId = match.group.groupId;
+          targetWindowId = match.windowId;
+          targetTitle = typeof match.group.title === "string" ? match.group.title : null;
+          if (windowIdParam && windowIdParam !== targetWindowId) {
+            throw new Error("Group is not in the specified window");
+          }
+        } else {
+          const resolved = resolveGroupByTitle2(snapshot, deps2.buildWindowLabels, groupTitle, windowIdParam || void 0);
+          if (resolved.error) {
+            const error = resolved.error;
+            if (error.message === "No matching group title found" && params.create === true) {
+              targetWindowId = windowIdParam || (sourceWindows.size === 1 ? Array.from(sourceWindows)[0] : null);
+              if (!targetWindowId) {
+                throw new Error("Multiple source windows. Provide --window to create a new group.");
+              }
+              targetTitle = groupTitle;
+              created = true;
+            } else {
+              throw error;
+            }
+          } else {
+            const match = resolved.match;
+            targetGroupId = match.group.groupId;
+            targetWindowId = match.windowId;
+            targetTitle = typeof match.group.title === "string" && match.group.title ? match.group.title : groupTitle;
+          }
+        }
+        if (!targetWindowId) {
+          throw new Error("Target window not found");
+        }
+        const moveIds = resolvedTabIds.filter((tabId) => {
+          const entry = tabIndex.get(tabId);
+          return entry && entry.windowId !== targetWindowId;
+        });
+        if (moveIds.length > 0) {
+          await chrome.tabs.move(moveIds, { windowId: targetWindowId, index: -1 });
+        }
+        let assignedGroupId = targetGroupId;
+        if (targetGroupId != null) {
+          await chrome.tabs.group({ groupId: targetGroupId, tabIds: resolvedTabIds });
+        } else {
+          assignedGroupId = await chrome.tabs.group({ tabIds: resolvedTabIds, createProperties: { windowId: targetWindowId } });
+          const update = {};
+          if (targetTitle) {
+            update.title = targetTitle;
+          }
+          if (typeof params.color === "string" && params.color.trim()) {
+            update.color = params.color.trim();
+          }
+          if (typeof params.collapsed === "boolean") {
+            update.collapsed = params.collapsed;
+          }
+          if (Object.keys(update).length > 0) {
+            try {
+              await chrome.tabGroups.update(assignedGroupId, update);
+            } catch (error) {
+              deps2.log("Failed to update group", error);
+            }
+          }
+          created = true;
+        }
+        return {
+          groupId: assignedGroupId,
+          groupTitle: targetTitle || groupTitle || null,
+          windowId: targetWindowId,
+          created,
+          summary: {
+            movedTabs: moveIds.length,
+            groupedTabs: resolvedTabIds.length,
+            skippedTabs: skipped.length
+          },
+          skipped,
+          undo: {
+            action: "group-assign",
+            groupId: assignedGroupId,
+            groupTitle: targetTitle || groupTitle || null,
+            groupColor: typeof params.color === "string" && params.color.trim() ? params.color.trim() : null,
+            groupCollapsed: typeof params.collapsed === "boolean" ? params.collapsed : null,
+            created,
+            tabs: undoTabs
+          },
+          txid: params.txid || null
+        };
+      }
+    }
+  });
+
+  // dist/extension/lib/tabs.js
+  var require_tabs = __commonJS({
+    "dist/extension/lib/tabs.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getMostRecentFocusedWindowId = getMostRecentFocusedWindowId2;
+      exports.normalizeUrl = normalizeUrl;
+      exports.normalizeTabIndex = normalizeTabIndex2;
+      exports.resolveOpenWindow = resolveOpenWindow;
+      exports.focusTab = focusTab;
+      exports.refreshTabs = refreshTabs;
+      exports.openTabs = openTabs;
+      function getMostRecentFocusedWindowId2(windows) {
+        let bestWindowId = null;
+        let bestFocusedAt = -Infinity;
+        for (const win of windows) {
+          for (const tab of win.tabs) {
+            const focusedAt = Number(tab.lastFocusedAt);
+            if (!Number.isFinite(focusedAt)) {
+              continue;
+            }
+            if (focusedAt > bestFocusedAt) {
+              bestFocusedAt = focusedAt;
+              bestWindowId = win.windowId;
+            }
+          }
+        }
+        return bestWindowId;
+      }
+      function normalizeUrl(rawUrl) {
+        if (!rawUrl || typeof rawUrl !== "string") {
+          return null;
+        }
+        let url;
+        try {
+          url = new URL(rawUrl);
+        } catch {
+          return null;
+        }
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+          return null;
+        }
+        url.hash = "";
+        const dropKeys = /* @__PURE__ */ new Set([
+          "fbclid",
+          "gclid",
+          "igshid",
+          "mc_cid",
+          "mc_eid",
+          "ref",
+          "ref_src",
+          "ref_url",
+          "utm_campaign",
+          "utm_content",
+          "utm_medium",
+          "utm_source",
+          "utm_term",
+          "utm_name",
+          "si"
+        ]);
+        for (const key of Array.from(url.searchParams.keys())) {
+          if (key.startsWith("utm_") || dropKeys.has(key)) {
+            url.searchParams.delete(key);
+          }
+        }
+        const search = url.searchParams.toString();
+        url.search = search ? `?${search}` : "";
+        return url.toString();
+      }
+      function normalizeTabIndex2(value) {
+        const index = Number(value);
+        return Number.isFinite(index) ? index : null;
+      }
+      function matchIncludes(value, needle) {
+        if (!needle) {
+          return false;
+        }
+        return typeof value === "string" && value.toLowerCase().includes(needle);
+      }
+      function resolveOpenWindow(snapshot, params) {
+        const windows = snapshot.windows;
+        if (!windows.length) {
+          return { error: { message: "No windows available" } };
+        }
+        if (params.windowId != null) {
+          if (typeof params.windowId === "string") {
+            const normalized = params.windowId.trim().toLowerCase();
+            if (normalized === "active") {
+              const focused2 = windows.find((win) => win.focused);
+              if (focused2) {
+                return { windowId: focused2.windowId };
+              }
+              return { error: { message: "Active window not found" } };
+            }
+            if (normalized === "last-focused") {
+              const lastFocused2 = getMostRecentFocusedWindowId2(windows);
+              if (lastFocused2 != null) {
+                return { windowId: lastFocused2 };
+              }
+              return { error: { message: "Last focused window not found" } };
+            }
+            if (normalized === "new") {
+              return { error: { message: "--window new is only supported by open" } };
+            }
+          }
+          const windowId = Number(params.windowId);
+          const found = windows.find((win) => win.windowId === windowId);
+          if (!found) {
+            return { error: { message: "Window not found" } };
+          }
+          return { windowId };
+        }
+        if (params.windowTabId != null) {
+          const tabId = Number(params.windowTabId);
+          const found = windows.find((win) => win.tabs.some((tab) => tab.tabId === tabId));
+          if (!found) {
+            return { error: { message: "Window not found for tab" } };
+          }
+          return { windowId: found.windowId };
+        }
+        let candidates = [...windows];
+        let filtered = false;
+        if (typeof params.afterGroupTitle === "string" && params.afterGroupTitle.trim()) {
+          const groupTitle = params.afterGroupTitle.trim();
+          candidates = candidates.filter((win) => win.groups.some((group) => group.title === groupTitle));
+          filtered = true;
+        }
+        if (typeof params.windowGroupTitle === "string" && params.windowGroupTitle.trim()) {
+          const groupTitle = params.windowGroupTitle.trim();
+          candidates = candidates.filter((win) => win.groups.some((group) => group.title === groupTitle));
+          filtered = true;
+        }
+        if (typeof params.windowUrl === "string" && params.windowUrl.trim()) {
+          const needle = params.windowUrl.trim().toLowerCase();
+          candidates = candidates.filter((win) => win.tabs.some((tab) => matchIncludes(tab.url, needle)));
+          filtered = true;
+        }
+        if (filtered) {
+          if (candidates.length === 1) {
+            return { windowId: candidates[0].windowId };
+          }
+          if (candidates.length === 0) {
+            return { error: { message: "No matching window found" } };
+          }
+          return { error: { message: "Multiple windows match selection. Provide --window to disambiguate." } };
+        }
+        const focused = windows.find((win) => win.focused);
+        if (focused) {
+          return { windowId: focused.windowId };
+        }
+        if (windows.length === 1) {
+          return { windowId: windows[0].windowId };
+        }
+        const lastFocused = getMostRecentFocusedWindowId2(windows);
+        if (lastFocused != null) {
+          return { windowId: lastFocused };
+        }
+        return { error: { message: "Multiple windows available. Provide --window to target one." } };
+      }
+      async function focusTab(params) {
+        const tabIds = Array.isArray(params.tabIds) ? params.tabIds.map(Number) : [];
+        const tabId = Number.isFinite(params.tabId) ? Number(params.tabId) : tabIds.length ? Number(tabIds[0]) : null;
+        if (!tabId) {
+          throw new Error("Missing tabId");
+        }
+        const tab = await chrome.tabs.get(tabId);
+        await chrome.windows.update(tab.windowId, { focused: true });
+        await chrome.tabs.update(tabId, { active: true });
+        return {
+          tabId,
+          windowId: tab.windowId
+        };
+      }
+      async function refreshTabs(params) {
+        const tabId = Number.isFinite(params.tabId) ? Number(params.tabId) : null;
+        if (!tabId) {
+          throw new Error("Missing tabId");
+        }
+        await chrome.tabs.reload(tabId);
+        return {
+          tabId,
+          summary: { refreshedTabs: 1 }
+        };
+      }
+      async function openTabs(params, deps2) {
+        const urls = Array.isArray(params.urls) ? params.urls.map((url) => typeof url === "string" ? url.trim() : "").filter(Boolean) : [];
+        const groupTitle = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+        const groupColor = typeof params.color === "string" ? params.color.trim() : "";
+        const afterGroupTitle = typeof params.afterGroupTitle === "string" ? params.afterGroupTitle.trim() : "";
+        const beforeTabId = Number.isFinite(params.beforeTabId) ? Number(params.beforeTabId) : null;
+        const afterTabId = Number.isFinite(params.afterTabId) ? Number(params.afterTabId) : null;
+        if (beforeTabId != null && afterTabId != null) {
+          throw new Error("Only one target position is allowed");
+        }
+        const newWindow = params.newWindow === true;
+        if (!urls.length && !newWindow) {
+          throw new Error("No URLs provided");
+        }
+        if (newWindow) {
+          if (afterGroupTitle || beforeTabId || afterTabId) {
+            throw new Error("Cannot use --before/--after with --new-window");
+          }
+          if (params.windowId != null || params.windowGroupTitle || params.windowTabId != null || params.windowUrl) {
+            throw new Error("Cannot combine --new-window with window selectors");
+          }
+          const created2 = [];
+          const skipped2 = [];
+          const createdWindow = await chrome.windows.create({ focused: false });
+          const windowId2 = createdWindow.id;
+          let seedTabs = createdWindow.tabs;
+          if (!seedTabs) {
+            seedTabs = await chrome.tabs.query({ windowId: windowId2 });
+          }
+          const seedTabId = seedTabs.find((tab) => typeof tab.id === "number")?.id ?? null;
+          for (const url of urls) {
+            try {
+              const tab = await chrome.tabs.create({ windowId: windowId2, url, active: false });
+              created2.push({
+                tabId: tab.id,
+                windowId: tab.windowId,
+                index: tab.index,
+                url: tab.url,
+                title: tab.title
+              });
+            } catch (error) {
+              skipped2.push({ url, reason: "create_failed" });
+            }
+          }
+          if (!urls.length && seedTabs.length) {
+            const tab = seedTabs[0];
+            created2.push({
+              tabId: tab.id,
+              windowId: tab.windowId,
+              index: tab.index,
+              url: tab.url,
+              title: tab.title
+            });
+          }
+          if (seedTabId && created2.length > 0 && urls.length > 0) {
+            try {
+              await chrome.tabs.remove(seedTabId);
+            } catch (error) {
+              deps2.log("Failed to remove seed tab", error);
+            }
+          }
+          let groupId2 = null;
+          if (groupTitle && created2.length > 0) {
+            try {
+              const tabIds = created2.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+              if (tabIds.length > 0) {
+                groupId2 = await chrome.tabs.group({ tabIds, createProperties: { windowId: windowId2 } });
+                const update = { title: groupTitle };
+                if (groupColor) {
+                  update.color = groupColor;
+                }
+                await chrome.tabGroups.update(groupId2, update);
+              }
+            } catch (error) {
+              deps2.log("Failed to create group", error);
+              groupId2 = null;
+            }
+          }
+          return {
+            windowId: windowId2,
+            groupId: groupId2,
+            groupTitle: groupTitle || null,
+            afterGroupTitle: null,
+            insertIndex: null,
+            created: created2,
+            skipped: skipped2,
+            summary: {
+              createdTabs: created2.length,
+              skippedUrls: skipped2.length,
+              grouped: Boolean(groupId2)
+            }
+          };
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        let openParams = params;
+        if (params.windowId == null && (beforeTabId != null || afterTabId != null)) {
+          const anchorId = beforeTabId != null ? beforeTabId : afterTabId;
+          const anchorWindow = snapshot.windows.find((win) => win.tabs.some((tab) => tab.tabId === anchorId));
+          if (anchorWindow) {
+            openParams = { ...params, windowId: anchorWindow.windowId };
+          }
+        }
+        const selection = resolveOpenWindow(snapshot, openParams);
+        if (selection.error) {
+          throw selection.error;
+        }
+        const windowId = selection.windowId;
+        const windowSnapshot = snapshot.windows.find((win) => win.windowId === windowId);
+        if (!windowSnapshot) {
+          throw new Error("Window snapshot unavailable");
+        }
+        const created = [];
+        const skipped = [];
+        let insertIndex = null;
+        if (afterGroupTitle) {
+          const targetGroup = windowSnapshot.groups.find((group) => group.title === afterGroupTitle);
+          if (!targetGroup) {
+            throw new Error("Group not found in target window");
+          }
+          const groupTabs = windowSnapshot.tabs.filter((tab) => tab.groupId === targetGroup.groupId);
+          if (!groupTabs.length) {
+            throw new Error("Group has no tabs to anchor insertion");
+          }
+          const indices = groupTabs.map((tab) => normalizeTabIndex2(tab.index)).filter((value) => value != null);
+          if (!indices.length) {
+            throw new Error("Group tabs missing indices");
+          }
+          insertIndex = Math.max(...indices) + 1;
+        }
+        if (beforeTabId != null || afterTabId != null) {
+          if (afterGroupTitle) {
+            throw new Error("Only one target position is allowed");
+          }
+          const anchorId = beforeTabId != null ? beforeTabId : afterTabId;
+          const anchorTab = windowSnapshot.tabs.find((tab) => tab.tabId === anchorId);
+          if (!anchorTab) {
+            throw new Error("Anchor tab not found in target window");
+          }
+          const anchorIndex = normalizeTabIndex2(anchorTab.index);
+          if (!Number.isFinite(anchorIndex)) {
+            throw new Error("Anchor tab index unavailable");
+          }
+          insertIndex = beforeTabId != null ? anchorIndex : anchorIndex + 1;
+        }
+        let nextIndex = insertIndex;
+        for (const url of urls) {
+          try {
+            const createOptions = { windowId, url, active: false };
+            if (nextIndex != null) {
+              createOptions.index = nextIndex;
+              nextIndex += 1;
+            }
+            const tab = await chrome.tabs.create(createOptions);
+            created.push({
+              tabId: tab.id,
+              windowId: tab.windowId,
+              index: tab.index,
+              url: tab.url,
+              title: tab.title
+            });
+          } catch (error) {
+            skipped.push({ url, reason: "create_failed" });
+          }
+        }
+        let groupId = null;
+        if (groupTitle && created.length > 0) {
+          try {
+            const tabIds = created.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+            if (tabIds.length > 0) {
+              groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId } });
+              const update = { title: groupTitle };
+              if (groupColor) {
+                update.color = groupColor;
+              }
+              await chrome.tabGroups.update(groupId, update);
+            }
+          } catch (error) {
+            deps2.log("Failed to create group", error);
+            groupId = null;
+          }
+        }
+        return {
+          windowId,
+          groupId,
+          groupTitle: groupTitle || null,
+          afterGroupTitle: afterGroupTitle || null,
+          insertIndex,
+          created,
+          skipped,
+          summary: {
+            createdTabs: created.length,
+            skippedUrls: skipped.length,
+            grouped: Boolean(groupId)
+          }
+        };
+      }
+    }
+  });
+
+  // dist/extension/lib/move.js
+  var require_move = __commonJS({
+    "dist/extension/lib/move.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.resolveMoveTarget = resolveMoveTarget;
+      exports.moveTab = moveTab;
+      exports.moveGroup = moveGroup;
+      var tabs2 = require_tabs();
+      var { normalizeTabIndex: normalizeTabIndex2 } = tabs2;
+      function resolveMoveTarget(snapshot, params, deps2) {
+        const beforeTabId = Number(params.beforeTabId);
+        const afterTabId = Number(params.afterTabId);
+        const beforeGroupTitle = typeof params.beforeGroupTitle === "string" ? params.beforeGroupTitle.trim() : "";
+        const afterGroupTitle = typeof params.afterGroupTitle === "string" ? params.afterGroupTitle.trim() : "";
+        const targets = [
+          Number.isFinite(beforeTabId) ? "before-tab" : null,
+          Number.isFinite(afterTabId) ? "after-tab" : null,
+          beforeGroupTitle ? "before-group" : null,
+          afterGroupTitle ? "after-group" : null
+        ].filter(Boolean);
+        if (targets.length === 0) {
+          return { error: { message: "Missing target position (--before/--after)" } };
+        }
+        if (targets.length > 1) {
+          return { error: { message: "Only one target position is allowed" } };
+        }
+        const windows = snapshot.windows;
+        const findTab = (tabId) => {
+          for (const win of windows) {
+            const tab = win.tabs.find((entry) => entry.tabId === tabId);
+            if (tab) {
+              return { tab, windowId: win.windowId };
+            }
+          }
+          return null;
+        };
+        if (targets[0] === "before-tab" || targets[0] === "after-tab") {
+          const tabId = targets[0] === "before-tab" ? beforeTabId : afterTabId;
+          if (!Number.isFinite(tabId)) {
+            return { error: { message: "Invalid tab target" } };
+          }
+          const match2 = findTab(tabId);
+          if (!match2) {
+            return { error: { message: "Target tab not found" } };
+          }
+          const index = normalizeTabIndex2(match2.tab.index);
+          if (!Number.isFinite(index)) {
+            return { error: { message: "Target tab index unavailable" } };
+          }
+          return {
+            windowId: match2.windowId,
+            index: targets[0] === "before-tab" ? index : index + 1,
+            anchor: { type: "tab", tabId }
+          };
+        }
+        const groupTitle = targets[0] === "before-group" ? beforeGroupTitle : afterGroupTitle;
+        const windowId = Number.isFinite(params.windowId) ? Number(params.windowId) : void 0;
+        const resolved = deps2.resolveGroupByTitle(snapshot, groupTitle, windowId);
+        if (resolved.error) {
+          return resolved;
+        }
+        const match = resolved.match;
+        if (!match.tabs.length) {
+          return { error: { message: "Target group has no tabs" } };
+        }
+        const indices = match.tabs.map((tab) => normalizeTabIndex2(tab.index)).filter((value) => value != null);
+        if (!indices.length) {
+          return { error: { message: "Target group indices unavailable" } };
+        }
+        const minIndex = Math.min(...indices);
+        const maxIndex = Math.max(...indices);
+        return {
+          windowId: match.windowId,
+          index: targets[0] === "before-group" ? minIndex : maxIndex + 1,
+          anchor: { type: "group", groupId: match.group.groupId, groupTitle }
+        };
+      }
+      async function moveTab(params, deps2) {
+        const tabIds = Array.isArray(params.tabIds) ? params.tabIds.map(Number) : [];
+        const tabId = Number.isFinite(params.tabId) ? Number(params.tabId) : tabIds.length ? Number(tabIds[0]) : null;
+        if (!tabId) {
+          throw new Error("Missing tabId");
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const windows = snapshot.windows;
+        const sourceWindow = windows.find((win) => win.tabs.some((tab) => tab.tabId === tabId));
+        if (!sourceWindow) {
+          throw new Error("Source tab not found");
+        }
+        const sourceTab = sourceWindow.tabs.find((tab) => tab.tabId === tabId);
+        if (!sourceTab) {
+          throw new Error("Source tab not found");
+        }
+        const newWindow = params.newWindow === true;
+        const hasTarget = Number.isFinite(params.beforeTabId) || Number.isFinite(params.afterTabId) || typeof params.beforeGroupTitle === "string" && params.beforeGroupTitle.trim() || typeof params.afterGroupTitle === "string" && params.afterGroupTitle.trim();
+        if (newWindow) {
+          if (hasTarget) {
+            throw new Error("Cannot combine --new-window with --before/--after");
+          }
+          const createdWindow = await chrome.windows.create({ tabId, focused: false });
+          const targetWindowId2 = createdWindow.id;
+          let targetIndex2 = 0;
+          const createdTab = createdWindow.tabs?.find((tab) => tab.id === tabId) || null;
+          if (createdTab && Number.isFinite(createdTab.index)) {
+            targetIndex2 = createdTab.index;
+          } else {
+            try {
+              const updated = await chrome.tabs.get(tabId);
+              targetIndex2 = updated.index;
+            } catch {
+              targetIndex2 = 0;
+            }
+          }
+          return {
+            tabId,
+            from: { windowId: sourceWindow.windowId, index: sourceTab.index },
+            to: { windowId: targetWindowId2, index: targetIndex2 },
+            summary: { movedTabs: 1 },
+            undo: {
+              action: "move-tab",
+              tabId,
+              from: {
+                windowId: sourceWindow.windowId,
+                index: sourceTab.index,
+                groupId: sourceTab.groupId,
+                groupTitle: sourceTab.groupTitle,
+                groupColor: sourceTab.groupColor,
+                groupCollapsed: sourceTab.groupCollapsed ?? null
+              },
+              to: {
+                windowId: targetWindowId2,
+                index: targetIndex2
+              }
+            },
+            txid: params.txid || null
+          };
+        }
+        let normalizedParams = params;
+        if (params.windowId != null) {
+          const resolvedWindowId = deps2.resolveWindowIdFromParams(snapshot, params.windowId);
+          normalizedParams = { ...params, windowId: resolvedWindowId ?? void 0 };
+        }
+        const target = resolveMoveTarget(snapshot, normalizedParams, deps2);
+        if (target.error) {
+          throw target.error;
+        }
+        const targetWindowId = target.windowId;
+        let targetIndex = target.index;
+        const sourceIndex = normalizeTabIndex2(sourceTab.index);
+        if (Number.isFinite(sourceIndex) && sourceWindow.windowId === targetWindowId && sourceIndex < targetIndex) {
+          targetIndex -= 1;
+        }
+        const moved = await chrome.tabs.move(tabId, { windowId: targetWindowId, index: targetIndex });
+        return {
+          tabId,
+          from: { windowId: sourceWindow.windowId, index: sourceTab.index },
+          to: { windowId: targetWindowId, index: moved.index },
+          summary: { movedTabs: 1 },
+          undo: {
+            action: "move-tab",
+            tabId,
+            from: {
+              windowId: sourceWindow.windowId,
+              index: sourceTab.index,
+              groupId: sourceTab.groupId,
+              groupTitle: sourceTab.groupTitle,
+              groupColor: sourceTab.groupColor,
+              groupCollapsed: sourceTab.groupCollapsed ?? null
+            },
+            to: {
+              windowId: targetWindowId,
+              index: moved.index
+            }
+          },
+          txid: params.txid || null
+        };
+      }
+      async function moveGroup(params, deps2) {
+        const groupId = Number.isFinite(params.groupId) ? Number(params.groupId) : null;
+        const groupTitle = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+        if (!groupId && !groupTitle) {
+          throw new Error("Missing group identifier");
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const windowIdParam = params.windowId != null ? deps2.resolveWindowIdFromParams(snapshot, params.windowId) ?? void 0 : void 0;
+        const resolvedGroup = groupId != null ? deps2.resolveGroupById(snapshot, groupId) : deps2.resolveGroupByTitle(snapshot, groupTitle, windowIdParam);
+        if (resolvedGroup.error) {
+          throw resolvedGroup.error;
+        }
+        const source = resolvedGroup.match;
+        if (!source.tabs.length) {
+          throw new Error("Group has no tabs to move");
+        }
+        const newWindow = params.newWindow === true;
+        const hasTarget = Number.isFinite(params.beforeTabId) || Number.isFinite(params.afterTabId) || typeof params.beforeGroupTitle === "string" && params.beforeGroupTitle.trim() || typeof params.afterGroupTitle === "string" && params.afterGroupTitle.trim();
+        if (newWindow) {
+          if (hasTarget) {
+            throw new Error("Cannot combine --new-window with --before/--after");
+          }
+          const tabIds2 = source.tabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+          const [firstTabId, ...restTabIds] = tabIds2;
+          if (!firstTabId) {
+            throw new Error("Group has no tabs to move");
+          }
+          const createdWindow = await chrome.windows.create({ tabId: firstTabId, focused: false });
+          const targetWindowId2 = createdWindow.id;
+          if (restTabIds.length > 0) {
+            await chrome.tabs.move(restTabIds, { windowId: targetWindowId2, index: -1 });
+          }
+          let newGroupId2 = null;
+          try {
+            newGroupId2 = await chrome.tabs.group({ tabIds: tabIds2, createProperties: { windowId: targetWindowId2 } });
+            await chrome.tabGroups.update(newGroupId2, {
+              title: source.group.title || "",
+              color: source.group.color || "grey",
+              collapsed: source.group.collapsed || false
+            });
+          } catch (error) {
+            deps2.log("Failed to regroup tabs", error);
+          }
+          const undoTabs2 = source.tabs.map((tab) => ({
+            tabId: tab.tabId,
+            windowId: tab.windowId,
+            index: tab.index,
+            groupId: tab.groupId,
+            groupTitle: tab.groupTitle,
+            groupColor: tab.groupColor,
+            groupCollapsed: source.group.collapsed ?? null
+          })).filter((tab) => typeof tab.tabId === "number");
+          return {
+            groupId: source.group.groupId,
+            windowId: source.windowId,
+            movedToWindowId: targetWindowId2,
+            newGroupId: newGroupId2,
+            summary: { movedTabs: tabIds2.length },
+            undo: {
+              action: "move-group",
+              groupId: source.group.groupId,
+              windowId: source.windowId,
+              movedToWindowId: targetWindowId2,
+              groupTitle: source.group.title ?? null,
+              groupColor: source.group.color ?? null,
+              groupCollapsed: source.group.collapsed ?? null,
+              tabs: undoTabs2
+            },
+            txid: params.txid || null
+          };
+        }
+        const target = resolveMoveTarget(snapshot, params, deps2);
+        if (target.error) {
+          throw target.error;
+        }
+        if (target.anchor?.type === "tab") {
+          const anchorTabId = target.anchor.tabId;
+          if (source.tabs.some((tab) => tab.tabId === anchorTabId)) {
+            throw new Error("Target tab is within the source group");
+          }
+        }
+        if (target.anchor?.type === "group") {
+          const anchorGroupId = target.anchor.groupId;
+          if (anchorGroupId === source.group.groupId && source.windowId === target.windowId) {
+            throw new Error("Target group matches source group");
+          }
+        }
+        const tabIds = source.tabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+        const indices = source.tabs.map((tab) => normalizeTabIndex2(tab.index)).filter((value) => value != null);
+        const minIndex = Math.min(...indices);
+        const maxIndex = Math.max(...indices);
+        const targetWindowId = target.windowId;
+        let targetIndex = target.index;
+        if (source.windowId === targetWindowId && targetIndex > maxIndex) {
+          targetIndex -= tabIds.length;
+        }
+        const moved = await chrome.tabs.move(tabIds, { windowId: targetWindowId, index: targetIndex });
+        const movedList = Array.isArray(moved) ? moved : [moved];
+        let newGroupId = null;
+        if (targetWindowId !== source.windowId) {
+          try {
+            const movedIds = movedList.map((tab) => tab.id).filter((id) => typeof id === "number");
+            if (movedIds.length > 0) {
+              newGroupId = await chrome.tabs.group({ tabIds: movedIds, createProperties: { windowId: targetWindowId } });
+              await chrome.tabGroups.update(newGroupId, {
+                title: source.group.title || "",
+                color: source.group.color || "grey",
+                collapsed: source.group.collapsed || false
+              });
+            }
+          } catch (error) {
+            deps2.log("Failed to regroup tabs", error);
+          }
+        }
+        const undoTabs = source.tabs.map((tab) => ({
+          tabId: tab.tabId,
+          windowId: tab.windowId,
+          index: tab.index,
+          groupId: tab.groupId,
+          groupTitle: tab.groupTitle,
+          groupColor: tab.groupColor,
+          groupCollapsed: source.group.collapsed ?? null
+        })).filter((tab) => typeof tab.tabId === "number");
+        return {
+          groupId: source.group.groupId,
+          windowId: source.windowId,
+          movedToWindowId: targetWindowId,
+          newGroupId,
+          summary: { movedTabs: tabIds.length },
+          undo: {
+            action: "move-group",
+            groupId: source.group.groupId,
+            windowId: source.windowId,
+            movedToWindowId: targetWindowId,
+            groupTitle: source.group.title ?? null,
+            groupColor: source.group.color ?? null,
+            groupCollapsed: source.group.collapsed ?? null,
+            tabs: undoTabs
+          },
+          txid: params.txid || null
+        };
+      }
+    }
+  });
+
+  // dist/extension/lib/inspect.js
+  var require_inspect = __commonJS({
+    "dist/extension/lib/inspect.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.SELECTOR_VALUE_MAX_LENGTH = exports.DESCRIPTION_MAX_LENGTH = exports.DEFAULT_STALE_DAYS = void 0;
+      exports.analyzeTabs = analyzeTabs;
+      exports.inspectTabs = inspectTabs;
+      var content2 = require_content();
+      var { isScriptableUrl: isScriptableUrl2, isGitHubIssueOrPr: isGitHubIssueOrPr2, detectGitHubState: detectGitHubState2, extractPageMeta: extractPageMeta2, extractSelectorSignal: extractSelectorSignal2, waitForSettle: waitForSettle2, waitForTabReady: waitForTabReady2 } = content2;
+      var tabs2 = require_tabs();
+      var { normalizeUrl } = tabs2;
+      exports.DEFAULT_STALE_DAYS = 30;
+      exports.DESCRIPTION_MAX_LENGTH = 250;
+      exports.SELECTOR_VALUE_MAX_LENGTH = 500;
+      async function analyzeTabs(params, requestId, deps2) {
+        const staleDays = Number.isFinite(params.staleDays) ? params.staleDays : exports.DEFAULT_STALE_DAYS;
+        const checkGitHub = params.checkGitHub === true;
+        const githubConcurrencyRaw = Number(params.githubConcurrency);
+        const githubConcurrency = Number.isFinite(githubConcurrencyRaw) && githubConcurrencyRaw > 0 ? Math.min(10, Math.floor(githubConcurrencyRaw)) : 4;
+        const githubTimeoutRaw = Number(params.githubTimeoutMs);
+        const githubTimeoutMs = Number.isFinite(githubTimeoutRaw) && githubTimeoutRaw > 0 ? Math.floor(githubTimeoutRaw) : 4e3;
+        const progressEnabled = params.progress === true;
+        const snapshot = await deps2.getTabSnapshot();
+        const selection = deps2.selectTabsByScope(snapshot, params);
+        if (selection.error) {
+          throw selection.error;
+        }
+        const selectedTabs = selection.tabs;
+        const scopeTabs = selectedTabs;
+        const now = Date.now();
+        const startedAt = Date.now();
+        let githubChecked = 0;
+        let githubTotal = 0;
+        let githubMatched = 0;
+        const normalizedMap = /* @__PURE__ */ new Map();
+        const duplicates = /* @__PURE__ */ new Map();
+        for (const tab of scopeTabs) {
+          const normalized = normalizeUrl(tab.url);
+          if (!normalized) {
+            continue;
+          }
+          if (normalizedMap.has(normalized)) {
+            const existing = normalizedMap.get(normalized);
+            duplicates.set(tab.tabId, existing.tabId);
+          } else {
+            normalizedMap.set(normalized, tab);
+          }
+        }
+        const candidateMap = /* @__PURE__ */ new Map();
+        const addReason = (tab, reason) => {
+          const tabId = tab.tabId;
+          const entry = candidateMap.get(tabId) || { tab, reasons: [] };
+          entry.reasons.push(reason);
+          candidateMap.set(tabId, entry);
+        };
+        for (const tab of selectedTabs) {
+          if (duplicates.has(tab.tabId)) {
+            addReason(tab, {
+              type: "duplicate",
+              detail: `Matches tab ${duplicates.get(tab.tabId)}`
+            });
+          }
+          if (tab.lastFocusedAt) {
+            const ageDays = (now - tab.lastFocusedAt) / (24 * 60 * 60 * 1e3);
+            if (ageDays >= staleDays) {
+              addReason(tab, {
+                type: "stale",
+                detail: `Last focused ${Math.floor(ageDays)} days ago`
+              });
+            }
+          }
+        }
+        const githubTabs = checkGitHub ? selectedTabs.filter((tab) => isGitHubIssueOrPr2(tab.url) && isScriptableUrl2(tab.url)) : [];
+        githubTotal = githubTabs.length;
+        if (checkGitHub && githubTabs.length > 0) {
+          let index = 0;
+          const total = githubTabs.length;
+          const workers = Array.from({ length: Math.min(githubConcurrency, total) }, async () => {
+            while (true) {
+              const currentIndex = index;
+              if (currentIndex >= total) {
+                return;
+              }
+              index += 1;
+              const tab = githubTabs[currentIndex];
+              const state2 = await detectGitHubState2(tab.tabId, githubTimeoutMs);
+              githubChecked += 1;
+              if (state2 === "closed" || state2 === "merged") {
+                githubMatched += 1;
+                addReason(tab, {
+                  type: "closed_issue",
+                  detail: `GitHub state: ${state2}`
+                });
+              }
+              if (progressEnabled) {
+                deps2.sendProgress(requestId, {
+                  phase: "github",
+                  processed: githubChecked,
+                  total,
+                  matched: githubMatched,
+                  tabId: tab.tabId,
+                  timeoutMs: githubTimeoutMs
+                });
+              }
+            }
+          });
+          await Promise.all(workers);
+        }
+        const candidates = Array.from(candidateMap.values()).map((entry) => {
+          const reasons = entry.reasons;
+          const severity = reasons.some((reason) => reason.type === "duplicate" || reason.type === "closed_issue") ? "high" : "medium";
+          return {
+            tabId: entry.tab.tabId,
+            windowId: entry.tab.windowId,
+            groupId: entry.tab.groupId,
+            url: entry.tab.url,
+            title: entry.tab.title,
+            lastFocusedAt: entry.tab.lastFocusedAt,
+            reasons,
+            severity
+          };
+        });
+        return {
+          generatedAt: Date.now(),
+          staleDays,
+          totals: {
+            tabs: scopeTabs.length,
+            analyzed: selectedTabs.length,
+            candidates: candidates.length
+          },
+          meta: {
+            durationMs: Date.now() - startedAt,
+            githubChecked,
+            githubTotal,
+            githubMatched,
+            githubTimeoutMs
+          },
+          candidates
+        };
+      }
+      async function inspectTabs(params, requestId, deps2) {
+        const signalList = Array.isArray(params.signals) && params.signals.length > 0 ? params.signals.map(String) : ["page-meta"];
+        const signalConcurrencyRaw = Number(params.signalConcurrency);
+        const signalConcurrency = Number.isFinite(signalConcurrencyRaw) && signalConcurrencyRaw > 0 ? Math.min(10, Math.floor(signalConcurrencyRaw)) : 4;
+        const signalTimeoutRaw = Number(params.signalTimeoutMs);
+        const signalTimeoutMs = Number.isFinite(signalTimeoutRaw) && signalTimeoutRaw > 0 ? Math.floor(signalTimeoutRaw) : 4e3;
+        const progressEnabled = params.progress === true;
+        const waitFor = typeof params.waitFor === "string" ? params.waitFor.trim().toLowerCase() : "";
+        if (waitFor === "settle" && Array.isArray(params.tabIds) && params.tabIds.length > 0) {
+          const waitTimeoutRaw = Number(params.waitTimeoutMs);
+          const waitTimeoutMs = Number.isFinite(waitTimeoutRaw) && waitTimeoutRaw > 0 ? Math.floor(waitTimeoutRaw) : signalTimeoutMs;
+          const tabIds = params.tabIds.map(Number).filter(Number.isFinite);
+          await Promise.all(tabIds.map((id) => waitForSettle2(id, waitTimeoutMs)));
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const selection = deps2.selectTabsByScope(snapshot, params);
+        if (selection.error) {
+          throw selection.error;
+        }
+        const tabs3 = selection.tabs;
+        const startedAt = Date.now();
+        const selectorSpecs = [];
+        if (Array.isArray(params.selectorSpecs)) {
+          selectorSpecs.push(...params.selectorSpecs);
+        }
+        if (params.signalConfig && typeof params.signalConfig === "object") {
+          const config = params.signalConfig;
+          if (Array.isArray(config.selectors)) {
+            selectorSpecs.push(...config.selectors);
+          }
+          if (config.signals && typeof config.signals === "object") {
+            const signals = config.signals;
+            const selectorConfig = signals.selector;
+            if (selectorConfig && Array.isArray(selectorConfig.selectors)) {
+              selectorSpecs.push(...selectorConfig.selectors);
+            }
+          }
+        }
+        const normalizedSelectors = selectorSpecs.filter((spec) => spec && typeof spec.selector === "string" && spec.selector.length > 0).map((spec) => ({
+          name: typeof spec.name === "string" ? spec.name : void 0,
+          selector: spec.selector,
+          attr: typeof spec.attr === "string" ? spec.attr : "text",
+          all: Boolean(spec.all),
+          text: typeof spec.text === "string" && spec.text.trim() ? spec.text.trim() : void 0,
+          textMode: typeof spec.textMode === "string" ? spec.textMode.trim().toLowerCase() : void 0
+        }));
+        const selectorWarnings = normalizedSelectors.filter((spec) => typeof spec.selector === "string" && spec.selector.includes(":contains(")).map((spec) => ({
+          name: spec.name || spec.selector,
+          hint: "CSS :contains() is not supported; use selector text filters or a different selector."
+        }));
+        const signalDefs = [];
+        for (const signalId of signalList) {
+          if (signalId === "github-state") {
+            signalDefs.push({
+              id: signalId,
+              match: (tab) => isGitHubIssueOrPr2(tab.url) && isScriptableUrl2(tab.url),
+              run: async (tabId) => {
+                const state2 = await detectGitHubState2(tabId, signalTimeoutMs);
+                return state2 ? { state: state2 } : null;
+              }
+            });
+          } else if (signalId === "page-meta") {
+            signalDefs.push({
+              id: signalId,
+              match: (tab) => isScriptableUrl2(tab.url),
+              run: async (tabId) => extractPageMeta2(tabId, signalTimeoutMs, exports.DESCRIPTION_MAX_LENGTH)
+            });
+          } else if (signalId === "selector") {
+            signalDefs.push({
+              id: signalId,
+              match: (tab) => isScriptableUrl2(tab.url),
+              run: async (tabId) => extractSelectorSignal2(tabId, normalizedSelectors, signalTimeoutMs, exports.SELECTOR_VALUE_MAX_LENGTH)
+            });
+          }
+        }
+        const tasks = [];
+        for (const tab of tabs3) {
+          for (const signal of signalDefs) {
+            if (signal.match(tab)) {
+              tasks.push({ tab, signal });
+            }
+          }
+        }
+        const totalTasks = tasks.length;
+        let completedTasks = 0;
+        const entryMap = /* @__PURE__ */ new Map();
+        const workerCount = Math.min(signalConcurrency, totalTasks || 1);
+        let index = 0;
+        const workers = Array.from({ length: workerCount }, async () => {
+          while (true) {
+            const currentIndex = index;
+            if (currentIndex >= totalTasks) {
+              return;
+            }
+            index += 1;
+            const task = tasks[currentIndex];
+            const tabId = task.tab.tabId;
+            let result = null;
+            let error = null;
+            const started = Date.now();
+            try {
+              await waitForTabReady2(tabId, params, signalTimeoutMs);
+              result = await task.signal.run(tabId);
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "signal_error";
+              error = message;
+            }
+            const durationMs = Date.now() - started;
+            const entry = entryMap.get(tabId) || { tab: task.tab, signals: {} };
+            entry.signals[task.signal.id] = {
+              ok: error === null,
+              durationMs,
+              data: result,
+              error
+            };
+            entryMap.set(tabId, entry);
+            completedTasks += 1;
+            if (progressEnabled) {
+              deps2.sendProgress(requestId, {
+                phase: "inspect",
+                processed: completedTasks,
+                total: totalTasks,
+                signalId: task.signal.id,
+                tabId
+              });
+            }
+          }
+        });
+        await Promise.all(workers);
+        const entries = Array.from(entryMap.values()).map((entry) => ({
+          tabId: entry.tab.tabId,
+          windowId: entry.tab.windowId,
+          groupId: entry.tab.groupId,
+          url: entry.tab.url,
+          title: entry.tab.title,
+          signals: entry.signals
+        }));
+        return {
+          generatedAt: Date.now(),
+          totals: {
+            tabs: tabs3.length,
+            signals: signalDefs.length,
+            tasks: totalTasks
+          },
+          meta: {
+            durationMs: Date.now() - startedAt,
+            signalTimeoutMs,
+            selectorCount: normalizedSelectors.length,
+            selectorWarnings: selectorWarnings.length > 0 ? selectorWarnings : void 0
+          },
+          entries
+        };
+      }
+    }
+  });
+
+  // dist/extension/lib/undo-handlers.js
+  var require_undo_handlers = __commonJS({
+    "dist/extension/lib/undo-handlers.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.undoGroupUpdate = undoGroupUpdate;
+      exports.undoGroupUngroup = undoGroupUngroup;
+      exports.undoGroupAssign = undoGroupAssign;
+      exports.undoMoveTab = undoMoveTab;
+      exports.undoMoveGroup = undoMoveGroup;
+      exports.undoMergeWindow = undoMergeWindow;
+      exports.undoArchive = undoArchive;
+      exports.undoClose = undoClose;
+      exports.undoTransaction = undoTransaction;
+      async function ensureWindow(windowId) {
+        if (windowId) {
+          try {
+            const existing = await chrome.windows.get(windowId);
+            if (existing) {
+              return windowId;
+            }
+          } catch {
+          }
+        }
+        const created = await chrome.windows.create({ focused: false });
+        return created.id;
+      }
+      async function restoreTabsFromUndo(entries, deps2) {
+        const skipped = [];
+        const restored = [];
+        const windowMap = /* @__PURE__ */ new Map();
+        for (const entry of entries) {
+          const tabId = Number(entry.tabId);
+          if (!Number.isFinite(tabId)) {
+            skipped.push({ tabId: entry.tabId, reason: "missing_tab" });
+            continue;
+          }
+          const sourceWindowId = Number(entry.windowId);
+          if (!Number.isFinite(sourceWindowId)) {
+            skipped.push({ tabId, reason: "missing_window" });
+            continue;
+          }
+          let targetWindowId = windowMap.get(sourceWindowId);
+          if (!targetWindowId) {
+            targetWindowId = await ensureWindow(sourceWindowId);
+            windowMap.set(sourceWindowId, targetWindowId);
+          }
+          try {
+            await chrome.tabs.move(tabId, { windowId: targetWindowId, index: -1 });
+            restored.push({ tabId, entry, targetWindowId });
+          } catch {
+            skipped.push({ tabId, reason: "move_failed" });
+          }
+        }
+        const groupsByWindow = /* @__PURE__ */ new Map();
+        for (const item of restored) {
+          const entry = item.entry;
+          const rawGroupId = typeof entry.groupId === "number" ? entry.groupId : null;
+          const groupId = rawGroupId != null && rawGroupId !== -1 ? rawGroupId : null;
+          const groupTitle = typeof entry.groupTitle === "string" ? entry.groupTitle : null;
+          if (!groupId && !groupTitle) {
+            continue;
+          }
+          const groupKey = groupId != null ? `id:${groupId}` : `title:${groupTitle}`;
+          const key = `${item.targetWindowId}:${groupKey}`;
+          if (!groupsByWindow.has(key)) {
+            groupsByWindow.set(key, {
+              windowId: item.targetWindowId,
+              groupId,
+              groupTitle,
+              groupColor: typeof entry.groupColor === "string" ? entry.groupColor : null,
+              groupCollapsed: typeof entry.groupCollapsed === "boolean" ? entry.groupCollapsed : null,
+              tabIds: []
+            });
+          }
+          groupsByWindow.get(key)?.tabIds.push(item.tabId);
+        }
+        for (const group of groupsByWindow.values()) {
+          if (group.tabIds.length === 0) {
+            continue;
+          }
+          let targetGroupId = null;
+          if (group.groupId != null) {
+            try {
+              targetGroupId = await chrome.tabs.group({ groupId: group.groupId, tabIds: group.tabIds });
+            } catch {
+              targetGroupId = null;
+            }
+          }
+          if (targetGroupId == null) {
+            try {
+              targetGroupId = await chrome.tabs.group({
+                tabIds: group.tabIds,
+                createProperties: { windowId: group.windowId }
+              });
+            } catch (error) {
+              deps2.log("Failed to regroup tabs", error);
+              continue;
+            }
+          }
+          const update = {};
+          if (typeof group.groupTitle === "string") {
+            update.title = group.groupTitle;
+          }
+          if (typeof group.groupColor === "string" && group.groupColor) {
+            update.color = group.groupColor;
+          }
+          if (typeof group.groupCollapsed === "boolean") {
+            update.collapsed = group.groupCollapsed;
+          }
+          if (Object.keys(update).length > 0) {
+            try {
+              await chrome.tabGroups.update(targetGroupId, update);
+            } catch (error) {
+              deps2.log("Failed to update restored group", error);
+            }
+          }
+        }
+        const orderByWindow = /* @__PURE__ */ new Map();
+        for (const item of restored) {
+          const index = Number(item.entry.index);
+          if (!Number.isFinite(index)) {
+            continue;
+          }
+          if (!orderByWindow.has(item.targetWindowId)) {
+            orderByWindow.set(item.targetWindowId, []);
+          }
+          orderByWindow.get(item.targetWindowId)?.push({ tabId: item.tabId, index });
+        }
+        for (const [targetWindowId, items] of orderByWindow.entries()) {
+          const ordered = [...items].sort((a, b) => a.index - b.index);
+          for (const item of ordered) {
+            try {
+              await chrome.tabs.move(item.tabId, { windowId: targetWindowId, index: item.index });
+            } catch {
+            }
+          }
+        }
+        return {
+          summary: {
+            restoredTabs: restored.length,
+            skippedTabs: skipped.length
+          },
+          skipped
+        };
+      }
+      async function undoGroupUpdate(undo) {
+        const groupId = Number(undo.groupId);
+        if (!Number.isFinite(groupId)) {
+          return {
+            summary: { restoredGroups: 0, skippedGroups: 1 },
+            skipped: [{ groupId: undo.groupId, reason: "missing_group" }]
+          };
+        }
+        const previous = undo.previous || {};
+        const update = {};
+        if (typeof previous.title === "string") {
+          update.title = previous.title;
+        }
+        if (typeof previous.color === "string" && previous.color) {
+          update.color = previous.color;
+        }
+        if (typeof previous.collapsed === "boolean") {
+          update.collapsed = previous.collapsed;
+        }
+        if (!Object.keys(update).length) {
+          return {
+            summary: { restoredGroups: 0, skippedGroups: 1 },
+            skipped: [{ groupId, reason: "missing_values" }]
+          };
+        }
+        try {
+          await chrome.tabGroups.update(groupId, update);
+          return {
+            summary: { restoredGroups: 1, skippedGroups: 0 },
+            skipped: []
+          };
+        } catch {
+          return {
+            summary: { restoredGroups: 0, skippedGroups: 1 },
+            skipped: [{ groupId, reason: "update_failed" }]
+          };
+        }
+      }
+      async function undoGroupUngroup(undo, deps2) {
+        const tabs2 = undo.tabs || [];
+        return await restoreTabsFromUndo(tabs2, deps2);
+      }
+      async function undoGroupAssign(undo, deps2) {
+        const tabs2 = undo.tabs || [];
+        return await restoreTabsFromUndo(tabs2, deps2);
+      }
+      async function undoMoveTab(undo, deps2) {
+        const from = undo.from || {};
+        const entry = {
+          tabId: undo.tabId,
+          windowId: from.windowId,
+          index: from.index,
+          groupId: from.groupId,
+          groupTitle: from.groupTitle,
+          groupColor: from.groupColor,
+          groupCollapsed: from.groupCollapsed
+        };
+        return await restoreTabsFromUndo([entry], deps2);
+      }
+      async function undoMoveGroup(undo, deps2) {
+        const tabs2 = undo.tabs || [];
+        return await restoreTabsFromUndo(tabs2, deps2);
+      }
+      async function undoMergeWindow(undo, deps2) {
+        const tabs2 = undo.tabs || [];
+        return await restoreTabsFromUndo(tabs2, deps2);
+      }
+      async function undoArchive(undo, deps2) {
+        const tabs2 = undo.tabs || [];
+        const restored = [];
+        const skipped = [];
+        const windowMap = /* @__PURE__ */ new Map();
+        for (const entry of tabs2) {
+          if (!entry.tabId) {
+            skipped.push({ tabId: entry.tabId, reason: "missing_tab" });
+            continue;
+          }
+          let targetWindowId = windowMap.get(entry.from.windowId);
+          if (!targetWindowId) {
+            targetWindowId = await ensureWindow(entry.from.windowId);
+            windowMap.set(entry.from.windowId, targetWindowId);
+          }
+          try {
+            await chrome.tabs.move(entry.tabId, { windowId: targetWindowId, index: -1 });
+            restored.push({ tabId: entry.tabId, targetWindowId });
+          } catch {
+            skipped.push({ tabId: entry.tabId, reason: "move_failed" });
+          }
+        }
+        const restoredSet = new Set(restored.map((item) => item.tabId));
+        const groupsByWindow = /* @__PURE__ */ new Map();
+        for (const entry of tabs2) {
+          if (!restoredSet.has(entry.tabId)) {
+            continue;
+          }
+          const targetWindowId = windowMap.get(entry.from.windowId) || entry.from.windowId;
+          const hasGroupId = entry.from.groupId != null && entry.from.groupId !== -1;
+          const hasGroupTitle = entry.from.groupTitle != null;
+          if (!hasGroupId && !hasGroupTitle) {
+            continue;
+          }
+          const groupKey = hasGroupId ? entry.from.groupId : entry.from.groupTitle;
+          const key = `${targetWindowId}:${groupKey}`;
+          if (!groupsByWindow.has(key)) {
+            groupsByWindow.set(key, []);
+          }
+          groupsByWindow.get(key)?.push(entry);
+        }
+        for (const [key, groupTabs] of groupsByWindow.entries()) {
+          const [windowIdPart] = key.split(":");
+          const targetWindowId = Number(windowIdPart);
+          const tabIds = groupTabs.map((entry) => entry.tabId).filter(Boolean);
+          if (!tabIds.length) {
+            continue;
+          }
+          try {
+            const groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId: targetWindowId } });
+            await chrome.tabGroups.update(groupId, {
+              title: groupTabs[0].from.groupTitle || "",
+              color: groupTabs[0].from.groupColor || "grey",
+              collapsed: groupTabs[0].from.groupCollapsed || false
+            });
+          } catch (error) {
+            deps2.log("Failed to recreate group", error);
+          }
+        }
+        for (const [originalWindowId, targetWindowId] of windowMap.entries()) {
+          const windowTabs = tabs2.filter((entry) => entry.from.windowId === originalWindowId && restoredSet.has(entry.tabId)).sort((a, b) => a.from.index - b.from.index);
+          for (const entry of windowTabs) {
+            if (!entry.tabId) {
+              continue;
+            }
+            try {
+              await chrome.tabs.move(entry.tabId, { windowId: targetWindowId, index: entry.from.index });
+            } catch {
+            }
+          }
+          const activeTab = windowTabs.find((entry) => entry.active);
+          if (activeTab && activeTab.tabId) {
+            try {
+              await chrome.tabs.update(activeTab.tabId, { active: true });
+            } catch {
+            }
+          }
+        }
+        return {
+          summary: {
+            restoredTabs: restored.length,
+            skippedTabs: skipped.length
+          },
+          skipped
+        };
+      }
+      async function undoClose(undo, deps2) {
+        const tabs2 = undo.tabs || [];
+        const restored = [];
+        const skipped = [];
+        const windowMap = /* @__PURE__ */ new Map();
+        for (const entry of tabs2) {
+          if (!entry.url) {
+            skipped.push({ url: entry.url, reason: "missing_url" });
+            continue;
+          }
+          let targetWindowId = windowMap.get(entry.from.windowId);
+          if (!targetWindowId) {
+            targetWindowId = await ensureWindow(entry.from.windowId);
+            windowMap.set(entry.from.windowId, targetWindowId);
+          }
+          try {
+            const created = await chrome.tabs.create({
+              windowId: targetWindowId,
+              url: entry.url,
+              active: false,
+              pinned: entry.pinned
+            });
+            restored.push({ tabId: created.id, entry });
+          } catch {
+            skipped.push({ url: entry.url, reason: "create_failed" });
+          }
+        }
+        const groupsByWindow = /* @__PURE__ */ new Map();
+        for (const item of restored) {
+          const entry = item.entry;
+          const targetWindowId = windowMap.get(entry.from.windowId) || entry.from.windowId;
+          const hasGroupId = entry.from.groupId != null && entry.from.groupId !== -1;
+          const hasGroupTitle = entry.from.groupTitle != null;
+          if (!hasGroupId && !hasGroupTitle) {
+            continue;
+          }
+          const groupKey = hasGroupId ? entry.from.groupId : entry.from.groupTitle;
+          const key = `${targetWindowId}:${groupKey}`;
+          if (!groupsByWindow.has(key)) {
+            groupsByWindow.set(key, []);
+          }
+          groupsByWindow.get(key)?.push({ tabId: item.tabId, entry });
+        }
+        for (const [key, groupTabs] of groupsByWindow.entries()) {
+          const [windowIdPart] = key.split(":");
+          const targetWindowId = Number(windowIdPart);
+          const tabIds = groupTabs.map((item) => item.tabId).filter(Boolean);
+          if (!tabIds.length) {
+            continue;
+          }
+          try {
+            const groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId: targetWindowId } });
+            await chrome.tabGroups.update(groupId, {
+              title: groupTabs[0].entry.from.groupTitle || "",
+              color: groupTabs[0].entry.from.groupColor || "grey",
+              collapsed: groupTabs[0].entry.from.groupCollapsed || false
+            });
+          } catch (error) {
+            deps2.log("Failed to recreate group", error);
+          }
+        }
+        for (const [originalWindowId, targetWindowId] of windowMap.entries()) {
+          const windowTabs = restored.map((item) => ({ tabId: item.tabId, entry: item.entry })).filter((item) => item.entry.from.windowId === originalWindowId).sort((a, b) => a.entry.from.index - b.entry.from.index);
+          for (const item of windowTabs) {
+            try {
+              await chrome.tabs.move(item.tabId, { windowId: targetWindowId, index: item.entry.from.index });
+            } catch {
+            }
+          }
+          const activeTab = windowTabs.find((item) => item.entry.active);
+          if (activeTab) {
+            try {
+              await chrome.tabs.update(activeTab.tabId, { active: true });
+            } catch {
+            }
+          }
+        }
+        return {
+          summary: {
+            restoredTabs: restored.length,
+            skippedTabs: skipped.length
+          },
+          skipped
+        };
+      }
+      async function undoTransaction(params, deps2) {
+        if (!params.record || !params.record.undo) {
+          throw new Error("Undo record missing");
+        }
+        const undo = params.record.undo;
+        if (undo.action === "archive") {
+          return await undoArchive(undo, deps2);
+        }
+        if (undo.action === "close") {
+          return await undoClose(undo, deps2);
+        }
+        if (undo.action === "group-update") {
+          return await undoGroupUpdate(undo);
+        }
+        if (undo.action === "group-ungroup") {
+          return await undoGroupUngroup(undo, deps2);
+        }
+        if (undo.action === "group-assign") {
+          return await undoGroupAssign(undo, deps2);
+        }
+        if (undo.action === "move-tab") {
+          return await undoMoveTab(undo, deps2);
+        }
+        if (undo.action === "move-group") {
+          return await undoMoveGroup(undo, deps2);
+        }
+        if (undo.action === "merge-window") {
+          return await undoMergeWindow(undo, deps2);
+        }
+        throw new Error(`Unknown undo action: ${undo.action}`);
+      }
+    }
+  });
+
+  // dist/extension/lib/archive.js
+  var require_archive = __commonJS({
+    "dist/extension/lib/archive.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.ensureArchiveWindow = ensureArchiveWindow;
+      exports.archiveTabs = archiveTabs;
+      exports.getTabsByIds = getTabsByIds;
+      exports.closeTabs = closeTabs;
+      exports.mergeWindow = mergeWindow;
+      async function ensureArchiveWindow(deps2) {
+        const archiveWindowId = await deps2.getArchiveWindowId();
+        if (archiveWindowId) {
+          try {
+            await chrome.windows.get(archiveWindowId);
+            return archiveWindowId;
+          } catch {
+            await deps2.setArchiveWindowId(null);
+          }
+        }
+        const created = await chrome.windows.create({ focused: false });
+        await deps2.setArchiveWindowId(created.id);
+        return created.id;
+      }
+      async function archiveTabs(params, deps2) {
+        const snapshot = await deps2.getTabSnapshot();
+        const windowLabels = deps2.buildWindowLabels(snapshot);
+        let windowsToProcess = snapshot.windows;
+        if (params.windowId) {
+          const resolvedWindowId = deps2.resolveWindowIdFromParams(snapshot, params.windowId);
+          windowsToProcess = resolvedWindowId != null ? windowsToProcess.filter((win) => win.windowId === resolvedWindowId) : [];
+        } else if (!params.all) {
+          const focused = windowsToProcess.find((win) => win.focused);
+          windowsToProcess = focused ? [focused] : [];
+        }
+        if (params.groupTitle || params.groupId || params.tabIds) {
+          const selected = deps2.selectTabsByScope(snapshot, params);
+          if (selected.error) {
+            throw selected.error;
+          }
+          windowsToProcess = snapshot.windows.map((win) => ({
+            windowId: win.windowId,
+            focused: win.focused,
+            state: win.state,
+            tabs: win.tabs.filter((tab) => selected.tabs.some((sel) => sel.tabId === tab.tabId)),
+            groups: win.groups
+          })).filter((win) => win.tabs.length > 0);
+        }
+        if (windowsToProcess.length === 0) {
+          return {
+            txid: params.txid || null,
+            summary: { movedTabs: 0, movedGroups: 0, skippedTabs: 0 },
+            archiveWindowId: null,
+            skipped: [],
+            undo: { action: "archive", tabs: [] }
+          };
+        }
+        const archiveWindowId = await ensureArchiveWindow(deps2);
+        const undoTabs = [];
+        const skipped = [];
+        let movedGroups = 0;
+        let movedTabs = 0;
+        for (const window2 of windowsToProcess) {
+          const groupsById = /* @__PURE__ */ new Map();
+          for (const group of window2.groups) {
+            groupsById.set(group.groupId, group);
+          }
+          const groupedTabs = /* @__PURE__ */ new Map();
+          const ungroupedTabs = [];
+          for (const tab of window2.tabs) {
+            if (tab.tabId == null) {
+              continue;
+            }
+            if (tab.groupId === -1) {
+              ungroupedTabs.push(tab);
+            } else {
+              if (!groupedTabs.has(tab.groupId)) {
+                groupedTabs.set(tab.groupId, []);
+              }
+              groupedTabs.get(tab.groupId)?.push(tab);
+            }
+          }
+          const windowLabel = windowLabels.get(window2.windowId) || `W${window2.windowId}`;
+          const plans = [];
+          for (const [groupId, tabs2] of groupedTabs.entries()) {
+            const group = groupsById.get(groupId) || null;
+            plans.push({
+              windowId: window2.windowId,
+              windowLabel,
+              group,
+              tabs: tabs2,
+              isUngrouped: false
+            });
+          }
+          if (ungroupedTabs.length > 0) {
+            plans.push({
+              windowId: window2.windowId,
+              windowLabel,
+              group: null,
+              tabs: ungroupedTabs,
+              isUngrouped: true
+            });
+          }
+          for (const plan of plans) {
+            const tabIds = plan.tabs.map((tab) => tab.tabId);
+            if (tabIds.length === 0) {
+              continue;
+            }
+            const tabById = /* @__PURE__ */ new Map();
+            for (const tab of plan.tabs) {
+              tabById.set(tab.tabId, tab);
+            }
+            let moved;
+            try {
+              moved = await chrome.tabs.move(tabIds, { windowId: archiveWindowId, index: -1 });
+            } catch (error) {
+              for (const tabId of tabIds) {
+                skipped.push({ tabId, reason: "move_failed" });
+              }
+              deps2.log("Failed to move tabs", error);
+              continue;
+            }
+            const movedList = Array.isArray(moved) ? moved : [moved];
+            const movedIds = movedList.map((tab) => tab.id);
+            movedTabs += movedIds.length;
+            for (const movedId of movedIds) {
+              const tab = tabById.get(movedId);
+              if (!tab) {
+                continue;
+              }
+              undoTabs.push({
+                tabId: tab.tabId,
+                url: tab.url,
+                title: tab.title,
+                pinned: tab.pinned,
+                active: tab.active,
+                from: {
+                  windowId: tab.windowId,
+                  index: tab.index,
+                  groupId: tab.groupId,
+                  groupTitle: plan.group ? plan.group.title : null,
+                  groupColor: plan.group ? plan.group.color : null,
+                  groupCollapsed: plan.group ? plan.group.collapsed : null
+                }
+              });
+            }
+            const titleBase = plan.group && plan.group.title ? plan.group.title : plan.isUngrouped ? "Ungrouped" : "Group";
+            const archiveTitle = `${plan.windowLabel} - ${titleBase}`;
+            const groupColor = plan.group && plan.group.color ? plan.group.color : "grey";
+            try {
+              const newGroupId = await chrome.tabs.group({ tabIds: movedIds, createProperties: { windowId: archiveWindowId } });
+              await chrome.tabGroups.update(newGroupId, { title: archiveTitle, color: groupColor });
+              movedGroups += 1;
+            } catch (error) {
+              deps2.log("Failed to group archived tabs", error);
+            }
+          }
+        }
+        return {
+          txid: params.txid || null,
+          summary: {
+            movedTabs,
+            movedGroups,
+            skippedTabs: skipped.length
+          },
+          archiveWindowId,
+          skipped,
+          undo: {
+            action: "archive",
+            tabs: undoTabs
+          }
+        };
+      }
+      async function getTabsByIds(tabIds) {
+        const results = [];
+        for (const tabId of tabIds) {
+          try {
+            const tab = await chrome.tabs.get(tabId);
+            results.push(tab);
+          } catch {
+            results.push(null);
+          }
+        }
+        return results;
+      }
+      async function closeTabs(params, deps2) {
+        const mode = params.mode || "direct";
+        if (mode === "direct" && !params.confirmed) {
+          throw new Error("Direct close requires confirmation");
+        }
+        let tabIds = params.tabIds || [];
+        if (!tabIds.length && (params.groupTitle || params.groupId || params.windowId)) {
+          const snapshot = await deps2.getTabSnapshot();
+          const selection = deps2.selectTabsByScope(snapshot, params);
+          if (selection.error) {
+            throw selection.error;
+          }
+          tabIds = selection.tabs.map((tab) => tab.tabId);
+        }
+        if (!tabIds.length) {
+          return {
+            txid: params.txid || null,
+            summary: { closedTabs: 0, skippedTabs: 0 },
+            skipped: [],
+            undo: { action: "close", tabs: [] }
+          };
+        }
+        const expectedUrls = params.expectedUrls || {};
+        const tabInfos = await getTabsByIds(tabIds);
+        const validTabs = [];
+        const skipped = [];
+        const groups2 = await chrome.tabGroups.query({});
+        const groupById = new Map(groups2.map((group) => [group.id, group]));
+        for (let i = 0; i < tabIds.length; i += 1) {
+          const tabId = tabIds[i];
+          const tab = tabInfos[i];
+          if (!tab) {
+            skipped.push({ tabId, reason: "not_found" });
+            continue;
+          }
+          const expected = expectedUrls[String(tabId)];
+          if (expected && tab.url !== expected) {
+            skipped.push({ tabId, reason: "url_mismatch" });
+            continue;
+          }
+          const group = tab.groupId !== -1 ? groupById.get(tab.groupId) : null;
+          validTabs.push({
+            tabId,
+            url: tab.url,
+            title: tab.title,
+            pinned: tab.pinned,
+            active: tab.active,
+            from: {
+              windowId: tab.windowId,
+              index: tab.index,
+              groupId: tab.groupId,
+              groupTitle: group ? group.title : null,
+              groupColor: group ? group.color : null,
+              groupCollapsed: group ? group.collapsed : null
+            }
+          });
+        }
+        if (validTabs.length > 0) {
+          await chrome.tabs.remove(validTabs.map((tab) => tab.tabId));
+        }
+        return {
+          txid: params.txid || null,
+          summary: {
+            closedTabs: validTabs.length,
+            skippedTabs: skipped.length
+          },
+          skipped,
+          undo: {
+            action: "close",
+            tabs: validTabs.map((tab) => ({
+              url: tab.url,
+              title: tab.title,
+              pinned: tab.pinned,
+              active: tab.active,
+              from: tab.from
+            }))
+          }
+        };
+      }
+      async function mergeWindow(params, deps2) {
+        const fromWindowId = Number.isFinite(params.fromWindowId) ? Number(params.fromWindowId) : Number(params.windowId);
+        const toWindowId = Number.isFinite(params.toWindowId) ? Number(params.toWindowId) : null;
+        if (!Number.isFinite(fromWindowId) || !Number.isFinite(toWindowId)) {
+          throw new Error("Missing source or target window id");
+        }
+        if (fromWindowId === toWindowId) {
+          throw new Error("Source and target windows must differ");
+        }
+        const snapshot = await deps2.getTabSnapshot();
+        const windows = snapshot.windows;
+        const sourceWindow = windows.find((win) => win.windowId === fromWindowId);
+        if (!sourceWindow) {
+          throw new Error("Source window not found");
+        }
+        const targetWindow = windows.find((win) => win.windowId === toWindowId);
+        if (!targetWindow) {
+          throw new Error("Target window not found");
+        }
+        const rawTabIds = Array.isArray(params.tabIds) ? params.tabIds.map(Number) : [];
+        const tabIdSet = new Set(rawTabIds.filter((id) => Number.isFinite(id)));
+        const skipped = [];
+        let selectedTabs = sourceWindow.tabs;
+        if (tabIdSet.size > 0) {
+          const sourceTabIds = new Set(sourceWindow.tabs.map((tab) => tab.tabId).filter((id) => typeof id === "number"));
+          for (const tabId of tabIdSet) {
+            if (!sourceTabIds.has(tabId)) {
+              skipped.push({ tabId, reason: "not_in_source" });
+            }
+          }
+          selectedTabs = sourceWindow.tabs.filter((tab) => tabIdSet.has(tab.tabId));
+        }
+        if (selectedTabs.length === 0) {
+          return {
+            fromWindowId,
+            toWindowId,
+            summary: { movedTabs: 0, movedGroups: 0, skippedTabs: skipped.length, closedSource: false },
+            skipped,
+            groups: [],
+            undo: {
+              action: "merge-window",
+              fromWindowId,
+              toWindowId,
+              closedSource: false,
+              tabs: []
+            }
+          };
+        }
+        const orderedTabs = [...selectedTabs].sort((a, b) => {
+          const aIndex = Number(a.index);
+          const bIndex = Number(b.index);
+          if (!Number.isFinite(aIndex) && !Number.isFinite(bIndex)) {
+            return 0;
+          }
+          if (!Number.isFinite(aIndex)) {
+            return 1;
+          }
+          if (!Number.isFinite(bIndex)) {
+            return -1;
+          }
+          return aIndex - bIndex;
+        });
+        const groupById = /* @__PURE__ */ new Map();
+        for (const group of sourceWindow.groups) {
+          groupById.set(group.groupId, group);
+        }
+        const plans = [];
+        let currentPlan = null;
+        for (const tab of orderedTabs) {
+          const rawGroupId = tab.groupId;
+          const groupId = typeof rawGroupId === "number" && rawGroupId !== -1 ? rawGroupId : null;
+          if (!currentPlan || currentPlan.groupId !== groupId) {
+            currentPlan = { groupId, tabs: [] };
+            plans.push(currentPlan);
+          }
+          currentPlan.tabs.push(tab);
+        }
+        let movedTabs = 0;
+        let movedGroups = 0;
+        const groups2 = [];
+        const undoTabs = [];
+        for (const plan of plans) {
+          const tabIds = plan.tabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+          if (!tabIds.length) {
+            continue;
+          }
+          let moved;
+          try {
+            moved = await chrome.tabs.move(tabIds, { windowId: toWindowId, index: -1 });
+          } catch (error) {
+            for (const tabId of tabIds) {
+              skipped.push({ tabId, reason: "move_failed" });
+            }
+            deps2.log("Failed to move tabs", error);
+            continue;
+          }
+          const movedList = Array.isArray(moved) ? moved : [moved];
+          const movedIds = movedList.map((tab) => tab.id).filter((id) => typeof id === "number");
+          movedTabs += movedIds.length;
+          for (const entry of plan.tabs) {
+            if (typeof entry.tabId !== "number") {
+              continue;
+            }
+            const meta = groupById.get(entry.groupId);
+            undoTabs.push({
+              tabId: entry.tabId,
+              windowId: entry.windowId,
+              index: entry.index,
+              groupId: entry.groupId,
+              groupTitle: entry.groupTitle,
+              groupColor: entry.groupColor,
+              groupCollapsed: meta ? meta.collapsed : null
+            });
+          }
+          if (plan.groupId != null && movedIds.length > 0) {
+            movedGroups += 1;
+            let newGroupId = null;
+            try {
+              newGroupId = await chrome.tabs.group({ tabIds: movedIds, createProperties: { windowId: toWindowId } });
+              const meta = groupById.get(plan.groupId);
+              if (meta) {
+                await chrome.tabGroups.update(newGroupId, {
+                  title: meta.title || "",
+                  color: meta.color || "grey",
+                  collapsed: meta.collapsed || false
+                });
+              }
+            } catch (error) {
+              deps2.log("Failed to regroup tabs", error);
+            }
+            groups2.push({ sourceGroupId: plan.groupId, newGroupId });
+          }
+        }
+        let closedSource = false;
+        if (params.closeSource === true) {
+          try {
+            const remainingTabs = await chrome.tabs.query({ windowId: fromWindowId });
+            if (remainingTabs.length === 0) {
+              await chrome.windows.remove(fromWindowId);
+              closedSource = true;
+            }
+          } catch (error) {
+            deps2.log("Failed to close source window", error);
+          }
+        }
+        return {
+          fromWindowId,
+          toWindowId,
+          summary: { movedTabs, movedGroups, skippedTabs: skipped.length, closedSource },
+          skipped,
+          groups: groups2,
+          undo: {
+            action: "merge-window",
+            fromWindowId,
+            toWindowId,
+            closedSource,
+            tabs: undoTabs
+          },
+          txid: params.txid || null
+        };
+      }
+    }
+  });
+
+  // dist/extension/background.js
+  var HOST_NAME = "com.erwinkroon.tabctl";
+  var manifest = chrome.runtime.getManifest();
+  var MANIFEST_VERSION = manifest.version || "0.0.0";
+  var MANIFEST_VERSION_NAME = manifest.version_name || MANIFEST_VERSION;
+  function parseVersionName(versionName) {
+    const match = versionName.match(/-dev\.([0-9a-f]+)(\.dirty)?$/i);
+    if (!match) {
+      return { gitSha: null, dirty: false };
+    }
+    return { gitSha: match[1] || null, dirty: Boolean(match[2]) };
+  }
+  var parsed = parseVersionName(MANIFEST_VERSION_NAME);
+  var VERSION_INFO = {
+    version: MANIFEST_VERSION_NAME,
+    baseVersion: MANIFEST_VERSION,
+    gitSha: parsed.gitSha,
+    dirty: parsed.dirty
+  };
+  var KEEPALIVE_ALARM = "tabctl-keepalive";
+  var KEEPALIVE_INTERVAL_MINUTES = 1;
+  var screenshot = require_screenshot();
+  var content = require_content();
+  var { delay, executeWithTimeout, isScriptableUrl, isGitHubIssueOrPr, detectGitHubState, extractPageMeta, extractSelectorSignal, waitForTabLoad, waitForDomReady, waitForSettle, waitForTabReady, SETTLE_STABILITY_MS, SETTLE_POLL_INTERVAL_MS } = content;
+  var groups = require_groups();
+  var tabs = require_tabs();
+  var { getMostRecentFocusedWindowId, normalizeTabIndex } = tabs;
+  var move = require_move();
+  var inspect = require_inspect();
+  var { DESCRIPTION_MAX_LENGTH } = inspect;
+  var undoHandlers = require_undo_handlers();
+  var archive = require_archive();
+  var state = {
+    port: null,
+    archiveWindowId: null,
+    archiveWindowIdLoaded: false,
+    lastFocused: {},
+    lastFocusedLoaded: false
+  };
+  function log(...args) {
+    console.log("[tabctl]", ...args);
+  }
+  function sendResponse(id, ok, payload) {
+    if (!state.port) {
+      return;
+    }
+    if (ok) {
+      const data = typeof payload === "object" && payload !== null ? { ...payload, component: "extension", version: VERSION_INFO.version, baseVersion: VERSION_INFO.baseVersion } : { payload, component: "extension", version: VERSION_INFO.version, baseVersion: VERSION_INFO.baseVersion };
+      state.port.postMessage({ id, ok: true, data });
+      return;
+    }
+    const error = payload instanceof Error ? { message: payload.message, stack: payload.stack } : payload;
+    state.port.postMessage({ id, ok: false, error });
+  }
+  function connectNative() {
+    if (state.port) {
+      return;
+    }
+    try {
+      const port = chrome.runtime.connectNative(HOST_NAME);
+      state.port = port;
+      port.onMessage.addListener(handleNativeMessage);
+      port.onDisconnect.addListener(() => {
+        const lastError = chrome.runtime.lastError;
+        if (lastError) {
+          log("Native host disconnected:", lastError.message);
+        } else {
+          log("Native host disconnected");
+        }
+        state.port = null;
+      });
+      log("Native host connected");
+    } catch (error) {
+      log("Native host connection failed", error);
+    }
+  }
+  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) {
+      connectNative();
+    }
+  });
+  async function ensureLastFocusedLoaded() {
+    if (state.lastFocusedLoaded) {
+      return;
+    }
+    const stored = await chrome.storage.local.get("lastFocused");
+    state.lastFocused = stored.lastFocused || {};
+    state.lastFocusedLoaded = true;
+  }
+  async function ensureArchiveWindowIdLoaded() {
+    if (state.archiveWindowIdLoaded) {
+      return;
+    }
+    const stored = await chrome.storage.local.get("archiveWindowId");
+    state.archiveWindowId = stored.archiveWindowId || null;
+    state.archiveWindowIdLoaded = true;
+  }
+  async function setLastFocused(tabId) {
+    await ensureLastFocusedLoaded();
+    state.lastFocused[String(tabId)] = Date.now();
+    await chrome.storage.local.set({ lastFocused: state.lastFocused });
+  }
+  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) => {
+    if (windowId === chrome.windows.WINDOW_ID_NONE) {
+      return;
+    }
+    chrome.tabs.query({ windowId, active: true }).then((tabs2) => {
+      if (tabs2[0] && tabs2[0].id != null) {
+        setLastFocused(tabs2[0].id).catch((error) => log("Failed to set last focused", error));
+      }
+    }).catch((error) => log("Failed to query active tab", error));
+  });
+  async function handleNativeMessage(message) {
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    const { id, action, params } = message;
+    if (!id || !action) {
+      return;
+    }
+    try {
+      const data = await handleAction(action, params || {}, id);
+      sendResponse(id, true, data);
+    } catch (error) {
+      sendResponse(id, false, error);
+    }
+  }
+  function sendProgress(id, payload) {
+    if (!state.port) {
+      return;
+    }
+    state.port.postMessage({ id, progress: true, data: payload });
+  }
+  async function handleAction(action, params, requestId) {
+    switch (action) {
+      case "ping":
+        return {
+          now: Date.now(),
+          version: VERSION_INFO.version,
+          baseVersion: VERSION_INFO.baseVersion,
+          gitSha: VERSION_INFO.gitSha,
+          dirty: VERSION_INFO.dirty,
+          component: "extension"
+        };
+      case "version":
+        return {
+          version: VERSION_INFO.version,
+          baseVersion: VERSION_INFO.baseVersion,
+          gitSha: VERSION_INFO.gitSha,
+          dirty: VERSION_INFO.dirty,
+          component: "extension"
+        };
+      case "list":
+        return await getTabSnapshot();
+      case "analyze":
+        return await inspect.analyzeTabs(params, requestId, deps);
+      case "inspect":
+        return await inspect.inspectTabs(params, requestId, deps);
+      case "focus":
+        return await tabs.focusTab(params);
+      case "refresh":
+        return await tabs.refreshTabs(params);
+      case "open":
+        return await tabs.openTabs(params, deps);
+      case "group-list":
+        return await listGroups(params);
+      case "group-update":
+        return await groupUpdate(params);
+      case "group-ungroup":
+        return await groupUngroup(params);
+      case "group-assign":
+        return await groupAssign(params);
+      case "move-tab":
+        return await move.moveTab(params, deps);
+      case "move-group":
+        return await move.moveGroup(params, deps);
+      case "merge-window":
+        return await archive.mergeWindow(params, deps);
+      case "archive":
+        return await archive.archiveTabs(params, deps);
+      case "close":
+        return await archive.closeTabs(params, deps);
+      case "report":
+        return await reportTabs(params);
+      case "screenshot":
+        return await screenshot.screenshotTabs(params, requestId, deps);
+      case "undo":
+        return await undoHandlers.undoTransaction(params, deps);
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+  function resolveWindowIdFromParams(snapshot, value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "active") {
+        const focused = snapshot.windows.find((win) => win.focused);
+        return focused ? focused.windowId : null;
+      }
+      if (normalized === "last-focused") {
+        return getMostRecentFocusedWindowId(snapshot.windows);
+      }
+      const parsed3 = Number(normalized);
+      return Number.isFinite(parsed3) ? parsed3 : null;
+    }
+    const parsed2 = Number(value);
+    return Number.isFinite(parsed2) ? parsed2 : null;
+  }
+  async function getTabSnapshot() {
+    await ensureLastFocusedLoaded();
+    const windows = await chrome.windows.getAll({ populate: true, windowTypes: ["normal"] });
+    const groups2 = await chrome.tabGroups.query({});
+    const groupById = new Map(groups2.map((group) => [group.id, group]));
+    const snapshot = windows.map((win) => {
+      const tabs2 = (win.tabs || []).map((tab) => {
+        const group = tab.groupId !== -1 ? groupById.get(tab.groupId) : null;
+        return {
+          tabId: tab.id,
+          windowId: win.id,
+          index: tab.index,
+          url: tab.url,
+          title: tab.title,
+          active: tab.active,
+          pinned: tab.pinned,
+          groupId: tab.groupId,
+          groupTitle: group ? group.title : null,
+          groupColor: group ? group.color : null,
+          groupCollapsed: group ? group.collapsed : null,
+          lastFocusedAt: state.lastFocused[String(tab.id)] || null
+        };
+      });
+      const windowGroups = groups2.filter((group) => group.windowId === win.id).map((group) => ({
+        groupId: group.id,
+        title: group.title,
+        color: group.color,
+        collapsed: group.collapsed
+      }));
+      return {
+        windowId: win.id,
+        focused: win.focused,
+        state: win.state,
+        tabs: tabs2,
+        groups: windowGroups
+      };
+    });
+    return {
+      generatedAt: Date.now(),
+      windows: snapshot
+    };
+  }
+  function flattenTabs(snapshot) {
+    const result = [];
+    for (const win of snapshot.windows) {
+      for (const tab of win.tabs) {
+        result.push(tab);
+      }
+    }
+    return result;
+  }
+  function resolveGroupByTitle(snapshot, groupTitle, windowId) {
+    return groups.resolveGroupByTitle(snapshot, buildWindowLabels, groupTitle, windowId);
+  }
+  function resolveGroupById(snapshot, groupId) {
+    return groups.resolveGroupById(snapshot, buildWindowLabels, groupId);
+  }
+  function buildWindowLabels(snapshot) {
+    const labels = /* @__PURE__ */ new Map();
+    snapshot.windows.forEach((win, index) => {
+      labels.set(win.windowId, `W${index + 1}`);
+    });
+    return labels;
+  }
+  function selectTabsByScope(snapshot, params) {
+    const allTabs = flattenTabs(snapshot);
+    if (params.tabIds && params.tabIds.length) {
+      const idSet = new Set(params.tabIds.map(Number));
+      return { tabs: allTabs.filter((tab) => idSet.has(tab.tabId)) };
+    }
+    if (params.groupId) {
+      const groupId = Number(params.groupId);
+      return { tabs: allTabs.filter((tab) => tab.groupId === groupId) };
+    }
+    if (params.groupTitle) {
+      const windowId = params.windowId != null ? resolveWindowIdFromParams(snapshot, params.windowId) ?? void 0 : void 0;
+      const resolved = resolveGroupByTitle(snapshot, params.groupTitle, windowId);
+      if (resolved.error) {
+        return { tabs: [], error: resolved.error };
+      }
+      const match = resolved.match;
+      return {
+        tabs: allTabs.filter((tab) => tab.groupId === match.group.groupId && tab.windowId === match.windowId)
+      };
+    }
+    if (params.windowId) {
+      const windowId = resolveWindowIdFromParams(snapshot, params.windowId);
+      if (!Number.isFinite(windowId)) {
+        return { tabs: [] };
+      }
+      return { tabs: allTabs.filter((tab) => tab.windowId === windowId) };
+    }
+    if (params.all) {
+      return { tabs: allTabs };
+    }
+    const focusedWindow = snapshot.windows.find((win) => win.focused);
+    if (!focusedWindow) {
+      return { tabs: [] };
+    }
+    return { tabs: focusedWindow.tabs };
+  }
+  var deps = {
+    getTabSnapshot,
+    selectTabsByScope,
+    sendProgress,
+    log,
+    resolveWindowIdFromParams,
+    resolveGroupByTitle,
+    resolveGroupById,
+    buildWindowLabels,
+    getArchiveWindowId,
+    setArchiveWindowId,
+    delay,
+    executeWithTimeout,
+    isScriptableUrl,
+    waitForTabReady
+  };
+  async function listGroups(params) {
+    return groups.listGroups(params, deps);
+  }
+  async function groupUpdate(params) {
+    return groups.groupUpdate(params, deps);
+  }
+  async function groupUngroup(params) {
+    return groups.groupUngroup(params, deps);
+  }
+  async function groupAssign(params) {
+    return groups.groupAssign(params, deps);
+  }
+  async function getArchiveWindowId() {
+    await ensureArchiveWindowIdLoaded();
+    return state.archiveWindowId;
+  }
+  async function setArchiveWindowId(id) {
+    state.archiveWindowId = id;
+    state.archiveWindowIdLoaded = true;
+    await chrome.storage.local.set({ archiveWindowId: id });
+  }
+  async function extractDescription(tabId) {
+    try {
+      const [{ result }] = await chrome.scripting.executeScript({
+        target: { tabId },
+        func: () => {
+          const pickContent = (selector) => {
+            const el = document.querySelector(selector);
+            if (!el) {
+              return "";
+            }
+            const content2 = el.getAttribute("content") || el.textContent || "";
+            return content2.trim();
+          };
+          let description = pickContent("meta[name='description']") || pickContent("meta[property='og:description']") || pickContent("meta[name='twitter:description']");
+          if (!description) {
+            const h1 = document.querySelector("h1");
+            const h1Text = h1 ? h1.textContent?.trim() : "";
+            const paragraphs = Array.from(document.querySelectorAll("p")).map((p) => p.textContent?.replace(/\s+/g, " ").trim() || "").filter((text) => text.length > 40);
+            const pText = paragraphs.length ? paragraphs[0] : "";
+            if (h1Text && pText) {
+              description = `${h1Text} - ${pText}`;
+            } else {
+              description = h1Text || pText;
+            }
+          }
+          return description.replace(/\s+/g, " ").trim();
+        }
+      });
+      if (!result) {
+        return "";
+      }
+      return String(result).slice(0, DESCRIPTION_MAX_LENGTH);
+    } catch {
+      return "";
+    }
+  }
+  async function reportTabs(params) {
+    const snapshot = await getTabSnapshot();
+    const selection = selectTabsByScope(snapshot, params);
+    if (selection.error) {
+      throw selection.error;
+    }
+    const windowLabels = buildWindowLabels(snapshot);
+    const tabs2 = selection.tabs;
+    const entries = [];
+    for (const tab of tabs2) {
+      const description = isScriptableUrl(tab.url) ? await extractDescription(tab.tabId) : "";
+      entries.push({
+        tabId: tab.tabId,
+        windowId: tab.windowId,
+        windowLabel: windowLabels.get(tab.windowId) || `W${tab.windowId}`,
+        groupId: tab.groupId,
+        groupTitle: tab.groupTitle,
+        groupColor: tab.groupColor,
+        url: tab.url,
+        title: tab.title,
+        description,
+        lastFocusedAt: tab.lastFocusedAt
+      });
+    }
+    return {
+      generatedAt: Date.now(),
+      entries,
+      totals: {
+        tabs: entries.length
+      }
+    };
+  }
+  self.__tabctl = { state, connectNative };
+})();