tabctl 0.3.0 → 0.4.0

package/dist/extension/background.js

@@ -1,8 +1,27 @@
 (() => {
+  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({
@@ -690,8 +709,13 @@
       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) => (Number(a.index) || 0) - (Number(b.index) || 0));
+        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);
@@ -758,8 +782,8 @@
         if (matches.length > 1) {
           return {
             error: {
-              message: "Group title is ambiguous. Provide a windowId.",
-              hint: "Use --window to disambiguate group titles.",
+              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
             }
@@ -1105,6 +1129,301 @@
           txid: params.txid || null
         };
       }
+      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
+            });
+          }
+        }
+        return {
+          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
+        };
+      }
+    }
+  });
+
+  // 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:";
+    }
+    if (options.forceHttps && urlObject.protocol === "http:") {
+      urlObject.protocol = "https:";
+    }
+    if (options.stripAuthentication) {
+      urlObject.username = "";
+      urlObject.password = "";
+    }
+    if (options.stripHash) {
+      urlObject.hash = "";
+    } else if (options.stripTextFragment) {
+      urlObject.hash = urlObject.hash.replace(/#?:~:text.*?$/i, "");
+    }
+    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;
+        }
+        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 = "/";
+    }
+    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("/")}` : "/";
+    }
+    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}`;
+      };
     }
   });
 
@@ -1112,14 +1431,18 @@
   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 = normalizeUrl;
+      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;
@@ -1137,45 +1460,29 @@
         }
         return bestWindowId;
       }
-      function normalizeUrl(rawUrl) {
+      function normalizeUrl2(rawUrl) {
         if (!rawUrl || typeof rawUrl !== "string") {
           return null;
         }
-        let url;
         try {
-          url = new URL(rawUrl);
+          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;
         }
-        if (url.protocol !== "http:" && url.protocol !== "https:") {
-          return null;
-        }
-        url.hash = "";
-        const dropKeys = /* @__PURE__ */ new Set([
-          "fbclid",
-          "gclid",
-          "igshid",
-          "mc_cid",
-          "mc_eid",
-          "ref",
-          "ref_src",
-          "ref_url",
-          "utm_campaign",
-          "utm_content",
-          "utm_medium",
-          "utm_source",
-          "utm_term",
-          "utm_name",
-          "si"
-        ]);
-        for (const key of Array.from(url.searchParams.keys())) {
-          if (key.startsWith("utm_") || dropKeys.has(key)) {
-            url.searchParams.delete(key);
-          }
-        }
-        const search = url.searchParams.toString();
-        url.search = search ? `?${search}` : "";
-        return url.toString();
       }
       function normalizeTabIndex2(value) {
         const index = Number(value);
@@ -1303,6 +1610,8 @@
           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");
         }
@@ -1387,6 +1696,12 @@
         }
         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));
@@ -1403,6 +1718,24 @@
         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;
@@ -1436,8 +1769,22 @@
           }
           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) {
@@ -1461,18 +1808,41 @@
           try {
             const tabIds = created.map((tab) => tab.tabId).filter((id) => typeof id === "number");
             if (tabIds.length > 0) {
-              groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId } });
-              const update = { title: groupTitle };
-              if (groupColor) {
-                update.color = groupColor;
+              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);
               }
-              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;
+        }
+        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) {
+            const groupedAfterUngrouped = freshTabs.filter((t, i) => i > firstUngroupedIndex && (t.groupId ?? -1) !== -1);
+            if (groupedAfterUngrouped.length > 0) {
+              const tabIdsToMove = groupedAfterUngrouped.map((t) => t.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);
+        }
         return {
           windowId,
           groupId,
@@ -1825,7 +2195,7 @@
       var content2 = require_content();
       var { isScriptableUrl: isScriptableUrl2, isGitHubIssueOrPr: isGitHubIssueOrPr2, detectGitHubState: detectGitHubState2, extractPageMeta: extractPageMeta2, extractSelectorSignal: extractSelectorSignal2, waitForSettle: waitForSettle2, waitForTabReady: waitForTabReady2 } = content2;
       var tabs2 = require_tabs();
-      var { normalizeUrl } = tabs2;
+      var { normalizeUrl: normalizeUrl2 } = tabs2;
       exports.DEFAULT_STALE_DAYS = 30;
       exports.DESCRIPTION_MAX_LENGTH = 250;
       exports.SELECTOR_VALUE_MAX_LENGTH = 500;
@@ -1852,7 +2222,7 @@
         const normalizedMap = /* @__PURE__ */ new Map();
         const duplicates = /* @__PURE__ */ new Map();
         for (const tab of scopeTabs) {
-          const normalized = normalizeUrl(tab.url);
+          const normalized = normalizeUrl2(tab.url);
           if (!normalized) {
             continue;
           }
@@ -2119,6 +2489,7 @@
       exports.undoGroupUpdate = undoGroupUpdate;
       exports.undoGroupUngroup = undoGroupUngroup;
       exports.undoGroupAssign = undoGroupAssign;
+      exports.undoGroupGather = undoGroupGather;
       exports.undoMoveTab = undoMoveTab;
       exports.undoMoveGroup = undoMoveGroup;
       exports.undoMergeWindow = undoMergeWindow;
@@ -2303,6 +2674,10 @@
         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 = {
@@ -2515,6 +2890,9 @@
         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);
         }
@@ -3149,6 +3527,8 @@
         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":
@@ -3165,6 +3545,9 @@
         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 };
       default:
         throw new Error(`Unknown action: ${action}`);
     }
@@ -3317,6 +3700,9 @@
   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;