tabctl 0.6.0-alpha.8 → 0.6.0-alpha.9

package/dist/extension/background.js

@@ -1,27 +1,8 @@
 (() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  };
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
   // dist/extension/lib/screenshot.js
   var require_screenshot = __commonJS({
@@ -40,7 +21,6 @@
       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;
@@ -185,8 +165,8 @@
         }
         return chrome.tabs.captureVisibleTab(windowId, options);
       }
-      async function getPageMetrics(tabId, timeoutMs, deps2) {
-        const result = await deps2.executeWithTimeout(tabId, timeoutMs, () => {
+      async function getPageMetrics(tabId, timeoutMs, deps) {
+        const result = await deps.executeWithTimeout(tabId, timeoutMs, () => {
           const doc = document.documentElement;
           const body = document.body;
           const pageWidth = Math.max(doc.scrollWidth, doc.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
@@ -206,8 +186,8 @@
         }
         return result;
       }
-      async function scrollToPosition(tabId, timeoutMs, x, y, deps2) {
-        const result = await deps2.executeWithTimeout(tabId, timeoutMs, (scrollX, scrollY) => {
+      async function scrollToPosition(tabId, timeoutMs, x, y, deps) {
+        const result = await deps.executeWithTimeout(tabId, timeoutMs, (scrollX, scrollY) => {
           window.scrollTo(scrollX, scrollY);
           return {
             scrollX: window.scrollX || window.pageXOffset || 0,
@@ -219,13 +199,13 @@
         }
         return result;
       }
-      async function captureTabTiles(tab, options, deps2) {
+      async function captureTabTiles(tab, options, deps) {
         const tabId = tab.tabId;
         const windowId = tab.windowId;
         if (!Number.isFinite(tabId) || !Number.isFinite(windowId)) {
           throw new Error("Missing tab/window id");
         }
-        const metrics = await getPageMetrics(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, deps2);
+        const metrics = await getPageMetrics(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, deps);
         if (!metrics) {
           throw new Error("Failed to read page metrics");
         }
@@ -243,7 +223,7 @@
         let tileIndex = 0;
         const captureTile = async (x, y, width, height, total) => {
           if (tileIndex > 0) {
-            await deps2.delay(exports.SCREENSHOT_CAPTURE_DELAY_MS);
+            await deps.delay(exports.SCREENSHOT_CAPTURE_DELAY_MS);
           }
           const rawDataUrl = await captureVisible(windowId, options.format, options.quality);
           if (!rawDataUrl) {
@@ -278,8 +258,8 @@
         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);
+            await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, x, y, deps);
+            await deps.delay(exports.SCREENSHOT_SCROLL_DELAY_MS);
             const width = Math.min(stepX, maxX - x);
             const height = Math.min(stepY, maxY - y);
             try {
@@ -287,7 +267,7 @@
             } 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 deps.delay(1e3);
                 await captureTile(x, y, width, height, tileCount);
               } else {
                 throw err;
@@ -295,90 +275,9 @@
             }
           }
         }
-        await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps2);
+        await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps);
         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;
-        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 });
-          }
-        }
-        const response = {
-          totals: { tabs: tabs2.length, tiles: totalTiles },
-          entries
-        };
-        return response;
-      }
     }
   });
 
@@ -387,21 +286,10 @@
     "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.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://"));
-      }
+      exports.extractPageMeta = extractPageMeta;
+      exports.extractSelectorSignal = extractSelectorSignal;
       function delay2(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
       }
@@ -428,7 +316,7 @@
           return null;
         }
       }
-      async function extractPageMeta2(tabId, timeoutMs, descriptionMaxLength) {
+      async function extractPageMeta(tabId, timeoutMs, descriptionMaxLength) {
         const result = await executeWithTimeout2(tabId, timeoutMs, () => {
           const pickContent = (selector) => {
             const el = document.querySelector(selector);
@@ -455,7 +343,7 @@
           h1: (meta.h1 || "").slice(0, descriptionMaxLength)
         };
       }
-      async function extractSelectorSignal2(tabId, specs, timeoutMs, selectorValueMaxLength) {
+      async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLength) {
         if (!specs.length) {
           return null;
         }
@@ -558,2951 +446,103 @@
         }
         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;
-      exports.groupGather = groupGather2;
-      function getGroupTabs(windowSnapshot, groupId) {
-        return windowSnapshot.tabs.filter((tab) => tab.groupId === groupId).sort((a, b) => {
-          const ai = Number(a.index);
-          const bi = Number(b.index);
-          return (Number.isFinite(ai) ? ai : 0) - (Number.isFinite(bi) ? bi : 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: `Ambiguous group title: found ${matches.length} groups named "${groupTitle}". Use group-gather to merge duplicates, --group-id to target by ID, or --window to narrow scope.`,
-              hint: "Use group-gather to merge duplicates, --group-id to target by ID, or --window to narrow scope.",
-              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);
-        const fullResult = {
-          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
-        };
-        return {
-          groupId: updated.id,
-          windowId: updated.windowId,
-          summary: { updatedGroups: 1 },
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
-      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);
-        }
-        const fullResult = {
-          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
-        };
-        return {
-          groupId: match.group.groupId,
-          windowId: match.windowId,
-          summary: fullResult.summary,
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
-      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;
-        }
-        const fullResult = {
-          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
-        };
-        return {
-          groupId: assignedGroupId,
-          windowId: targetWindowId,
-          created,
-          summary: fullResult.summary,
-          skipped: fullResult.skipped,
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
-      async function groupGather2(params, deps2) {
-        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 groupTitleFilter = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
-        const merged = [];
-        const undoEntries = [];
-        for (const win of windows) {
-          if (windowIdParam && win.windowId !== windowIdParam)
-            continue;
-          const byTitle = /* @__PURE__ */ new Map();
-          for (const group of win.groups) {
-            const title = typeof group.title === "string" ? group.title : "";
-            if (!title)
-              continue;
-            if (groupTitleFilter && title !== groupTitleFilter)
-              continue;
-            if (!byTitle.has(title))
-              byTitle.set(title, []);
-            byTitle.get(title).push(group);
-          }
-          for (const [title, titleGroups] of byTitle) {
-            if (titleGroups.length < 2)
-              continue;
-            const groupsWithIndex = titleGroups.map((g) => {
-              const tabs2 = win.tabs.filter((t) => t.groupId === g.groupId);
-              const minIndex = Math.min(...tabs2.map((t) => {
-                const idx = Number(t.index);
-                return Number.isFinite(idx) ? idx : Infinity;
-              }));
-              return { group: g, tabs: tabs2, minIndex };
-            });
-            groupsWithIndex.sort((a, b) => a.minIndex - b.minIndex);
-            const primary = groupsWithIndex[0];
-            const duplicates = groupsWithIndex.slice(1);
-            let movedTabs = 0;
-            for (const dup of duplicates) {
-              const tabIds = dup.tabs.map((t) => t.tabId).filter((id) => typeof id === "number");
-              if (tabIds.length > 0) {
-                for (const tab of dup.tabs) {
-                  undoEntries.push({
-                    tabId: tab.tabId,
-                    windowId: win.windowId,
-                    index: tab.index,
-                    groupId: tab.groupId,
-                    groupTitle: tab.groupTitle,
-                    groupColor: tab.groupColor,
-                    groupCollapsed: dup.group.collapsed ?? null
-                  });
-                }
-                await chrome.tabs.group({ groupId: primary.group.groupId, tabIds });
-                movedTabs += tabIds.length;
-              }
-            }
-            merged.push({
-              windowId: win.windowId,
-              groupTitle: title,
-              primaryGroupId: primary.group.groupId,
-              mergedGroupCount: duplicates.length,
-              movedTabs
-            });
-          }
-        }
-        const fullResult = {
-          merged,
-          summary: {
-            mergedGroups: merged.reduce((sum, m) => sum + m.mergedGroupCount, 0),
-            movedTabs: merged.reduce((sum, m) => sum + m.movedTabs, 0)
-          },
-          undo: {
-            action: "group-gather",
-            tabs: undoEntries
-          },
-          txid: params.txid || null
-        };
-        return {
-          merged,
-          summary: fullResult.summary,
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
     }
   });
 
-  // node_modules/normalize-url/index.js
-  var normalize_url_exports = {};
-  __export(normalize_url_exports, {
-    default: () => normalizeUrl
-  });
-  function normalizeUrl(urlString, options) {
-    options = {
-      defaultProtocol: "http",
-      normalizeProtocol: true,
-      forceHttp: false,
-      forceHttps: false,
-      stripAuthentication: true,
-      stripHash: false,
-      stripTextFragment: true,
-      stripWWW: true,
-      removeQueryParameters: [/^utm_\w+/i],
-      removeTrailingSlash: true,
-      removeSingleSlash: true,
-      removeDirectoryIndex: false,
-      removeExplicitPort: false,
-      sortQueryParameters: true,
-      removePath: false,
-      transformPath: false,
-      ...options
-    };
-    if (typeof options.defaultProtocol === "string" && !options.defaultProtocol.endsWith(":")) {
-      options.defaultProtocol = `${options.defaultProtocol}:`;
-    }
-    urlString = urlString.trim();
-    if (/^data:/i.test(urlString)) {
-      return normalizeDataURL(urlString, options);
-    }
-    if (hasCustomProtocol(urlString)) {
-      return urlString;
-    }
-    const hasRelativeProtocol = urlString.startsWith("//");
-    const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
-    if (!isRelativeUrl) {
-      urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
-    }
-    const urlObject = new URL(urlString);
-    if (options.forceHttp && options.forceHttps) {
-      throw new Error("The `forceHttp` and `forceHttps` options cannot be used together");
-    }
-    if (options.forceHttp && urlObject.protocol === "https:") {
-      urlObject.protocol = "http:";
+  // 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 };
     }
-    if (options.forceHttps && urlObject.protocol === "http:") {
-      urlObject.protocol = "https:";
+    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 } = content;
+  var DESCRIPTION_MAX_LENGTH = 250;
+  function requireFiniteId(value, name) {
+    const n = Number(value);
+    if (!Number.isFinite(n))
+      throw new Error(`${name} must be a finite number, got: ${String(value)}`);
+    return n;
+  }
+  var state = {
+    port: null,
+    lastFocused: {},
+    lastFocusedLoaded: false
+  };
+  function log(...args) {
+    console.log("[tabctl]", ...args);
+  }
+  function sendResponse(id, ok, payload) {
+    if (!state.port) {
+      return;
     }
-    if (options.stripAuthentication) {
-      urlObject.username = "";
-      urlObject.password = "";
+    if (ok) {
+      const data = typeof payload === "object" && payload !== null ? payload : { payload };
+      state.port.postMessage({ id, ok: true, data });
+      return;
     }
-    if (options.stripHash) {
-      urlObject.hash = "";
-    } else if (options.stripTextFragment) {
-      urlObject.hash = urlObject.hash.replace(/#?:~:text.*?$/i, "");
+    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;
     }
-    if (urlObject.pathname) {
-      const protocolRegex = /\b[a-z][a-z\d+\-.]{1,50}:\/\//g;
-      let lastIndex = 0;
-      let result = "";
-      for (; ; ) {
-        const match = protocolRegex.exec(urlObject.pathname);
-        if (!match) {
-          break;
+    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");
         }
-        const protocol = match[0];
-        const protocolAtIndex = match.index;
-        const intermediate = urlObject.pathname.slice(lastIndex, protocolAtIndex);
-        result += intermediate.replace(/\/{2,}/g, "/");
-        result += protocol;
-        lastIndex = protocolAtIndex + protocol.length;
-      }
-      const remnant = urlObject.pathname.slice(lastIndex, urlObject.pathname.length);
-      result += remnant.replace(/\/{2,}/g, "/");
-      urlObject.pathname = result;
-    }
-    if (urlObject.pathname) {
-      try {
-        urlObject.pathname = decodeURI(urlObject.pathname).replace(/\\/g, "%5C");
-      } catch {
-      }
-    }
-    if (options.removeDirectoryIndex === true) {
-      options.removeDirectoryIndex = [/^index\.[a-z]+$/];
-    }
-    if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
-      const pathComponents = urlObject.pathname.split("/").filter(Boolean);
-      const lastComponent = pathComponents.at(-1);
-      if (lastComponent && testParameter(lastComponent, options.removeDirectoryIndex)) {
-        pathComponents.pop();
-        urlObject.pathname = pathComponents.length > 0 ? `/${pathComponents.join("/")}/` : "/";
-      }
-    }
-    if (options.removePath) {
-      urlObject.pathname = "/";
+        state.port = null;
+      });
+      log("Native host connected");
+    } catch (error) {
+      log("Native host connection failed", error);
     }
-    if (options.transformPath && typeof options.transformPath === "function") {
-      const pathComponents = urlObject.pathname.split("/").filter(Boolean);
-      const newComponents = options.transformPath(pathComponents);
-      urlObject.pathname = newComponents?.length > 0 ? `/${newComponents.join("/")}` : "/";
+  }
+  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();
     }
-    if (urlObject.hostname) {
-      urlObject.hostname = urlObject.hostname.replace(/\.$/, "");
-      if (options.stripWWW && /^www\.(?!www\.)[a-z\-\d]{1,63}\.[a-z.\-\d]{2,63}$/.test(urlObject.hostname)) {
-        urlObject.hostname = urlObject.hostname.replace(/^www\./, "");
-      }
-    }
-    if (Array.isArray(options.removeQueryParameters)) {
-      for (const key of [...urlObject.searchParams.keys()]) {
-        if (testParameter(key, options.removeQueryParameters)) {
-          urlObject.searchParams.delete(key);
-        }
-      }
-    }
-    if (!Array.isArray(options.keepQueryParameters) && options.removeQueryParameters === true) {
-      urlObject.search = "";
-    }
-    if (Array.isArray(options.keepQueryParameters) && options.keepQueryParameters.length > 0) {
-      for (const key of [...urlObject.searchParams.keys()]) {
-        if (!testParameter(key, options.keepQueryParameters)) {
-          urlObject.searchParams.delete(key);
-        }
-      }
-    }
-    if (options.sortQueryParameters) {
-      const originalSearch = urlObject.search;
-      urlObject.searchParams.sort();
-      try {
-        urlObject.search = decodeURIComponent(urlObject.search);
-      } catch {
-      }
-      const partsWithoutEquals = originalSearch.slice(1).split("&").filter((p) => p && !p.includes("="));
-      for (const part of partsWithoutEquals) {
-        const decoded = decodeURIComponent(part);
-        urlObject.search = urlObject.search.replace(`?${decoded}=`, `?${decoded}`).replace(`&${decoded}=`, `&${decoded}`);
-      }
-    }
-    if (options.removeTrailingSlash) {
-      urlObject.pathname = urlObject.pathname.replace(/\/$/, "");
-    }
-    if (options.removeExplicitPort && urlObject.port) {
-      urlObject.port = "";
-    }
-    const oldUrlString = urlString;
-    urlString = urlObject.toString();
-    if (!options.removeSingleSlash && urlObject.pathname === "/" && !oldUrlString.endsWith("/") && urlObject.hash === "") {
-      urlString = urlString.replace(/\/$/, "");
-    }
-    if ((options.removeTrailingSlash || urlObject.pathname === "/") && urlObject.hash === "" && options.removeSingleSlash) {
-      urlString = urlString.replace(/\/$/, "");
-    }
-    if (hasRelativeProtocol && !options.normalizeProtocol) {
-      urlString = urlString.replace(/^http:\/\//, "//");
-    }
-    if (options.stripProtocol) {
-      urlString = urlString.replace(/^(?:https?:)?\/\//, "");
-    }
-    return urlString;
-  }
-  var DATA_URL_DEFAULT_MIME_TYPE, DATA_URL_DEFAULT_CHARSET, testParameter, supportedProtocols, hasCustomProtocol, normalizeDataURL;
-  var init_normalize_url = __esm({
-    "node_modules/normalize-url/index.js"() {
-      DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
-      DATA_URL_DEFAULT_CHARSET = "us-ascii";
-      testParameter = (name, filters) => filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name);
-      supportedProtocols = /* @__PURE__ */ new Set([
-        "https:",
-        "http:",
-        "file:"
-      ]);
-      hasCustomProtocol = (urlString) => {
-        try {
-          const { protocol } = new URL(urlString);
-          return protocol.endsWith(":") && !protocol.includes(".") && !supportedProtocols.has(protocol);
-        } catch {
-          return false;
-        }
-      };
-      normalizeDataURL = (urlString, { stripHash }) => {
-        const match = /^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$/.exec(urlString);
-        if (!match) {
-          throw new Error(`Invalid URL: ${urlString}`);
-        }
-        const { type, data, hash } = match.groups;
-        const mediaType = type.split(";");
-        const isBase64 = mediaType.at(-1) === "base64";
-        if (isBase64) {
-          mediaType.pop();
-        }
-        const mimeType = mediaType.shift()?.toLowerCase() ?? "";
-        const attributes = mediaType.map((attribute) => {
-          let [key, value = ""] = attribute.split("=").map((string) => string.trim());
-          if (key === "charset") {
-            value = value.toLowerCase();
-            if (value === DATA_URL_DEFAULT_CHARSET) {
-              return "";
-            }
-          }
-          return `${key}${value ? `=${value}` : ""}`;
-        }).filter(Boolean);
-        const normalizedMediaType = [...attributes];
-        if (isBase64) {
-          normalizedMediaType.push("base64");
-        }
-        if (normalizedMediaType.length > 0 || mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE) {
-          normalizedMediaType.unshift(mimeType);
-        }
-        const hashPart = stripHash || !hash ? "" : `#${hash}`;
-        return `data:${normalizedMediaType.join(";")},${isBase64 ? data.trim() : data}${hashPart}`;
-      };
-    }
-  });
-
-  // dist/extension/lib/tabs.js
-  var require_tabs = __commonJS({
-    "dist/extension/lib/tabs.js"(exports) {
-      "use strict";
-      var __importDefault = exports && exports.__importDefault || function(mod) {
-        return mod && mod.__esModule ? mod : { "default": mod };
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.getMostRecentFocusedWindowId = getMostRecentFocusedWindowId2;
-      exports.normalizeUrl = normalizeUrl2;
-      exports.normalizeTabIndex = normalizeTabIndex2;
-      exports.resolveOpenWindow = resolveOpenWindow;
-      exports.focusTab = focusTab;
-      exports.refreshTabs = refreshTabs;
-      exports.openTabs = openTabs;
-      var normalize_url_1 = __importDefault((init_normalize_url(), __toCommonJS(normalize_url_exports)));
-      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 normalizeUrl2(rawUrl) {
-        if (!rawUrl || typeof rawUrl !== "string") {
-          return null;
-        }
-        try {
-          return (0, normalize_url_1.default)(rawUrl, {
-            stripHash: true,
-            removeQueryParameters: [
-              /^utm_\w+$/i,
-              "fbclid",
-              "gclid",
-              "igshid",
-              "mc_cid",
-              "mc_eid",
-              "ref",
-              "ref_src",
-              "ref_url",
-              "si"
-            ]
-          });
-        } catch {
-          return null;
-        }
-      }
-      function normalizeTabIndex2(value) {
-        const index = Number(value);
-        return Number.isFinite(index) ? index : null;
-      }
-      function shapeOpenResult(result) {
-        return {
-          windowId: result.windowId,
-          groupId: result.groupId,
-          createdTabIds: result.created.map((tab) => tab.tabId).filter((id) => typeof id === "number"),
-          skipped: result.skipped,
-          summary: result.summary
-        };
-      }
-      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;
-        const forceNewGroup = params.newGroup === true;
-        const allowDuplicates = params.allowDuplicates === 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 shapeOpenResult({
-            windowId: windowId2,
-            groupId: groupId2,
-            created: created2,
-            skipped: skipped2,
-            summary: {
-              createdTabs: created2.length,
-              skippedUrls: skipped2.length,
-              grouped: Boolean(groupId2)
-            }
-          });
-        }
-        const snapshot = await deps2.getTabSnapshot();
-        let openParams = params;
-        if (groupTitle && !forceNewGroup && openParams.windowId == null && !openParams.windowGroupTitle && !openParams.windowTabId && !openParams.windowUrl) {
-          const groupWindows = snapshot.windows.filter((win) => win.groups.some((g) => g.title === groupTitle));
-          if (groupWindows.length === 1) {
-            openParams = { ...openParams, windowId: groupWindows[0].windowId };
-          }
-        }
-        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");
-        }
-        let existingGroupId = null;
-        const existingUrlSet = /* @__PURE__ */ new Set();
-        if (groupTitle && !forceNewGroup) {
-          const matchingGroups = windowSnapshot.groups.filter((g) => g.title === groupTitle);
-          if (matchingGroups.length > 1) {
-            throw new Error(`Ambiguous group title "${groupTitle}": found ${matchingGroups.length} groups with the same name. Use --new-group to force a new group, group-gather to merge, or --group-id to target by ID.`);
-          }
-          if (matchingGroups.length === 1) {
-            existingGroupId = matchingGroups[0].groupId;
-            const existingTabs = windowSnapshot.tabs.filter((tab) => tab.groupId === existingGroupId);
-            for (const tab of existingTabs) {
-              const norm = normalizeUrl2(tab.url);
-              if (norm) {
-                existingUrlSet.add(norm);
-              }
-            }
-          }
-        }
-        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;
-        }
-        if (existingGroupId != null && insertIndex == null && beforeTabId == null && afterTabId == null) {
-          const groupTabs = windowSnapshot.tabs.filter((tab) => tab.groupId === existingGroupId);
-          const indices = groupTabs.map((tab) => normalizeTabIndex2(tab.index)).filter((value) => value != null);
-          if (indices.length) {
-            insertIndex = Math.max(...indices) + 1;
-          }
-        }
-        let nextIndex = insertIndex;
-        for (const url of urls) {
-          if (!allowDuplicates && existingGroupId != null) {
-            const norm = normalizeUrl2(url);
-            if (norm && existingUrlSet.has(norm)) {
-              skipped.push({ url, reason: "duplicate" });
-              continue;
-            }
-          }
-          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" });
-          }
-        }
-        const createdTabIds = new Set(created.map((tab) => tab.tabId).filter((id) => typeof id === "number"));
-        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) {
-              if (existingGroupId != null) {
-                groupId = await chrome.tabs.group({ groupId: existingGroupId, tabIds });
-              } else {
-                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;
-          }
-        }
-        if (groupTitle && created.length === 0 && existingGroupId != null) {
-          groupId = existingGroupId;
-        }
-        const targetGroupId = groupId ?? existingGroupId;
-        if (targetGroupId != null && created.length > 0) {
-          try {
-            if (createdTabIds.size > 0) {
-              const latestTabs = await chrome.tabs.query({ windowId });
-              const missingGroupTabIds = latestTabs.filter((tab) => typeof tab.id === "number" && createdTabIds.has(tab.id) && tab.groupId !== targetGroupId).map((tab) => tab.id);
-              if (missingGroupTabIds.length > 0) {
-                await chrome.tabs.group({ groupId: targetGroupId, tabIds: missingGroupTabIds });
-              }
-            }
-          } catch (error) {
-            deps2.log("Failed to enforce grouping for newly opened tabs", error);
-          }
-        }
-        try {
-          const freshTabs = await chrome.tabs.query({ windowId });
-          freshTabs.sort((a, b) => a.index - b.index);
-          const firstUngroupedIndex = freshTabs.findIndex((t) => (t.groupId ?? -1) === -1);
-          if (firstUngroupedIndex >= 0) {
-            let tabIdsToMove = [];
-            if (existingGroupId != null) {
-              tabIdsToMove = freshTabs.filter((tab, i) => i > firstUngroupedIndex && typeof tab.id === "number" && createdTabIds.has(tab.id) && (tab.groupId ?? -1) !== -1).map((tab) => tab.id);
-            } else {
-              tabIdsToMove = freshTabs.filter((tab, i) => i > firstUngroupedIndex && (tab.groupId ?? -1) !== -1).map((tab) => tab.id).filter((id) => typeof id === "number");
-            }
-            if (tabIdsToMove.length > 0) {
-              await chrome.tabs.move(tabIdsToMove, { index: firstUngroupedIndex });
-            }
-          }
-        } catch (err) {
-          deps2.log("Failed to reorder groups before ungrouped tabs", err);
-        }
-        if (targetGroupId != null && createdTabIds.size > 0) {
-          try {
-            const latestTabs = await chrome.tabs.query({ windowId });
-            const lateUngroupedTabIds = latestTabs.filter((tab) => typeof tab.id === "number" && createdTabIds.has(tab.id) && tab.groupId !== targetGroupId).map((tab) => tab.id);
-            if (lateUngroupedTabIds.length > 0) {
-              await chrome.tabs.group({ groupId: targetGroupId, tabIds: lateUngroupedTabIds });
-            }
-          } catch (error) {
-            deps2.log("Failed post-reorder grouping verification", error);
-          }
-        }
-        if (targetGroupId != null && createdTabIds.size > 0) {
-          try {
-            await deps2.delay(250);
-            const delayedTabs = await chrome.tabs.query({ windowId });
-            const delayedUngroupedTabIds = delayedTabs.filter((tab) => typeof tab.id === "number" && createdTabIds.has(tab.id) && tab.groupId !== targetGroupId).map((tab) => tab.id);
-            if (delayedUngroupedTabIds.length > 0) {
-              await chrome.tabs.group({ groupId: targetGroupId, tabIds: delayedUngroupedTabIds });
-            }
-          } catch (error) {
-            deps2.log("Failed delayed grouping verification", error);
-          }
-        }
-        return shapeOpenResult({
-          windowId,
-          groupId,
-          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;
-            }
-          }
-          const fullResult2 = {
-            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
-          };
-          return {
-            tabId,
-            fromWindowId: sourceWindow.windowId,
-            toWindowId: targetWindowId2,
-            summary: fullResult2.summary,
-            undo: fullResult2.undo,
-            txid: fullResult2.txid
-          };
-        }
-        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 });
-        const fullResult = {
-          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
-        };
-        return {
-          tabId,
-          fromWindowId: sourceWindow.windowId,
-          toWindowId: targetWindowId,
-          summary: fullResult.summary,
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
-      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 ensureMovedTabsAreGrouped = async (movedTabIds, targetWindowId2, targetGroupId) => {
-          if (!targetGroupId || movedTabIds.length === 0) {
-            return;
-          }
-          const movedSet = new Set(movedTabIds);
-          const verify = async (step) => {
-            const tabs3 = await chrome.tabs.query({ windowId: targetWindowId2 });
-            const missingGroupTabIds = tabs3.filter((tab) => typeof tab.id === "number" && movedSet.has(tab.id) && tab.groupId !== targetGroupId).map((tab) => tab.id);
-            if (missingGroupTabIds.length > 0) {
-              await chrome.tabs.group({ groupId: targetGroupId, tabIds: missingGroupTabIds });
-            }
-          };
-          try {
-            await verify("group-verify");
-            await new Promise((resolve) => setTimeout(resolve, 250));
-            await verify("group-verify-delayed");
-            await new Promise((resolve) => setTimeout(resolve, 1500));
-            await verify("group-verify-delayed-late");
-          } catch (error) {
-            deps2.log("Failed to enforce moved group integrity", error);
-          }
-        };
-        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);
-          }
-          await ensureMovedTabsAreGrouped(tabIds2, targetWindowId2, newGroupId2);
-          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");
-          const fullResult2 = {
-            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
-          };
-          return {
-            groupId: source.group.groupId,
-            windowId: source.windowId,
-            movedToWindowId: targetWindowId2,
-            newGroupId: newGroupId2,
-            summary: fullResult2.summary,
-            undo: fullResult2.undo,
-            txid: fullResult2.txid
-          };
-        }
-        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);
-          }
-        }
-        await ensureMovedTabsAreGrouped(tabIds, targetWindowId, targetWindowId === source.windowId ? source.group.groupId : newGroupId);
-        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");
-        const fullResult = {
-          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
-        };
-        return {
-          groupId: source.group.groupId,
-          windowId: source.windowId,
-          movedToWindowId: targetWindowId,
-          newGroupId,
-          summary: fullResult.summary,
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
-    }
-  });
-
-  // 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, extractPageMeta: extractPageMeta2, extractSelectorSignal: extractSelectorSignal2, waitForSettle: waitForSettle2, waitForTabReady: waitForTabReady2 } = content2;
-      var tabs2 = require_tabs();
-      var { normalizeUrl: normalizeUrl2 } = 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 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 normalizedMap = /* @__PURE__ */ new Map();
-        const duplicates = /* @__PURE__ */ new Map();
-        for (const tab of scopeTabs) {
-          const normalized = normalizeUrl2(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 candidates = Array.from(candidateMap.values()).map((entry) => {
-          const reasons = entry.reasons;
-          const severity = reasons.some((reason) => reason.type === "duplicate") ? "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
-          };
-        });
-        const response = {
-          staleDays,
-          totals: {
-            tabs: scopeTabs.length,
-            analyzed: selectedTabs.length,
-            candidates: candidates.length
-          },
-          candidates
-        };
-        return response;
-      }
-      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 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) => {
-          const selector = spec.selector;
-          return {
-            name: typeof spec.name === "string" ? spec.name : void 0,
-            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) => spec.selector.includes(":contains(")).map((spec) => ({
-          code: "unsupported_selector_syntax",
-          signalId: "selector",
-          selector: spec.selector,
-          name: spec.name || spec.selector,
-          message: "Selector uses unsupported CSS :contains() syntax.",
-          hint: "Use selector text filters (text/textMode) or a different selector."
-        }));
-        const signalDefs = [];
-        for (const signalId of signalList) {
-          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;
-            try {
-              await waitForTabReady2(tabId, params, signalTimeoutMs);
-              result = await task.signal.run(tabId);
-              if (task.signal.id === "selector" && result && typeof result === "object") {
-                const selectorErrors = Object.keys(result.errors || {});
-                if (selectorErrors.length > 0) {
-                  error = `selector failures: ${selectorErrors.join(", ")}`;
-                }
-              }
-            } catch (err) {
-              const message = err instanceof Error ? err.message : "signal_error";
-              error = message;
-            }
-            const entry = entryMap.get(tabId) || { tab: task.tab, signals: {} };
-            entry.signals[task.signal.id] = {
-              ok: error === null,
-              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
-        }));
-        const response = {
-          totals: {
-            tabs: tabs3.length,
-            signals: signalDefs.length,
-            tasks: totalTasks
-          },
-          entries
-        };
-        if (selectorWarnings.length > 0) {
-          response.warnings = selectorWarnings;
-        }
-        return response;
-      }
-    }
-  });
-
-  // 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.undoGroupGather = undoGroupGather;
-      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 undoGroupGather(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 === "group-gather") {
-          return await undoGroupGather(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) {
-          const fullResult2 = {
-            txid: params.txid || null,
-            summary: { movedTabs: 0, movedGroups: 0, skippedTabs: 0 },
-            archiveWindowId: null,
-            skipped: [],
-            undo: { action: "archive", tabs: [] }
-          };
-          return fullResult2;
-        }
-        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);
-            }
-          }
-        }
-        const fullResult = {
-          txid: params.txid || null,
-          summary: {
-            movedTabs,
-            movedGroups,
-            skippedTabs: skipped.length
-          },
-          archiveWindowId,
-          skipped,
-          undo: {
-            action: "archive",
-            tabs: undoTabs
-          }
-        };
-        return {
-          txid: fullResult.txid,
-          summary: fullResult.summary,
-          archiveWindowId,
-          skipped: fullResult.skipped,
-          undo: fullResult.undo
-        };
-      }
-      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) {
-          const fullResult2 = {
-            txid: params.txid || null,
-            summary: { closedTabs: 0, skippedTabs: 0 },
-            skipped: [],
-            undo: { action: "close", tabs: [] }
-          };
-          return fullResult2;
-        }
-        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));
-        }
-        const fullResult = {
-          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
-            }))
-          }
-        };
-        return {
-          txid: fullResult.txid,
-          summary: fullResult.summary,
-          skipped: fullResult.skipped,
-          undo: fullResult.undo
-        };
-      }
-      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) {
-          const fullResult2 = {
-            fromWindowId,
-            toWindowId,
-            summary: { movedTabs: 0, movedGroups: 0, skippedTabs: skipped.length, closedSource: false },
-            skipped,
-            groups: [],
-            undo: {
-              action: "merge-window",
-              fromWindowId,
-              toWindowId,
-              closedSource: false,
-              tabs: []
-            }
-          };
-          return fullResult2;
-        }
-        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);
-          }
-        }
-        const fullResult = {
-          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
-        };
-        return {
-          fromWindowId,
-          toWindowId,
-          summary: fullResult.summary,
-          skipped: fullResult.skipped,
-          groups: fullResult.groups,
-          undo: fullResult.undo,
-          txid: fullResult.txid
-        };
-      }
-    }
-  });
-
-  // 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, 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 : { payload };
-      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;
+  });
+  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();
@@ -3524,9 +564,9 @@
     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));
+    chrome.tabs.query({ windowId, active: true }).then((tabs) => {
+      if (tabs[0] && tabs[0].id != null) {
+        setLastFocused(tabs[0].id).catch((error) => log("Failed to set last focused", error));
       }
     }).catch((error) => log("Failed to query active tab", error));
   });
@@ -3545,13 +585,11 @@
       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) {
+    if (action.startsWith("p:")) {
+      delete params.client;
+      delete params.txid;
+    }
     switch (action) {
       case "ping":
         return {
@@ -3563,109 +601,89 @@
           dirty: VERSION_INFO.dirty,
           component: "extension"
         };
-      case "version":
-        return {
-          runtimeId: chrome.runtime.id,
-          version: VERSION_INFO.version,
-          baseVersion: VERSION_INFO.baseVersion,
-          gitSha: VERSION_INFO.gitSha,
-          dirty: VERSION_INFO.dirty,
-          component: "extension"
-        };
-      case "list":
-        return shapeListSnapshot(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 "group-gather":
-        return await groupGather(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);
       case "reload":
         setTimeout(() => chrome.runtime.reload(), 100);
         return { reloading: true };
+      // --- Primitives: thin Chrome API wrappers (p: prefix) ---
+      case "p:snapshot":
+        return await getTabSnapshot();
+      case "p:tab-get":
+        return await chrome.tabs.get(requireFiniteId(params.tabId, "tabId"));
+      case "p:tab-query":
+        return await chrome.tabs.query(params.query);
+      case "p:tab-create":
+        return await chrome.tabs.create(params);
+      case "p:tab-update": {
+        const { tabId: rawTabId, ...updateProps } = params;
+        return await chrome.tabs.update(requireFiniteId(rawTabId, "tabId"), updateProps);
+      }
+      case "p:tab-move": {
+        const { tabIds: moveTabIds, ...moveProps } = params;
+        return await chrome.tabs.move(moveTabIds, moveProps);
+      }
+      case "p:tab-remove":
+        await chrome.tabs.remove(params.tabIds);
+        return { removed: true };
+      case "p:tab-reload":
+        await chrome.tabs.reload(requireFiniteId(params.tabId, "tabId"));
+        return { reloaded: true };
+      case "p:tab-group":
+        return { groupId: await chrome.tabs.group(params) };
+      case "p:tab-ungroup":
+        await chrome.tabs.ungroup(params.tabIds);
+        return { ungrouped: true };
+      case "p:group-update": {
+        const { groupId: rawGroupId, ...groupProps } = params;
+        return await chrome.tabGroups.update(requireFiniteId(rawGroupId, "groupId"), groupProps);
+      }
+      case "p:window-create":
+        return await chrome.windows.create(params);
+      case "p:window-remove":
+        await chrome.windows.remove(requireFiniteId(params.windowId, "windowId"));
+        return { removed: true };
+      case "p:window-update": {
+        const { windowId: rawWinId, ...winProps } = params;
+        return await chrome.windows.update(requireFiniteId(rawWinId, "windowId"), winProps);
+      }
+      case "p:execute-script": {
+        const targetTabId = requireFiniteId(params.tabId, "tabId");
+        const funcName = params.func;
+        const funcArgs = params.args || [];
+        const timeoutMs = Number(params.timeoutMs) || 8e3;
+        switch (funcName) {
+          case "extractPageMeta":
+            return await content.extractPageMeta(targetTabId, timeoutMs, funcArgs[0] || DESCRIPTION_MAX_LENGTH);
+          case "extractSelectorSignal": {
+            const specs = funcArgs[0];
+            if (!Array.isArray(specs))
+              throw new Error("extractSelectorSignal requires specs array as first arg");
+            const selectorMaxLen = funcArgs[1] || 500;
+            return await content.extractSelectorSignal(targetTabId, specs, timeoutMs, selectorMaxLen);
+          }
+          default:
+            throw new Error(`Unknown execute-script func: ${funcName}`);
+        }
+      }
+      case "p:screenshot-tile": {
+        const opts = params.options ?? {};
+        const mode = opts.mode === "viewport" || opts.mode === "full" ? opts.mode : "viewport";
+        const fmt = opts.format === "png" || opts.format === "jpeg" ? opts.format : "png";
+        const quality = typeof opts.quality === "number" ? Math.max(1, Math.min(100, opts.quality)) : 80;
+        const tileMaxDim = typeof opts.tileMaxDim === "number" ? Math.max(50, opts.tileMaxDim) : 50;
+        const maxBytes = typeof opts.maxBytes === "number" ? Math.max(5e4, opts.maxBytes) : 5e4;
+        return await screenshot.captureTabTiles(params.tab, { mode, format: fmt, quality, tileMaxDim, maxBytes }, { delay, executeWithTimeout });
+      }
       default:
         throw new Error(`Unknown action: ${action}`);
     }
   }
-  function shapeListSnapshot(snapshot) {
-    return {
-      windows: snapshot.windows.map((win) => ({
-        windowId: win.windowId,
-        focused: win.focused,
-        tabs: (win.tabs || []).map((tab) => ({
-          tabId: tab.tabId,
-          windowId: tab.windowId,
-          url: tab.url,
-          title: tab.title,
-          active: tab.active,
-          groupId: tab.groupId,
-          groupTitle: tab.groupTitle
-        })),
-        groups: (win.groups || []).map((group) => ({
-          groupId: group.groupId,
-          title: group.title,
-          color: group.color,
-          collapsed: group.collapsed
-        }))
-      }))
-    };
-  }
-  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 groups = await chrome.tabGroups.query({});
+    const groupById = new Map(groups.map((group) => [group.id, group]));
     const snapshot = windows.map((win) => {
-      const tabs2 = (win.tabs || []).map((tab) => {
+      const tabs = (win.tabs || []).map((tab) => {
         const group = tab.groupId !== -1 ? groupById.get(tab.groupId) : null;
         return {
           tabId: tab.id,
@@ -3682,7 +700,7 @@
           lastFocusedAt: state.lastFocused[String(tab.id)] || null
         };
       });
-      const windowGroups = groups2.filter((group) => group.windowId === win.id).map((group) => ({
+      const windowGroups = groups.filter((group) => group.windowId === win.id).map((group) => ({
         groupId: group.id,
         title: group.title,
         color: group.color,
@@ -3692,7 +710,7 @@
         windowId: win.id,
         focused: win.focused,
         state: win.state,
-        tabs: tabs2,
+        tabs,
         groups: windowGroups
       };
     });
@@ -3701,172 +719,5 @@
       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 groupGather(params) {
-    return groups.groupGather(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 };
 })();