tabctl 0.1.0

package/cli/lib/pagination.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumberOption = parseNumberOption;
+exports.buildNextCommand = buildNextCommand;
+exports.resolvePagination = resolvePagination;
+const constants_1 = require("./constants");
+const output_1 = require("./output");
+function parseNumberOption(options, key) {
+    if (!Object.prototype.hasOwnProperty.call(options, key)) {
+        return null;
+    }
+    const value = Number(options[key]);
+    if (!Number.isFinite(value)) {
+        (0, output_1.errorOut)(`Invalid --${key} value`);
+    }
+    return value;
+}
+function buildNextCommand(command, scopeArgs, offset, limit) {
+    const parts = ["tabctl", command, ...scopeArgs, "--offset", String(offset), "--limit", String(limit)];
+    return parts.join(" ");
+}
+function resolvePagination(options, total, command, scopeArgs) {
+    const noPage = options["no-page"] === true;
+    if (noPage) {
+        return { offset: 0, limit: total, page: null };
+    }
+    const limitRaw = parseNumberOption(options, "limit");
+    const offsetRaw = parseNumberOption(options, "offset");
+    const limit = limitRaw != null ? Math.floor(limitRaw) : constants_1.DEFAULT_PAGE_LIMIT;
+    const offset = offsetRaw != null ? Math.floor(offsetRaw) : 0;
+    if (!Number.isFinite(limit) || limit <= 0) {
+        (0, output_1.errorOut)("--limit must be a positive number");
+    }
+    if (!Number.isFinite(offset) || offset < 0) {
+        (0, output_1.errorOut)("--offset must be a non-negative number");
+    }
+    const remaining = total - offset;
+    const returned = remaining > 0 ? Math.min(limit, remaining) : 0;
+    const hasMore = offset + limit < total;
+    const nextOffset = hasMore ? offset + limit : null;
+    const hint = hasMore ? `Partial results. Next: ${buildNextCommand(command, scopeArgs, nextOffset, limit)}` : null;
+    return {
+        offset,
+        limit,
+        page: {
+            offset,
+            limit,
+            returned,
+            total,
+            hasMore,
+            nextOffset,
+            hint,
+        },
+    };
+}

package/cli/lib/policy.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPolicyPath = defaultPolicyPath;
+exports.defaultPolicyTemplate = defaultPolicyTemplate;
+exports.loadPolicy = loadPolicy;
+exports.getDomain = getDomain;
+exports.evaluateTab = evaluateTab;
+exports.annotateEntry = annotateEntry;
+exports.summarizePolicy = summarizePolicy;
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../../shared/config");
+function defaultPolicyPath() {
+    return (0, config_1.resolveConfig)().policyPath;
+}
+function defaultPolicyTemplate() {
+    return {
+        protect: {
+            pinned: true,
+            groupTitles: ["🔒"],
+        },
+    };
+}
+function loadPolicy() {
+    const resolvedPath = defaultPolicyPath();
+    if (!fs_1.default.existsSync(resolvedPath)) {
+        return { policy: null, path: resolvedPath };
+    }
+    const raw = fs_1.default.readFileSync(resolvedPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return { policy: parsed, path: resolvedPath };
+}
+function getDomain(rawUrl) {
+    if (!rawUrl) {
+        return null;
+    }
+    try {
+        const url = new URL(rawUrl);
+        return url.hostname;
+    }
+    catch {
+        return null;
+    }
+}
+function evaluateTab(tab, policy) {
+    const reasons = [];
+    if (!policy?.protect) {
+        return { eligible: true, protectedReasons: reasons };
+    }
+    const protect = policy.protect;
+    if (protect.pinned && tab.pinned === true) {
+        reasons.push("pinned");
+    }
+    const groupTitle = typeof tab.groupTitle === "string" ? tab.groupTitle : null;
+    if (groupTitle && Array.isArray(protect.groupTitles) && protect.groupTitles.includes(groupTitle)) {
+        reasons.push("groupTitle");
+    }
+    const groupId = Number(tab.groupId);
+    if (Number.isFinite(groupId) && Array.isArray(protect.groupIds) && protect.groupIds.includes(groupId)) {
+        reasons.push("groupId");
+    }
+    const windowId = Number(tab.windowId);
+    if (Number.isFinite(windowId) && Array.isArray(protect.windowIds) && protect.windowIds.includes(windowId)) {
+        reasons.push("windowId");
+    }
+    const domain = getDomain(typeof tab.url === "string" ? tab.url : null);
+    if (domain && Array.isArray(protect.domains) && protect.domains.includes(domain)) {
+        reasons.push("domain");
+    }
+    return { eligible: reasons.length === 0, protectedReasons: reasons };
+}
+function annotateEntry(entry, policy) {
+    const { eligible, protectedReasons } = evaluateTab(entry, policy);
+    return {
+        ...entry,
+        eligible,
+        protectedReasons,
+    };
+}
+function summarizePolicy(policy, policyPath) {
+    if (!policy) {
+        return { enabled: false, path: policyPath };
+    }
+    return {
+        enabled: true,
+        path: policyPath,
+        protect: policy.protect || {},
+    };
+}

package/cli/lib/report.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCsv = renderCsv;
+exports.renderMarkdown = renderMarkdown;
+function renderCsv(entries) {
+    const header = ["windowLabel", "groupTitle", "title", "url", "description", "lastFocusedAt"];
+    const lines = [header.join(",")];
+    const csvEscape = (value) => {
+        if (value == null) {
+            return "";
+        }
+        const str = String(value);
+        if (/[",\n]/.test(str)) {
+            return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+    };
+    for (const entry of entries) {
+        lines.push([
+            csvEscape(entry.windowLabel),
+            csvEscape(entry.groupTitle || ""),
+            csvEscape(entry.title || ""),
+            csvEscape(entry.url || ""),
+            csvEscape(entry.description || ""),
+            csvEscape(entry.lastFocusedAt || ""),
+        ].join(","));
+    }
+    return lines.join("\n");
+}
+function renderMarkdown(entries, generatedAt) {
+    const lines = [];
+    const date = generatedAt ? new Date(generatedAt).toISOString() : new Date().toISOString();
+    lines.push(`# Tab Report (${date})`);
+    const grouped = new Map();
+    for (const entry of entries) {
+        const windowKey = entry.windowLabel || `W${entry.windowId}`;
+        const groupKey = entry.groupTitle || "Ungrouped";
+        if (!grouped.has(windowKey)) {
+            grouped.set(windowKey, new Map());
+        }
+        const windowMap = grouped.get(windowKey);
+        if (!windowMap.has(groupKey)) {
+            windowMap.set(groupKey, []);
+        }
+        windowMap.get(groupKey)?.push(entry);
+    }
+    for (const [windowKey, groupMap] of grouped.entries()) {
+        lines.push(`\n## ${windowKey}`);
+        for (const [groupKey, items] of groupMap.entries()) {
+            lines.push(`\n### ${groupKey}`);
+            for (const item of items) {
+                const title = item.title || item.url || "(untitled)";
+                const url = item.url;
+                const link = url ? `[${title}](${url})` : title;
+                const desc = item.description ? ` - ${item.description}` : "";
+                lines.push(`- ${link}${desc}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}

package/cli/lib/scope.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCliArgValue = formatCliArgValue;
+exports.buildScopeArgs = buildScopeArgs;
+exports.resolveScopeFlags = resolveScopeFlags;
+exports.extractScopeParams = extractScopeParams;
+exports.selectTabsFromSnapshot = selectTabsFromSnapshot;
+exports.resolveWindowIdFromSnapshot = resolveWindowIdFromSnapshot;
+exports.filterGroupsByScope = filterGroupsByScope;
+const output_1 = require("./output");
+function formatCliArgValue(value) {
+    const raw = String(value);
+    if (!raw) {
+        return raw;
+    }
+    if (/[\s"]/g.test(raw)) {
+        const escaped = raw.replace(/"/g, '\\"');
+        return `"${escaped}"`;
+    }
+    return raw;
+}
+function buildScopeArgs(options, includeAll) {
+    const args = [];
+    if (includeAll) {
+        args.push("--all");
+        return args;
+    }
+    if (options.ungrouped === true) {
+        args.push("--ungrouped");
+    }
+    if (Array.isArray(options.tab)) {
+        for (const entry of options.tab) {
+            if (typeof entry === "string" && entry.trim()) {
+                args.push("--tab", formatCliArgValue(entry.trim()));
+            }
+        }
+    }
+    if (typeof options.group === "string" && options.group.trim()) {
+        args.push("--group", formatCliArgValue(options.group.trim()));
+    }
+    if (options["group-id"] != null && options.ungrouped !== true) {
+        args.push("--group-id", formatCliArgValue(options["group-id"]));
+    }
+    if (options.window != null) {
+        const windowValue = normalizeWindowScope(options.window);
+        args.push("--window", formatCliArgValue(windowValue));
+    }
+    return args;
+}
+function resolveScopeFlags(options) {
+    const tabIds = Array.isArray(options.tab)
+        ? options.tab.map(Number).filter(Number.isFinite)
+        : [];
+    const groupTitle = typeof options.group === "string" ? options.group.trim() : "";
+    const ungrouped = options.ungrouped === true;
+    const groupId = ungrouped ? -1 : (options["group-id"] != null ? Number(options["group-id"]) : null);
+    const normalizedWindow = options.window != null ? normalizeWindowScope(options.window) : null;
+    const windowId = normalizedWindow == null
+        ? null
+        : normalizedWindow;
+    if (options["group-id"] != null && !Number.isFinite(groupId)) {
+        (0, output_1.errorOut)("Invalid --group-id value");
+    }
+    if (ungrouped && options["group-id"] != null) {
+        (0, output_1.errorOut)("--ungrouped cannot be combined with --group-id");
+    }
+    if (options.window != null && typeof windowId === "number" && !Number.isFinite(windowId)) {
+        (0, output_1.errorOut)("Invalid --window value");
+    }
+    const hasScope = tabIds.length > 0
+        || Boolean(groupTitle)
+        || Number.isFinite(groupId)
+        || (typeof windowId === "number" && Number.isFinite(windowId))
+        || (typeof windowId === "string" && windowId.length > 0);
+    return { tabIds, groupTitle, groupId, windowId, hasScope, ungrouped };
+}
+function normalizeWindowScope(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim().toLowerCase();
+        if (trimmed === "active") {
+            return "active";
+        }
+        if (trimmed === "last-focused" || trimmed === "lastfocused") {
+            return "last-focused";
+        }
+        if (trimmed === "new") {
+            (0, output_1.errorOut)("--window new is only supported by open");
+        }
+        const numeric = Number(trimmed);
+        if (Number.isFinite(numeric)) {
+            return numeric;
+        }
+        (0, output_1.errorOut)("Invalid --window value");
+    }
+    return typeof value === "number" ? value : String(value);
+}
+function extractScopeParams(options) {
+    const scope = resolveScopeFlags(options);
+    return {
+        tabIds: scope.tabIds.length ? scope.tabIds : undefined,
+        groupTitle: scope.groupTitle || undefined,
+        groupId: scope.groupId != null ? scope.groupId : undefined,
+        windowId: scope.windowId != null ? scope.windowId : undefined,
+        all: options.all === true,
+    };
+}
+// Helper to build window label index (needed by selectTabsFromSnapshot)
+function buildWindowLabelIndex(snapshot) {
+    const windowLabels = new Map();
+    const windows = snapshot.windows || [];
+    windows.forEach((win, index) => {
+        const windowId = win.windowId;
+        if (typeof windowId === "number") {
+            windowLabels.set(windowId, `W${index + 1}`);
+        }
+    });
+    return windowLabels;
+}
+// Helper to list group summaries (needed by selectTabsFromSnapshot)
+function listGroupSummaries(snapshot, windowLabels) {
+    const windows = snapshot.windows || [];
+    const summaries = [];
+    for (const win of windows) {
+        const groups = win.groups || [];
+        for (const group of 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 selectTabsFromSnapshot(snapshot, params) {
+    const windows = snapshot.windows || [];
+    const allTabs = windows.flatMap((win) => win.tabs || []);
+    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 != null) {
+        const groupId = Number(params.groupId);
+        return { tabs: allTabs.filter((tab) => tab.groupId === groupId) };
+    }
+    if (params.groupTitle) {
+        const windowLabels = buildWindowLabelIndex(snapshot);
+        const matches = [];
+        for (const win of windows) {
+            const groups = win.groups || [];
+            for (const group of groups) {
+                if (group.title === params.groupTitle) {
+                    matches.push({
+                        windowId: win.windowId,
+                        windowLabel: windowLabels.get(win.windowId) ?? null,
+                        groupId: group.groupId,
+                    });
+                }
+            }
+        }
+        const availableGroups = listGroupSummaries(snapshot, windowLabels);
+        if (matches.length === 0) {
+            return {
+                tabs: [],
+                error: {
+                    message: "No matching group title found",
+                    hint: "Use tabctl group-list to see existing groups.",
+                    availableGroups,
+                },
+            };
+        }
+        if (matches.length > 1 && !params.windowId) {
+            return {
+                tabs: [],
+                error: {
+                    message: "Group title is ambiguous. Provide a windowId.",
+                    hint: "Use --window to disambiguate group titles.",
+                    matches,
+                    availableGroups,
+                },
+            };
+        }
+        const resolvedWindowId = params.windowId != null
+            ? resolveWindowIdFromSnapshot(snapshot, params.windowId)
+            : null;
+        const target = resolvedWindowId != null
+            ? matches.find((match) => match.windowId === resolvedWindowId)
+            : matches[0];
+        if (!target) {
+            return {
+                tabs: [],
+                error: {
+                    message: "Group title not found in specified window",
+                    hint: "Use tabctl group-list to see existing groups.",
+                    matches,
+                    availableGroups,
+                },
+            };
+        }
+        return { tabs: allTabs.filter((tab) => tab.groupId === target.groupId && tab.windowId === target.windowId) };
+    }
+    if (params.windowId != null) {
+        const windowId = resolveWindowIdFromSnapshot(snapshot, params.windowId);
+        if (!Number.isFinite(windowId)) {
+            return { tabs: [] };
+        }
+        return { tabs: allTabs.filter((tab) => tab.windowId === windowId) };
+    }
+    if (params.all) {
+        return { tabs: allTabs };
+    }
+    const focused = windows.find((win) => win.focused);
+    return { tabs: focused ? (focused.tabs || []) : [] };
+}
+function resolveWindowIdFromSnapshot(snapshot, value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    const windows = snapshot.windows || [];
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "active") {
+            const focused = windows.find((win) => win.focused === true);
+            return typeof focused?.windowId === "number" ? focused.windowId : null;
+        }
+        if (normalized === "last-focused") {
+            let bestWindowId = null;
+            let bestFocusedAt = -Infinity;
+            for (const win of windows) {
+                const tabs = win.tabs || [];
+                for (const tab of tabs) {
+                    const focusedAt = Number(tab.lastFocusedAt);
+                    if (!Number.isFinite(focusedAt)) {
+                        continue;
+                    }
+                    if (focusedAt > bestFocusedAt) {
+                        bestFocusedAt = focusedAt;
+                        bestWindowId = typeof win.windowId === "number" ? win.windowId : null;
+                    }
+                }
+            }
+            return bestWindowId;
+        }
+    }
+    return Number.isFinite(Number(value)) ? Number(value) : null;
+}
+function filterGroupsByScope(groups, scope, snapshot, buildTabIndex) {
+    let filtered = groups;
+    const allScope = !scope.hasScope;
+    if (!allScope) {
+        if (typeof scope.windowId === "number" && Number.isFinite(scope.windowId)) {
+            filtered = filtered.filter((group) => group.windowId === scope.windowId);
+        }
+        if (Number.isFinite(scope.groupId)) {
+            filtered = filtered.filter((group) => group.groupId === scope.groupId);
+        }
+        if (scope.groupTitle) {
+            filtered = filtered.filter((group) => group.title === scope.groupTitle);
+        }
+        if (scope.tabIds.length > 0 && snapshot) {
+            const tabIndex = buildTabIndex(snapshot);
+            const groupIds = new Set();
+            for (const tabId of scope.tabIds) {
+                const tab = tabIndex.get(tabId);
+                if (!tab) {
+                    continue;
+                }
+                const groupId = tab.groupId;
+                if (Number.isFinite(groupId) && groupId !== -1) {
+                    groupIds.add(groupId);
+                }
+            }
+            filtered = filtered.filter((group) => groupIds.has(group.groupId));
+        }
+    }
+    return filtered;
+}

package/cli/lib/snapshot.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTabIndex = buildTabIndex;
+exports.buildWindowTitleIndex = buildWindowTitleIndex;
+exports.buildWindowLabelIndex = buildWindowLabelIndex;
+exports.buildGroupsFromSnapshot = buildGroupsFromSnapshot;
+exports.listGroupSummaries = listGroupSummaries;
+exports.compareTabIndex = compareTabIndex;
+exports.orderTabs = orderTabs;
+exports.buildPagedSnapshot = buildPagedSnapshot;
+exports.filterSnapshotByPolicy = filterSnapshotByPolicy;
+const policy_1 = require("./policy");
+function buildTabIndex(snapshot) {
+    const tabIndex = new Map();
+    const windows = snapshot.windows || [];
+    for (const window of windows) {
+        const tabs = window.tabs || [];
+        for (const tab of tabs) {
+            if (typeof tab.tabId === "number") {
+                tabIndex.set(tab.tabId, tab);
+            }
+        }
+    }
+    return tabIndex;
+}
+function buildWindowTitleIndex(snapshot, policy) {
+    const windowTitleIndex = new Map();
+    const windows = snapshot.windows || [];
+    for (const window of windows) {
+        const windowId = window.windowId;
+        if (typeof windowId !== "number") {
+            continue;
+        }
+        const tabs = window.tabs || [];
+        const activeTab = tabs.find((tab) => tab.active === true);
+        if (!activeTab) {
+            windowTitleIndex.set(windowId, null);
+            continue;
+        }
+        const { eligible } = (0, policy_1.evaluateTab)(activeTab, policy);
+        if (!eligible) {
+            windowTitleIndex.set(windowId, null);
+            continue;
+        }
+        const title = typeof activeTab.title === "string" ? activeTab.title : null;
+        windowTitleIndex.set(windowId, title);
+    }
+    return windowTitleIndex;
+}
+function buildWindowLabelIndex(snapshot) {
+    const windowLabels = new Map();
+    const windows = snapshot.windows || [];
+    windows.forEach((win, index) => {
+        const windowId = win.windowId;
+        if (typeof windowId === "number") {
+            windowLabels.set(windowId, `W${index + 1}`);
+        }
+    });
+    return windowLabels;
+}
+function buildGroupsFromSnapshot(snapshot, windowId) {
+    const windows = snapshot.windows || [];
+    const windowLabels = buildWindowLabelIndex(snapshot);
+    const groups = [];
+    for (const win of windows) {
+        const winId = win.windowId;
+        if (!Number.isFinite(winId)) {
+            continue;
+        }
+        if (Number.isFinite(windowId) && winId !== windowId) {
+            continue;
+        }
+        const counts = new Map();
+        const tabs = win.tabs || [];
+        for (const tab of tabs) {
+            const groupId = tab.groupId;
+            if (typeof groupId === "number" && groupId !== -1) {
+                counts.set(groupId, (counts.get(groupId) || 0) + 1);
+            }
+        }
+        const windowGroups = win.groups || [];
+        for (const group of windowGroups) {
+            const groupId = group.groupId;
+            if (!Number.isFinite(groupId)) {
+                continue;
+            }
+            groups.push({
+                windowId: winId,
+                windowLabel: windowLabels.get(winId) ?? null,
+                groupId,
+                title: group.title ?? null,
+                color: group.color ?? null,
+                collapsed: group.collapsed ?? null,
+                tabCount: counts.get(groupId) || 0,
+            });
+        }
+    }
+    return groups;
+}
+function listGroupSummaries(snapshot, windowLabels) {
+    const windows = snapshot.windows || [];
+    const summaries = [];
+    for (const win of windows) {
+        const groups = win.groups || [];
+        for (const group of 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 compareTabIndex(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;
+    }
+    if (aIndex === bIndex) {
+        const aId = Number(a.tabId);
+        const bId = Number(b.tabId);
+        if (Number.isFinite(aId) && Number.isFinite(bId)) {
+            return aId - bId;
+        }
+        return 0;
+    }
+    return aIndex - bIndex;
+}
+function orderTabs(snapshot, tabFilter) {
+    const windows = snapshot.windows || [];
+    const ordered = [];
+    for (const win of windows) {
+        const tabs = (win.tabs || []).slice().sort(compareTabIndex);
+        for (const tab of tabs) {
+            const tabId = tab.tabId;
+            if (!tabFilter || tabFilter.has(tabId)) {
+                ordered.push(tab);
+            }
+        }
+    }
+    return ordered;
+}
+function buildPagedSnapshot(snapshot, tabs) {
+    const tabsByWindow = new Map();
+    const groupsByWindow = new Map();
+    for (const tab of tabs) {
+        const windowId = tab.windowId;
+        if (!Number.isFinite(windowId)) {
+            continue;
+        }
+        if (!tabsByWindow.has(windowId)) {
+            tabsByWindow.set(windowId, []);
+            groupsByWindow.set(windowId, new Set());
+        }
+        tabsByWindow.get(windowId)?.push(tab);
+        const groupId = tab.groupId;
+        if (Number.isFinite(groupId) && groupId !== -1) {
+            groupsByWindow.get(windowId)?.add(groupId);
+        }
+    }
+    const windows = snapshot.windows || [];
+    const pagedWindows = [];
+    for (const win of windows) {
+        const windowId = win.windowId;
+        const windowTabs = tabsByWindow.get(windowId) || [];
+        if (windowTabs.length === 0) {
+            continue;
+        }
+        const allowedGroupIds = groupsByWindow.get(windowId) || new Set();
+        const groups = (win.groups || []).filter((group) => allowedGroupIds.has(group.groupId));
+        pagedWindows.push({
+            ...win,
+            tabs: windowTabs,
+            groups,
+        });
+    }
+    return {
+        ...snapshot,
+        windows: pagedWindows,
+    };
+}
+function filterSnapshotByPolicy(snapshot, policy) {
+    if (!policy) {
+        return snapshot;
+    }
+    const windows = snapshot.windows || [];
+    const filteredWindows = windows.map((win) => {
+        const tabs = win.tabs || [];
+        const eligibleTabs = tabs
+            .filter((tab) => (0, policy_1.evaluateTab)(tab, policy).eligible)
+            .map((tab) => (0, policy_1.annotateEntry)(tab, policy));
+        const eligibleGroupIds = new Set(eligibleTabs
+            .map((tab) => tab.groupId)
+            .filter((groupId) => typeof groupId === "number" && groupId !== -1));
+        const groups = win.groups || [];
+        const filteredGroups = groups.filter((group) => eligibleGroupIds.has(group.groupId));
+        return {
+            ...win,
+            tabs: eligibleTabs,
+            groups: filteredGroups,
+        };
+    }).filter((win) => win.tabs.length > 0);
+    return {
+        ...snapshot,
+        windows: filteredWindows,
+    };
+}