npm - @quanta-intellect/vessel-browser - Versions diffs - 0.1.71 → 0.1.73 - Mend

@quanta-intellect/vessel-browser 0.1.71 → 0.1.73

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +14 -2
package/out/main/index.js +1376 -60
package/out/preload/index.js +33 -0
package/out/renderer/assets/{index-DbnD-fG3.js → index-C2iAShPa.js} +943 -633
package/out/renderer/assets/{index-wmYomTVM.css → index-MB-_tN9U.css} +142 -0
package/out/renderer/index.html +2 -2
package/package.json +1 -1

package/out/main/index.js CHANGED Viewed

@@ -339,6 +339,7 @@ class Tab {
   onHighlightSelection;
   onHighlightRemove;
   onHighlightRecolor;
+  onSavePage;
   _highlightModeActive = false;
   _readerOriginalUrl = null;
   // Fully custom URL history — we never rely on Chromium's native back/forward
@@ -383,11 +384,13 @@ class Tab {
     this.onHighlightSelection = options?.onHighlightSelection;
     this.onHighlightRemove = options?.onHighlightRemove;
     this.onHighlightRecolor = options?.onHighlightRecolor;
+    this.onSavePage = options?.onSavePage;
     const webPreferences = {
       preload: path.join(__dirname, "../preload/content-script.js"),
       sandbox: true,
       contextIsolation: true,
-      nodeIntegration: false
+      nodeIntegration: false,
+      spellcheck: false
     };
     if (options?.sessionPartition) {
       webPreferences.session = electron.session.fromPartition(options.sessionPartition);
@@ -404,6 +407,9 @@ class Tab {
       canGoForward: false,
       isReaderMode: false,
       adBlockingEnabled: options?.adBlockingEnabled ?? true,
+      isPinned: false,
+      isAudible: false,
+      isMuted: false,
       role: options?.role
     };
     this.view.webContents.on("before-input-event", (event, input) => {
@@ -530,6 +536,19 @@ class Tab {
       this._state.favicon = favicons[0] || "";
       this.onChange();
     });
+    wc.on("media-started-playing", () => {
+      this._state.isAudible = true;
+      this._state.isMuted = wc.isAudioMuted();
+      this.onChange();
+    });
+    wc.on("media-paused", () => {
+      setTimeout(() => {
+        if (wc.isDestroyed()) return;
+        this._state.isAudible = wc.isCurrentlyAudible();
+        this._state.isMuted = wc.isAudioMuted();
+        this.onChange();
+      }, 250);
+    });
     wc.on("context-menu", (_event, params) => {
       const x = params.x;
       const y = params.y;
@@ -621,6 +640,19 @@ class Tab {
         })
       );
     }
+    menu.append(new electron.MenuItem({ type: "separator" }));
+    menu.append(
+      new electron.MenuItem({
+        label: "Save Page As...",
+        click: () => this.onSavePage?.()
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        label: "View Page Source",
+        click: () => void this.viewSource()
+      })
+    );
     menu.popup({ window: this.parentWindow });
   }
   get state() {
@@ -706,12 +738,61 @@ class Tab {
   zoomReset() {
     this.view.webContents.setZoomLevel(0);
   }
+  async viewSource() {
+    const url = this.view.webContents.getURL();
+    let html;
+    try {
+      html = await this.view.webContents.executeJavaScript(
+        "document.documentElement.outerHTML"
+      );
+    } catch (err) {
+      logger$j.warn("Failed to retrieve page source:", err);
+      return;
+    }
+    const escaped = html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const win = new electron.BrowserWindow({
+      width: 960,
+      height: 700,
+      title: `view-source:${url}`,
+      backgroundColor: "#1a1a1e",
+      webPreferences: {
+        sandbox: true,
+        contextIsolation: true,
+        nodeIntegration: false,
+        spellcheck: false
+      }
+    });
+    const style = "background:#1a1a1e;color:#e0e0e0;font-family:monospace;font-size:12px;line-height:1.5;padding:16px;margin:0;white-space:pre-wrap;word-break:break-all;";
+    const dataUrl = `data:text/html;charset=utf-8,<!DOCTYPE html><html><head><title>view-source:${url}</title></head><body style="${style}"><pre>${escaped}</pre></body></html>`;
+    win.loadURL(dataUrl);
+  }
   setAdBlockingEnabled(enabled) {
     if (this._state.adBlockingEnabled === enabled) return false;
     this._state.adBlockingEnabled = enabled;
     this.onChange();
     return true;
   }
+  setPinned(pinned) {
+    if (this._state.isPinned === pinned) return;
+    this._state.isPinned = pinned;
+    this.onChange();
+  }
+  setGroup(groupId) {
+    if (this._state.groupId === groupId) return;
+    this._state.groupId = groupId;
+    this.onChange();
+  }
+  setMuted(muted) {
+    const wc = this.view.webContents;
+    wc.setAudioMuted(muted);
+    this._state.isMuted = wc.isAudioMuted();
+    this._state.isAudible = wc.isCurrentlyAudible();
+    this.onChange();
+  }
+  toggleMuted() {
+    this.setMuted(!this._state.isMuted);
+    return this._state.isMuted;
+  }
   get highlightModeActive() {
     return this._highlightModeActive;
   }
@@ -813,6 +894,32 @@ class Tab {
     this.view.webContents.close();
   }
 }
+const TAB_GROUP_COLORS = [
+  "blue",
+  "green",
+  "yellow",
+  "orange",
+  "red",
+  "purple",
+  "gray"
+];
+const TAB_GROUP_COLOR_LABELS = {
+  blue: "Blue",
+  green: "Green",
+  yellow: "Yellow",
+  orange: "Orange",
+  red: "Red",
+  purple: "Purple",
+  gray: "Gray"
+};
+const SEARCH_ENGINE_PRESETS = {
+  duckduckgo: { label: "DuckDuckGo", url: "https://duckduckgo.com/?q=" },
+  google: { label: "Google", url: "https://www.google.com/search?q=" },
+  bing: { label: "Bing", url: "https://www.bing.com/search?q=" },
+  brave: { label: "Brave Search", url: "https://search.brave.com/search?q=" },
+  ecosia: { label: "Ecosia", url: "https://www.ecosia.org/search?q=" },
+  kagi: { label: "Kagi", url: "https://kagi.com/search?q=" }
+};
 const logger$i = createLogger("JsonPersistence");
 function canUseSafeStorage() {
   try {
@@ -906,6 +1013,20 @@ const SAVE_DEBOUNCE_MS$5 = 250;
 function getHighlightsPath() {
   return path.join(electron.app.getPath("userData"), "vessel-highlights.json");
 }
+function createPersistence$1() {
+  return createDebouncedJsonPersistence({
+    debounceMs: SAVE_DEBOUNCE_MS$5,
+    filePath: getHighlightsPath(),
+    getValue: () => state$4,
+    logLabel: "highlights",
+    resetOnSchedule: true
+  });
+}
+let persistence$5 = null;
+function getPersistence$1() {
+  persistence$5 ??= createPersistence$1();
+  return persistence$5;
+}
 function load$4() {
   if (state$4) return state$4;
   state$4 = loadJsonFile({
@@ -920,15 +1041,8 @@ function load$4() {
   });
   return state$4;
 }
-const persistence$5 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$5,
-  filePath: getHighlightsPath(),
-  getValue: () => state$4,
-  logLabel: "highlights",
-  resetOnSchedule: true
-});
 function save$2() {
-  persistence$5.schedule();
+  getPersistence$1().schedule();
 }
 function emit$2() {
   if (!state$4) return;
@@ -1010,7 +1124,7 @@ function clearHighlightsForUrl(url) {
   return removed;
 }
 function flushPersist$4() {
-  return persistence$5.flush();
+  return getPersistence$1().flush();
 }
 const SKIP_TAGS_JS = "var SKIP_TAGS = {SCRIPT:1,STYLE:1,NOSCRIPT:1,TEMPLATE:1,IFRAME:1,SVG:1};";
 const CONTENT_ROOTS_JS = `
@@ -2367,9 +2481,22 @@ function destroySession(tabId) {
   }
 }
 const logger$h = createLogger("TabManager");
+function sanitizePdfFilename(title) {
+  const clean = title.replace(/[<>:"/\\|?*\x00-\x1f]/g, " ").replace(/\s+/g, " ").trim();
+  const base = (clean || "Vessel Page").replace(/\.pdf$/i, "");
+  return `${base}.pdf`;
+}
+function sanitizePageFilename(title, ext) {
+  const clean = title.replace(/[<>:\"/\\|?*\x00-\x1f]/g, " ").replace(/\s+/g, " ").trim();
+  const escapedExt = ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`\\.${escapedExt}$`, "i");
+  const base = (clean || "Vessel Page").replace(regex, "");
+  return `${base}.${ext}`;
+}
 class TabManager {
   tabs = /* @__PURE__ */ new Map();
   order = [];
+  tabGroups = /* @__PURE__ */ new Map();
   activeTabId = null;
   window;
   onStateChange;
@@ -2407,7 +2534,10 @@ class TabManager {
       },
       onHighlightSelection: (wc) => this.captureHighlightFromPage(wc),
       onHighlightRemove: (url2, text) => this.removeHighlightByText(url2, text),
-      onHighlightRecolor: (url2, text, color) => this.recolorHighlightByText(url2, text, color)
+      onHighlightRecolor: (url2, text, color) => this.recolorHighlightByText(url2, text, color),
+      onSavePage: () => {
+        void this.savePage(id);
+      }
     });
     this.tabs.set(id, tab);
     this.order.push(id);
@@ -2434,6 +2564,8 @@ class TabManager {
   closeTab(id) {
     const tab = this.tabs.get(id);
     if (!tab) return;
+    if (tab.state.isPinned) return;
+    const groupId = tab.state.groupId;
     this.closedTabs.push({
       url: tab.state.url,
       title: tab.state.title,
@@ -2451,6 +2583,7 @@ class TabManager {
     tab.destroy();
     this.tabs.delete(id);
     this.order = this.order.filter((tid) => tid !== id);
+    this.removeGroupIfEmpty(groupId);
     if (this.activeTabId === id) {
       if (this.order.length > 0) {
         this.switchTab(this.order[this.order.length - 1]);
@@ -2494,6 +2627,118 @@ class TabManager {
     if (!tab) return null;
     return this.createTab(tab.state.url, { adBlockingEnabled: tab.state.adBlockingEnabled });
   }
+  pinTab(id) {
+    const tab = this.tabs.get(id);
+    if (!tab) return;
+    tab.setPinned(true);
+    this.order = this.order.filter((tid) => tid !== id);
+    const firstNonPinned = this.order.findIndex((tid) => !this.tabs.get(tid)?.state.isPinned);
+    if (firstNonPinned === -1) {
+      this.order.push(id);
+    } else {
+      this.order.splice(firstNonPinned, 0, id);
+    }
+    this.broadcastState();
+  }
+  unpinTab(id) {
+    const tab = this.tabs.get(id);
+    if (!tab) return;
+    tab.setPinned(false);
+    this.order = this.order.filter((tid) => tid !== id);
+    const firstNonPinned = this.order.findIndex((tid) => !this.tabs.get(tid)?.state.isPinned);
+    if (firstNonPinned === -1) {
+      this.order.push(id);
+    } else {
+      this.order.splice(firstNonPinned, 0, id);
+    }
+    this.broadcastState();
+  }
+  createGroupFromTab(id, options) {
+    const tab = this.tabs.get(id);
+    if (!tab) return null;
+    const previousGroupId = tab.state.groupId;
+    const groupId = crypto$1.randomUUID();
+    const color = options?.color && TAB_GROUP_COLORS.includes(options.color) ? options.color : TAB_GROUP_COLORS[this.tabGroups.size % TAB_GROUP_COLORS.length];
+    this.tabGroups.set(groupId, {
+      id: groupId,
+      name: options?.name?.trim() || `Group ${this.tabGroups.size + 1}`,
+      color,
+      collapsed: false
+    });
+    this.assignTabToGroup(id, groupId);
+    this.removeGroupIfEmpty(previousGroupId);
+    return groupId;
+  }
+  assignTabToGroup(id, groupId) {
+    const tab = this.tabs.get(id);
+    if (!tab || !this.tabGroups.has(groupId)) return;
+    const previousGroupId = tab.state.groupId;
+    tab.setGroup(groupId);
+    this.removeGroupIfEmpty(previousGroupId);
+    this.broadcastState();
+  }
+  removeTabFromGroup(id) {
+    const tab = this.tabs.get(id);
+    if (!tab) return;
+    const groupId = tab.state.groupId;
+    tab.setGroup(void 0);
+    this.removeGroupIfEmpty(groupId);
+    this.broadcastState();
+  }
+  toggleGroupCollapsed(groupId) {
+    const group = this.tabGroups.get(groupId);
+    if (!group) return null;
+    group.collapsed = !group.collapsed;
+    this.broadcastState();
+    return group.collapsed;
+  }
+  setGroupColor(groupId, color) {
+    const group = this.tabGroups.get(groupId);
+    if (!group || !TAB_GROUP_COLORS.includes(color)) return;
+    group.color = color;
+    this.broadcastState();
+  }
+  toggleMuted(id) {
+    return this.tabs.get(id)?.toggleMuted() ?? null;
+  }
+  printTab(id) {
+    const tab = this.tabs.get(id);
+    if (!tab) return;
+    tab.view.webContents.print();
+  }
+  async saveTabAsPdf(id) {
+    const tab = this.tabs.get(id);
+    if (!tab) return null;
+    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+      title: "Save Page as PDF",
+      defaultPath: sanitizePdfFilename(tab.state.title || "Vessel Page"),
+      filters: [{ name: "PDF", extensions: ["pdf"] }]
+    });
+    if (canceled || !filePath) return null;
+    const data = await tab.view.webContents.printToPDF({
+      printBackground: true
+    });
+    await fs.promises.writeFile(filePath, data);
+    return filePath;
+  }
+  async savePage(id, format = "MHTML") {
+    const tab = this.tabs.get(id);
+    if (!tab) return null;
+    const ext = format === "MHTML" ? "mhtml" : "html";
+    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+      title: "Save Page As",
+      defaultPath: sanitizePageFilename(
+        tab.state.title || "Vessel Page",
+        ext
+      ),
+      filters: [
+        { name: format === "MHTML" ? "MHTML" : "HTML", extensions: [ext] }
+      ]
+    });
+    if (canceled || !filePath) return null;
+    await tab.view.webContents.savePage(filePath, format);
+    return filePath;
+  }
   getActiveTab() {
     return this.activeTabId ? this.tabs.get(this.activeTabId) : void 0;
   }
@@ -2504,7 +2749,10 @@ class TabManager {
     return this.activeTabId;
   }
   getAllStates() {
-    return this.order.map((id) => this.tabs.get(id).state);
+    return this.order.map((id) => this.withGroupState(this.tabs.get(id).state));
+  }
+  getGroups() {
+    return Array.from(this.tabGroups.values());
   }
   findTabByWebContentsId(webContentsId) {
     for (const id of this.order) {
@@ -2537,7 +2785,10 @@ class TabManager {
         id: state2.id,
         url: state2.url || "about:blank",
         title: state2.title,
-        adBlockingEnabled: state2.adBlockingEnabled
+        adBlockingEnabled: state2.adBlockingEnabled,
+        isPinned: state2.isPinned,
+        groupName: state2.groupName,
+        groupColor: state2.groupColor
       })),
       activeIndex: activeIndex >= 0 ? activeIndex : 0,
       activeTabId: activeId || void 0,
@@ -2552,12 +2803,33 @@ class TabManager {
       Math.min(snapshot.activeIndex, tabs.length - 1)
     );
     this.destroyAllTabs();
+    const restoredGroups = /* @__PURE__ */ new Map();
     const ids = tabs.map(
       (tab, index) => this.createTab(tab.url || "about:blank", {
         background: index !== activeIndex,
         adBlockingEnabled: tab.adBlockingEnabled ?? true
       })
     );
+    tabs.forEach((tab, index) => {
+      if (tab.isPinned && ids[index]) {
+        this.pinTab(ids[index]);
+      }
+      if (tab.groupName && ids[index]) {
+        const key = `${tab.groupName}|${tab.groupColor ?? "blue"}`;
+        let groupId = restoredGroups.get(key);
+        if (!groupId) {
+          groupId = crypto$1.randomUUID();
+          restoredGroups.set(key, groupId);
+          this.tabGroups.set(groupId, {
+            id: groupId,
+            name: tab.groupName,
+            color: tab.groupColor ?? "blue",
+            collapsed: false
+          });
+        }
+        this.assignTabToGroup(ids[index], groupId);
+      }
+    });
     const activeId = ids[activeIndex];
     if (activeId) {
       this.switchTab(activeId);
@@ -2576,6 +2848,7 @@ class TabManager {
     }
     this.tabs.clear();
     this.order = [];
+    this.tabGroups.clear();
     this.activeTabId = null;
     this.broadcastState();
   }
@@ -2692,6 +2965,24 @@ class TabManager {
       message: `Color changed to ${color}`
     });
   }
+  withGroupState(state2) {
+    if (!state2.groupId) return state2;
+    const group = this.tabGroups.get(state2.groupId);
+    if (!group) return { ...state2, groupId: void 0 };
+    return {
+      ...state2,
+      groupName: group.name,
+      groupColor: group.color,
+      groupCollapsed: group.collapsed
+    };
+  }
+  removeGroupIfEmpty(groupId) {
+    if (!groupId) return;
+    for (const tab of this.tabs.values()) {
+      if (tab.state.groupId === groupId) return;
+    }
+    this.tabGroups.delete(groupId);
+  }
   async removeHighlightMarksForText(wc, text) {
     await wc.executeJavaScript(
       `(function() {
@@ -2773,6 +3064,8 @@ const Channels = {
   BOOKMARK_SAVE: "bookmarks:save",
   BOOKMARK_UPDATE: "bookmarks:update-item",
   BOOKMARK_REMOVE: "bookmarks:remove",
+  BOOKMARKS_EXPORT_HTML: "bookmarks:export-html",
+  BOOKMARKS_EXPORT_JSON: "bookmarks:export-json",
   BOOKMARK_ADD_CONTEXT_TO_CHAT: "bookmarks:add-context-to-chat",
   FOLDER_CREATE: "bookmarks:folder-create",
   FOLDER_REMOVE: "bookmarks:folder-remove",
@@ -2801,6 +3094,23 @@ const Channels = {
   TAB_REOPEN_CLOSED: "tab:reopen-closed",
   TAB_DUPLICATE: "tab:duplicate",
   TAB_CONTEXT_MENU: "tab:context-menu",
+  // Pin tabs
+  TAB_PIN: "tab:pin",
+  TAB_UNPIN: "tab:unpin",
+  // Tab groups
+  TAB_GROUP_CREATE: "tab-group:create",
+  TAB_GROUP_ADD_TAB: "tab-group:add-tab",
+  TAB_GROUP_REMOVE_TAB: "tab-group:remove-tab",
+  TAB_GROUP_TOGGLE_COLLAPSED: "tab-group:toggle-collapsed",
+  TAB_GROUP_SET_COLOR: "tab-group:set-color",
+  TAB_GROUP_CONTEXT_MENU: "tab-group:context-menu",
+  // Audio / mute
+  TAB_TOGGLE_MUTE: "tab:toggle-mute",
+  // Print
+  TAB_PRINT: "tab:print",
+  TAB_PRINT_TO_PDF: "tab:print-to-pdf",
+  // Windows
+  OPEN_NEW_WINDOW: "window:open-new",
   // Private browsing
   OPEN_PRIVATE_WINDOW: "private:open-window",
   IS_PRIVATE_MODE: "private:is-private",
@@ -5694,7 +6004,7 @@ function enableClipboardShortcuts(view) {
     }
   });
 }
-const CHROME_HEIGHT$1 = 110;
+const CHROME_HEIGHT$2 = 110;
 const DEFAULT_DEVTOOLS_PANEL_HEIGHT = 250;
 const MIN_DEVTOOLS_PANEL = 120;
 const MAX_DEVTOOLS_PANEL = 600;
@@ -5836,7 +6146,8 @@ function createMainWindow(onTabStateChange) {
       preload: path.join(__dirname, "../preload/index.js"),
       sandbox: true,
       contextIsolation: true,
-      nodeIntegration: false
+      nodeIntegration: false,
+      spellcheck: false
     }
   });
   chromeView.setBackgroundColor("#00000000");
@@ -5846,7 +6157,8 @@ function createMainWindow(onTabStateChange) {
       preload: path.join(__dirname, "../preload/index.js"),
       sandbox: true,
       contextIsolation: true,
-      nodeIntegration: false
+      nodeIntegration: false,
+      spellcheck: false
     }
   });
   sidebarView.setBackgroundColor("#00000000");
@@ -5860,7 +6172,8 @@ function createMainWindow(onTabStateChange) {
       preload: path.join(__dirname, "../preload/index.js"),
       sandbox: true,
       contextIsolation: true,
-      nodeIntegration: false
+      nodeIntegration: false,
+      spellcheck: false
     }
   });
   devtoolsPanelView.setBackgroundColor("#00000000");
@@ -5909,7 +6222,7 @@ function layoutViews(state2) {
     uiState
   } = state2;
   const [width, height] = mainWindow.getContentSize();
-  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT$1;
+  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT$2;
   const sidebarWidth = uiState.sidebarOpen ? uiState.sidebarWidth : 0;
   const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
   const chromeNeedsFullHeight = uiState.settingsOpen;
@@ -5959,7 +6272,7 @@ function layoutViews(state2) {
 function resizeSidebarViews(state2) {
   const { mainWindow, sidebarView, devtoolsPanelView, tabManager, uiState } = state2;
   const [width, height] = mainWindow.getContentSize();
-  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT$1;
+  const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT$2;
   const sidebarWidth = uiState.sidebarOpen ? uiState.sidebarWidth : 0;
   const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
   const resizeHandleOverlap = 6;
@@ -9851,7 +10164,7 @@ function buildCompactScopedContext(page, mode, pageType = detectPageType(page))
   const primaryResults = primaryResultElements.map(formatElement);
   if (primaryResults.length > 0) {
     lines.push("");
-    lines.push("### Results — click one of these to open a product");
+    lines.push("### Primary Results");
     lines.push(...primaryResults.map((item) => `- ${item}`));
     lines.push("");
     lines.push("IMPORTANT: Use click(index=N) on a result above. Do NOT click filter or sort links.");
@@ -9995,6 +10308,61 @@ const TOOL_DEFINITIONS = [
     },
     tier: 2
   },
+  {
+    name: "list_groups",
+    title: "List Tab Groups",
+    description: "List all tab groups with their IDs, names, colors, collapsed state, and member tab count.",
+    tier: 2
+  },
+  {
+    name: "create_group",
+    title: "Create Tab Group",
+    description: "Create a new tab group from the active tab or a specified tab. Optionally provide a name and color.",
+    inputSchema: {
+      tabId: zod.z.string().optional().describe("Tab ID to group (defaults to active tab)"),
+      name: zod.z.string().optional().describe("Optional group name"),
+      color: zod.z.enum(["blue", "green", "yellow", "orange", "red", "purple", "gray"]).optional().describe("Optional group color")
+    },
+    tier: 2
+  },
+  {
+    name: "assign_to_group",
+    title: "Assign Tab to Group",
+    description: "Move a tab into an existing group by ID. Defaults to the active tab.",
+    inputSchema: {
+      groupId: zod.z.string().describe("Group ID to assign the tab to"),
+      tabId: zod.z.string().optional().describe("Tab ID to move (defaults to active tab)")
+    },
+    tier: 2
+  },
+  {
+    name: "remove_from_group",
+    title: "Remove Tab from Group",
+    description: "Ungroup a tab. Defaults to the active tab.",
+    inputSchema: {
+      tabId: zod.z.string().optional().describe("Tab ID to ungroup (defaults to active tab)")
+    },
+    tier: 2
+  },
+  {
+    name: "toggle_group",
+    title: "Toggle Group Collapsed",
+    description: "Collapse or expand a tab group.",
+    inputSchema: {
+      groupId: zod.z.string().describe("Group ID to toggle")
+    },
+    tier: 2
+  },
+  {
+    name: "set_group_color",
+    title: "Set Group Color",
+    description: "Change the color of a tab group.",
+    inputSchema: {
+      groupId: zod.z.string().describe("Group ID"),
+      color: zod.z.enum(["blue", "green", "yellow", "orange", "red", "purple", "gray"]).describe("New color")
+    },
+    tier: 2
+  },
   // --- Navigation ---
   {
     name: "navigate",
@@ -10777,6 +11145,12 @@ function shouldIncludeTool(toolName, pageType, intents, profile) {
     case "switch_tab":
     case "create_tab":
     case "set_ad_blocking":
+    case "list_groups":
+    case "create_group":
+    case "assign_to_group":
+    case "remove_from_group":
+    case "toggle_group":
+    case "set_group_color":
       return intents.has("tabs") || intents.has("debug");
     case "save_session":
     case "load_session":
@@ -10828,14 +11202,6 @@ function pruneToolsForContext(tools, pageType, query = "", options = {}) {
     return description !== tool.description ? { ...tool, description } : tool;
   });
 }
-const SEARCH_ENGINE_PRESETS = {
-  duckduckgo: { label: "DuckDuckGo", url: "https://duckduckgo.com/?q=" },
-  google: { label: "Google", url: "https://www.google.com/search?q=" },
-  bing: { label: "Bing", url: "https://www.bing.com/search?q=" },
-  brave: { label: "Brave Search", url: "https://search.brave.com/search?q=" },
-  ecosia: { label: "Ecosia", url: "https://www.ecosia.org/search?q=" },
-  kagi: { label: "Kagi", url: "https://kagi.com/search?q=" }
-};
 function trimText(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -11027,6 +11393,7 @@ function normalizeBookmarkMetadataUpdate(input) {
 }
 const UNSORTED_ID = "unsorted";
 const ARCHIVE_FOLDER_NAME = "Archive";
+const NETSCAPE_BOOKMARKS_DOCTYPE = "<!DOCTYPE NETSCAPE-Bookmark-file-1>";
 const SAVE_DEBOUNCE_MS$1 = 250;
 let state$1 = null;
 const listeners = /* @__PURE__ */ new Set();
@@ -11039,6 +11406,19 @@ function cloneState(current) {
 function getBookmarksPath() {
   return path.join(electron.app.getPath("userData"), "vessel-bookmarks.json");
 }
+function createPersistence() {
+  return createDebouncedJsonPersistence({
+    debounceMs: SAVE_DEBOUNCE_MS$1,
+    filePath: getBookmarksPath(),
+    getValue: () => state$1,
+    logLabel: "bookmarks"
+  });
+}
+let persistence$1 = null;
+function getPersistence() {
+  persistence$1 ??= createPersistence();
+  return persistence$1;
+}
 function load$1() {
   if (state$1) return state$1;
   state$1 = loadJsonFile({
@@ -11054,14 +11434,8 @@ function load$1() {
   });
   return state$1;
 }
-const persistence$1 = createDebouncedJsonPersistence({
-  debounceMs: SAVE_DEBOUNCE_MS$1,
-  filePath: getBookmarksPath(),
-  getValue: () => state$1,
-  logLabel: "bookmarks"
-});
 function save() {
-  persistence$1.schedule();
+  getPersistence().schedule();
 }
 function assignDefinedBookmarkFields(bookmark, fields) {
   if (!fields) return;
@@ -11077,9 +11451,81 @@ function emit() {
     listener(snapshot);
   }
 }
+function escapeBookmarkHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function toNetscapeTimestamp(value) {
+  if (!value) return Math.floor(Date.now() / 1e3);
+  const time = Date.parse(value);
+  return Number.isNaN(time) ? Math.floor(Date.now() / 1e3) : Math.floor(time / 1e3);
+}
+function getBookmarkDescription(bookmark) {
+  const lines = [
+    bookmark.note ? `Note: ${bookmark.note}` : "",
+    bookmark.intent ? `Intent: ${bookmark.intent}` : "",
+    bookmark.expectedContent ? `Expected content: ${bookmark.expectedContent}` : "",
+    bookmark.keyFields?.length ? `Key fields: ${bookmark.keyFields.join(", ")}` : "",
+    bookmark.agentHints && Object.keys(bookmark.agentHints).length > 0 ? `Agent hints: ${Object.entries(bookmark.agentHints).map(([key, value]) => `${key}: ${value}`).join("; ")}` : ""
+  ].filter(Boolean);
+  return lines.join("\n");
+}
+function appendBookmarkHtml(lines, bookmark, options, indent) {
+  const addDate = toNetscapeTimestamp(bookmark.savedAt);
+  lines.push(
+    `${indent}<DT><A HREF="${escapeBookmarkHtml(bookmark.url)}" ADD_DATE="${addDate}">${escapeBookmarkHtml(bookmark.title || bookmark.url)}</A>`
+  );
+  if (!options.includeNotes) return;
+  const description = getBookmarkDescription(bookmark);
+  if (description) {
+    lines.push(`${indent}<DD>${escapeBookmarkHtml(description)}`);
+  }
+}
 function getState() {
   return cloneState(load$1());
 }
+function exportBookmarksHtml(options = {}) {
+  const current = getState();
+  const resolvedOptions = {
+    includeNotes: options.includeNotes ?? false
+  };
+  const now = Math.floor(Date.now() / 1e3);
+  const folders = [
+    { id: UNSORTED_ID, name: "Vessel Bookmarks", createdAt: "", summary: "" },
+    ...current.folders
+  ];
+  const lines = [
+    NETSCAPE_BOOKMARKS_DOCTYPE,
+    '<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">',
+    "<TITLE>Bookmarks</TITLE>",
+    "<H1>Bookmarks</H1>",
+    "<DL><p>"
+  ];
+  for (const folder of folders) {
+    const items = current.bookmarks.filter(
+      (bookmark) => bookmark.folderId === folder.id
+    );
+    if (items.length === 0) continue;
+    const addDate = toNetscapeTimestamp(folder.createdAt) || now;
+    lines.push(
+      `    <DT><H3 ADD_DATE="${addDate}" LAST_MODIFIED="${now}">${escapeBookmarkHtml(folder.name)}</H3>`
+    );
+    if (resolvedOptions.includeNotes && folder.summary) {
+      lines.push(`    <DD>${escapeBookmarkHtml(folder.summary)}`);
+    }
+    lines.push("    <DL><p>");
+    for (const bookmark of items) {
+      appendBookmarkHtml(lines, bookmark, resolvedOptions, "        ");
+    }
+    lines.push("    </DL><p>");
+  }
+  lines.push("</DL><p>");
+  return `${lines.join("\n")}
+`;
+}
+function exportBookmarksJson() {
+  return `${JSON.stringify(getState(), null, 2)}
+`;
+}
 function subscribe(listener) {
   listeners.add(listener);
   return () => {
@@ -11350,7 +11796,7 @@ function renameFolder(id, newName, summary) {
   return { ...folder };
 }
 function flushPersist$1() {
-  return persistence$1.flush();
+  return getPersistence().flush();
 }
 function normalizeText(text) {
   return text?.trim() ?? "";
@@ -19304,6 +19750,120 @@ ${buildScopedContext(pageContent, mode)}`;
       return `Closed tab ${tabId}`;
     })
   );
+  server.registerTool(
+    "list_groups",
+    {
+      title: "List Tab Groups",
+      description: "List all tab groups with their IDs, names, colors, collapsed state, and member tab count."
+    },
+    async () => {
+      const groups = tabManager.getGroups();
+      const tabs = tabManager.getAllStates();
+      if (groups.length === 0) {
+        return asTextResponse("No tab groups");
+      }
+      const lines = groups.map((g) => {
+        const count = tabs.filter((t) => t.groupId === g.id).length;
+        return `[${g.id}] ${g.name} — color:${g.color} collapsed:${g.collapsed} tabs:${count}`;
+      });
+      return asTextResponse(lines.join("\n"));
+    }
+  );
+  server.registerTool(
+    "create_group",
+    {
+      title: "Create Tab Group",
+      description: "Create a new tab group from the active tab or a specified tab. Optionally provide a name and color.",
+      inputSchema: {
+        tabId: zod.z.string().optional().describe("Tab ID to group (defaults to active tab)"),
+        name: zod.z.string().optional().describe("Optional group name"),
+        color: zod.z.enum(["blue", "green", "yellow", "orange", "red", "purple", "gray"]).optional().describe("Optional group color")
+      }
+    },
+    async ({ tabId, name, color }) => withAction(runtime2, tabManager, "create_group", { tabId, name, color }, async () => {
+      const targetId = tabId || tabManager.getActiveTabId();
+      if (!targetId) {
+        return "Error: No active tab";
+      }
+      const groupId = tabManager.createGroupFromTab(targetId, {
+        name: name || void 0,
+        color: color || void 0
+      });
+      if (!groupId) {
+        return "Error: Could not create group";
+      }
+      return `Created group ${groupId}`;
+    })
+  );
+  server.registerTool(
+    "assign_to_group",
+    {
+      title: "Assign Tab to Group",
+      description: "Move a tab into an existing group by ID. Defaults to the active tab.",
+      inputSchema: {
+        groupId: zod.z.string().describe("Group ID to assign the tab to"),
+        tabId: zod.z.string().optional().describe("Tab ID to move (defaults to active tab)")
+      }
+    },
+    async ({ groupId, tabId }) => withAction(runtime2, tabManager, "assign_to_group", { groupId, tabId }, async () => {
+      const targetId = tabId || tabManager.getActiveTabId();
+      if (!targetId) {
+        return "Error: No active tab";
+      }
+      tabManager.assignTabToGroup(targetId, groupId);
+      return `Assigned tab ${targetId} to group ${groupId}`;
+    })
+  );
+  server.registerTool(
+    "remove_from_group",
+    {
+      title: "Remove Tab from Group",
+      description: "Ungroup a tab. Defaults to the active tab.",
+      inputSchema: {
+        tabId: zod.z.string().optional().describe("Tab ID to ungroup (defaults to active tab)")
+      }
+    },
+    async ({ tabId }) => withAction(runtime2, tabManager, "remove_from_group", { tabId }, async () => {
+      const targetId = tabId || tabManager.getActiveTabId();
+      if (!targetId) {
+        return "Error: No active tab";
+      }
+      tabManager.removeTabFromGroup(targetId);
+      return `Removed tab ${targetId} from group`;
+    })
+  );
+  server.registerTool(
+    "toggle_group",
+    {
+      title: "Toggle Group Collapsed",
+      description: "Collapse or expand a tab group.",
+      inputSchema: {
+        groupId: zod.z.string().describe("Group ID to toggle")
+      }
+    },
+    async ({ groupId }) => withAction(runtime2, tabManager, "toggle_group", { groupId }, async () => {
+      const collapsed = tabManager.toggleGroupCollapsed(groupId);
+      if (collapsed === null) {
+        return "Error: Group not found";
+      }
+      return collapsed ? `Collapsed group ${groupId}` : `Expanded group ${groupId}`;
+    })
+  );
+  server.registerTool(
+    "set_group_color",
+    {
+      title: "Set Group Color",
+      description: "Change the color of a tab group.",
+      inputSchema: {
+        groupId: zod.z.string().describe("Group ID"),
+        color: zod.z.enum(["blue", "green", "yellow", "orange", "red", "purple", "gray"]).describe("New color")
+      }
+    },
+    async ({ groupId, color }) => withAction(runtime2, tabManager, "set_group_color", { groupId, color }, async () => {
+      tabManager.setGroupColor(groupId, color);
+      return `Set group ${groupId} color to ${color}`;
+    })
+  );
   server.registerTool(
     "checkpoint_create",
     {
@@ -22520,6 +23080,7 @@ const THIRD_PARTY_PATH_PATTERNS = [
   /\/pixel/i
 ];
 let installed = false;
+const defaultSessionTabManagers = /* @__PURE__ */ new Set();
 function normalizeHostname(value) {
   return value.trim().toLowerCase().replace(/\.$/, "");
 }
@@ -22563,6 +23124,7 @@ function shouldBlockRequest(details) {
   return THIRD_PARTY_PATH_PATTERNS.some((pattern) => pattern.test(candidate));
 }
 function installAdBlocking(tabManager) {
+  defaultSessionTabManagers.add(tabManager);
   if (installed) return;
   installed = true;
   electron.session.defaultSession.webRequest.onBeforeRequest((details, callback) => {
@@ -22571,13 +23133,19 @@ function installAdBlocking(tabManager) {
       callback({});
       return;
     }
-    if (!tabManager.isAdBlockingEnabledForWebContents(webContentsId)) {
+    const manager = [...defaultSessionTabManagers].find(
+      (candidate) => candidate.findTabByWebContentsId(webContentsId)
+    );
+    if (!manager?.isAdBlockingEnabledForWebContents(webContentsId)) {
       callback({});
       return;
     }
     callback({ cancel: shouldBlockRequest(details) });
   });
 }
+function unregisterAdBlockingTabManager(tabManager) {
+  defaultSessionTabManagers.delete(tabManager);
+}
 function installAdBlockingForSession(ses, tabManager) {
   ses.webRequest.onBeforeRequest((details, callback) => {
     const webContentsId = typeof details.webContentsId === "number" ? details.webContentsId : null;
@@ -22592,6 +23160,8 @@ function installAdBlockingForSession(ses, tabManager) {
     callback({ cancel: shouldBlockRequest(details) });
   });
 }
+const defaultDownloadViews = /* @__PURE__ */ new Set();
+let defaultDownloadHandlerInstalled = false;
 function resolveDownloadPath(downloadDir, filename) {
   fs$1.mkdirSync(downloadDir, { recursive: true });
   const parsed = path.parse(filename);
@@ -22606,9 +23176,23 @@ function resolveDownloadPath(downloadDir, filename) {
   }
 }
 function installDownloadHandler(chromeView) {
-  installDownloadHandlerForSession(electron.session.defaultSession, chromeView);
+  defaultDownloadViews.add(chromeView);
+  if (defaultDownloadHandlerInstalled) return;
+  defaultDownloadHandlerInstalled = true;
+  installDownloadHandlerForSession(electron.session.defaultSession, defaultDownloadViews);
+}
+function unregisterDownloadHandler(chromeView) {
+  defaultDownloadViews.delete(chromeView);
 }
 function installDownloadHandlerForSession(targetSession, chromeView) {
+  const send = (channel, info) => {
+    const views = chromeView instanceof electron.WebContentsView ? [chromeView] : [...chromeView];
+    for (const view of views) {
+      if (!view.webContents.isDestroyed()) {
+        view.webContents.send(channel, info);
+      }
+    }
+  };
   targetSession.on("will-download", (_event, item) => {
     const settings2 = loadSettings();
     const downloadDir = settings2.downloadPath.trim() || electron.app.getPath("downloads");
@@ -22622,30 +23206,24 @@ function installDownloadHandlerForSession(targetSession, chromeView) {
       receivedBytes: 0,
       state: "progressing"
     };
-    if (!chromeView.webContents.isDestroyed()) {
-      chromeView.webContents.send(Channels.DOWNLOAD_STARTED, info);
-    }
+    send(Channels.DOWNLOAD_STARTED, info);
     item.on("updated", (_event2, state2) => {
       info.receivedBytes = item.getReceivedBytes();
       info.totalBytes = item.getTotalBytes();
       info.state = state2 === "progressing" ? "progressing" : "interrupted";
-      if (!chromeView.webContents.isDestroyed()) {
-        chromeView.webContents.send(Channels.DOWNLOAD_PROGRESS, info);
-      }
+      send(Channels.DOWNLOAD_PROGRESS, info);
     });
     item.once("done", (_event2, state2) => {
       info.receivedBytes = item.getReceivedBytes();
       info.state = state2 === "completed" ? "completed" : "cancelled";
-      if (!chromeView.webContents.isDestroyed()) {
-        chromeView.webContents.send(Channels.DOWNLOAD_DONE, info);
-      }
+      send(Channels.DOWNLOAD_DONE, info);
     });
   });
 }
 const logger$5 = createLogger("PrivateWindow");
-const CHROME_HEIGHT = 110;
+const CHROME_HEIGHT$1 = 110;
 const privateWindows = /* @__PURE__ */ new Set();
-function resolveRendererFile$1() {
+function resolveRendererFile$2() {
   const candidates = [
     path.join(__dirname, "../../out/renderer/index.html"),
     path.join(__dirname, "../../../out/renderer/index.html")
@@ -22662,16 +23240,16 @@ function resolveRendererFile$1() {
 function layoutPrivateViews(state2) {
   const { window: win, chromeView, tabManager } = state2;
   const [width, height] = win.getContentSize();
-  chromeView.setBounds({ x: 0, y: 0, width, height: CHROME_HEIGHT });
+  chromeView.setBounds({ x: 0, y: 0, width, height: CHROME_HEIGHT$1 });
   win.contentView.removeChildView(chromeView);
   win.contentView.addChildView(chromeView);
   const activeTab = tabManager.getActiveTab();
   if (activeTab) {
     activeTab.view.setBounds({
       x: 0,
-      y: CHROME_HEIGHT,
+      y: CHROME_HEIGHT$1,
       width,
-      height: height - CHROME_HEIGHT
+      height: height - CHROME_HEIGHT$1
     });
   }
 }
@@ -22683,7 +23261,7 @@ function loadPrivateRenderer(chromeView) {
     url.searchParams.set("private", "1");
     chromeView.webContents.loadURL(url.toString());
   } else {
-    chromeView.webContents.loadFile(resolveRendererFile$1(), {
+    chromeView.webContents.loadFile(resolveRendererFile$2(), {
       query: { view: "chrome", private: "1" }
     });
   }
@@ -22772,12 +23350,68 @@ function registerPrivateIpcHandlers(state2) {
     if (newId) layoutPrivateViews(state2);
     return newId;
   });
+  ipc.handle(Channels.TAB_PIN, (_e, id) => {
+    tabManager.pinTab(id);
+  });
+  ipc.handle(Channels.TAB_UNPIN, (_e, id) => {
+    tabManager.unpinTab(id);
+  });
+  ipc.handle(Channels.TAB_GROUP_CREATE, (_e, id) => {
+    return tabManager.createGroupFromTab(id);
+  });
+  ipc.handle(Channels.TAB_GROUP_ADD_TAB, (_e, id, groupId) => {
+    tabManager.assignTabToGroup(id, groupId);
+  });
+  ipc.handle(Channels.TAB_GROUP_REMOVE_TAB, (_e, id) => {
+    tabManager.removeTabFromGroup(id);
+  });
+  ipc.handle(Channels.TAB_GROUP_TOGGLE_COLLAPSED, (_e, groupId) => {
+    return tabManager.toggleGroupCollapsed(groupId);
+  });
+  ipc.handle(
+    Channels.TAB_GROUP_SET_COLOR,
+    (_e, groupId, color) => {
+      tabManager.setGroupColor(groupId, color);
+    }
+  );
+  ipc.handle(Channels.TAB_TOGGLE_MUTE, (_e, id) => {
+    return tabManager.toggleMuted(id);
+  });
+  ipc.handle(Channels.TAB_PRINT, (_e, id) => {
+    tabManager.printTab(id);
+  });
+  ipc.handle(Channels.TAB_PRINT_TO_PDF, (_e, id) => {
+    return tabManager.saveTabAsPdf(id);
+  });
   ipc.on(Channels.TAB_CONTEXT_MENU, (_e, id) => {
     const { Menu, MenuItem } = require("electron");
+    const tab = tabManager.getTab(id);
+    const isPinned = tab?.state.isPinned ?? false;
+    const groupId = tab?.state.groupId;
+    const isMuted = tab?.state.isMuted ?? false;
+    const groups = tabManager.getAllStates().filter((state22) => state22.groupId && state22.groupId !== groupId).reduce(
+      (map, state22) => map.set(state22.groupId, {
+        id: state22.groupId,
+        name: state22.groupName || "Group"
+      }),
+      /* @__PURE__ */ new Map()
+    );
     const menu = new Menu();
     menu.append(
       new MenuItem({
-        label: "Duplicate Tab",
+        label: isPinned ? "Unpin Tab" : "Pin Tab",
+        click: () => {
+          if (isPinned) {
+            tabManager.unpinTab(id);
+          } else {
+            tabManager.pinTab(id);
+          }
+        }
+      })
+    );
+    menu.append(
+      new MenuItem({
+        label: "Duplicate Tab",
         click: () => {
           const newId = tabManager.duplicateTab(id);
           if (newId) layoutPrivateViews(state2);
@@ -22786,19 +23420,110 @@ function registerPrivateIpcHandlers(state2) {
     );
     menu.append(
       new MenuItem({
-        label: "Close Tab",
+        label: "Add to New Group",
         click: () => {
-          tabManager.closeTab(id);
-          layoutPrivateViews(state2);
+          tabManager.createGroupFromTab(id);
         }
       })
     );
+    if (groups.size > 0) {
+      menu.append(
+        new MenuItem({
+          label: "Add to Group",
+          submenu: [...groups.values()].map(
+            (group) => new MenuItem({
+              label: group.name,
+              click: () => tabManager.assignTabToGroup(id, group.id)
+            })
+          )
+        })
+      );
+    }
+    if (groupId) {
+      menu.append(
+        new MenuItem({
+          label: "Remove from Group",
+          click: () => {
+            tabManager.removeTabFromGroup(id);
+          }
+        })
+      );
+    }
+    menu.append(
+      new MenuItem({
+        label: isMuted ? "Unmute Tab" : "Mute Tab",
+        click: () => {
+          tabManager.toggleMuted(id);
+        }
+      })
+    );
+    menu.append(new MenuItem({ type: "separator" }));
+    menu.append(
+      new MenuItem({
+        label: "Print Page",
+        click: () => {
+          tabManager.printTab(id);
+        }
+      })
+    );
+    menu.append(
+      new MenuItem({
+        label: "Save Page as PDF",
+        click: () => {
+          void tabManager.saveTabAsPdf(id).catch((error) => {
+            logger$5.warn("Failed to save private page as PDF:", error);
+          });
+        }
+      })
+    );
+    if (!isPinned) {
+      menu.append(new MenuItem({ type: "separator" }));
+      menu.append(
+        new MenuItem({
+          label: "Close Tab",
+          click: () => {
+            tabManager.closeTab(id);
+            layoutPrivateViews(state2);
+          }
+        })
+      );
+    }
+    menu.popup({ window: state2.window });
+  });
+  ipc.on(Channels.TAB_GROUP_CONTEXT_MENU, (_e, groupId) => {
+    const { Menu, MenuItem } = require("electron");
+    const firstTab = tabManager.getAllStates().find((tab) => tab.groupId === groupId);
+    if (!firstTab) return;
+    const menu = new Menu();
+    menu.append(
+      new MenuItem({
+        label: firstTab.groupCollapsed ? "Expand Group" : "Collapse Group",
+        click: () => tabManager.toggleGroupCollapsed(groupId)
+      })
+    );
+    menu.append(
+      new MenuItem({
+        label: "Group Color",
+        submenu: TAB_GROUP_COLORS.map(
+          (color) => new MenuItem({
+            label: TAB_GROUP_COLOR_LABELS[color],
+            type: "radio",
+            checked: firstTab.groupColor === color,
+            click: () => tabManager.setGroupColor(groupId, color)
+          })
+        )
+      })
+    );
     menu.popup({ window: state2.window });
   });
   ipc.handle(Channels.IS_PRIVATE_MODE, () => true);
   ipc.handle(Channels.OPEN_PRIVATE_WINDOW, () => {
     createPrivateWindow();
   });
+  ipc.handle(Channels.OPEN_NEW_WINDOW, () => {
+    const { createSecondaryWindow: createSecondaryWindow2 } = require("../secondary/window");
+    createSecondaryWindow2();
+  });
   ipc.handle(Channels.WINDOW_MINIMIZE, () => {
     state2.window.minimize();
   });
@@ -22917,6 +23642,373 @@ function createPrivateWindow() {
   logger$5.info("Private browsing window opened");
   return state2;
 }
+const CHROME_HEIGHT = 110;
+const secondaryWindows = /* @__PURE__ */ new Set();
+function resolveRendererFile$1() {
+  const candidates = [
+    path.join(__dirname, "../../out/renderer/index.html"),
+    path.join(__dirname, "../../../out/renderer/index.html")
+  ];
+  for (const candidate of candidates) {
+    try {
+      fs.accessSync(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return path.join(__dirname, "../../out/renderer/index.html");
+}
+function layoutSecondaryViews(state2) {
+  const { window: win, chromeView, tabManager } = state2;
+  const [width, height] = win.getContentSize();
+  chromeView.setBounds({ x: 0, y: 0, width, height: CHROME_HEIGHT });
+  win.contentView.removeChildView(chromeView);
+  win.contentView.addChildView(chromeView);
+  const activeTab = tabManager.getActiveTab();
+  if (activeTab) {
+    activeTab.view.setBounds({
+      x: 0,
+      y: CHROME_HEIGHT,
+      width,
+      height: height - CHROME_HEIGHT
+    });
+  }
+}
+function loadSecondaryRenderer(chromeView) {
+  const devUrl = process.env.ELECTRON_RENDERER_URL;
+  if (devUrl) {
+    const url = new URL(devUrl);
+    url.searchParams.set("view", "chrome");
+    url.searchParams.set("secondary", "1");
+    chromeView.webContents.loadURL(url.toString());
+  } else {
+    chromeView.webContents.loadFile(resolveRendererFile$1(), {
+      query: { view: "chrome", secondary: "1" }
+    });
+  }
+}
+function showTabContextMenu(state2, id) {
+  const { tabManager } = state2;
+  const tab = tabManager.getTab(id);
+  const isPinned = tab?.state.isPinned ?? false;
+  const groupId = tab?.state.groupId;
+  const isMuted = tab?.state.isMuted ?? false;
+  const groups = tabManager.getAllStates().filter((state22) => state22.groupId && state22.groupId !== groupId).reduce(
+    (map, state22) => map.set(state22.groupId, {
+      id: state22.groupId,
+      name: state22.groupName || "Group"
+    }),
+    /* @__PURE__ */ new Map()
+  );
+  const menu = new electron.Menu();
+  menu.append(
+    new electron.MenuItem({
+      label: isPinned ? "Unpin Tab" : "Pin Tab",
+      click: () => isPinned ? tabManager.unpinTab(id) : tabManager.pinTab(id)
+    })
+  );
+  menu.append(
+    new electron.MenuItem({
+      label: "Duplicate Tab",
+      click: () => {
+        const newId = tabManager.duplicateTab(id);
+        if (newId) layoutSecondaryViews(state2);
+      }
+    })
+  );
+  menu.append(
+    new electron.MenuItem({
+      label: "Add to New Group",
+      click: () => {
+        tabManager.createGroupFromTab(id);
+      }
+    })
+  );
+  if (groups.size > 0) {
+    menu.append(
+      new electron.MenuItem({
+        label: "Add to Group",
+        submenu: [...groups.values()].map(
+          (group) => new electron.MenuItem({
+            label: group.name,
+            click: () => tabManager.assignTabToGroup(id, group.id)
+          })
+        )
+      })
+    );
+  }
+  if (groupId) {
+    menu.append(
+      new electron.MenuItem({
+        label: "Remove from Group",
+        click: () => tabManager.removeTabFromGroup(id)
+      })
+    );
+  }
+  menu.append(
+    new electron.MenuItem({
+      label: isMuted ? "Unmute Tab" : "Mute Tab",
+      click: () => tabManager.toggleMuted(id)
+    })
+  );
+  menu.append(new electron.MenuItem({ type: "separator" }));
+  menu.append(
+    new electron.MenuItem({ label: "Print Page", click: () => tabManager.printTab(id) })
+  );
+  menu.append(
+    new electron.MenuItem({
+      label: "Save Page as PDF",
+      click: () => void tabManager.saveTabAsPdf(id)
+    })
+  );
+  if (!isPinned) {
+    menu.append(new electron.MenuItem({ type: "separator" }));
+    menu.append(
+      new electron.MenuItem({
+        label: "Close Tab",
+        click: () => {
+          tabManager.closeTab(id);
+          layoutSecondaryViews(state2);
+        }
+      })
+    );
+  }
+  menu.popup({ window: state2.window });
+}
+function showGroupContextMenu(state2, groupId) {
+  const { tabManager } = state2;
+  const firstTab = tabManager.getAllStates().find((tab) => tab.groupId === groupId);
+  if (!firstTab) return;
+  const menu = new electron.Menu();
+  menu.append(
+    new electron.MenuItem({
+      label: firstTab.groupCollapsed ? "Expand Group" : "Collapse Group",
+      click: () => tabManager.toggleGroupCollapsed(groupId)
+    })
+  );
+  menu.append(
+    new electron.MenuItem({
+      label: "Group Color",
+      submenu: TAB_GROUP_COLORS.map(
+        (color) => new electron.MenuItem({
+          label: TAB_GROUP_COLOR_LABELS[color],
+          type: "radio",
+          checked: firstTab.groupColor === color,
+          click: () => tabManager.setGroupColor(groupId, color)
+        })
+      )
+    })
+  );
+  menu.popup({ window: state2.window });
+}
+function registerSecondaryIpcHandlers(state2) {
+  const { chromeView, tabManager } = state2;
+  const ipc = chromeView.webContents.ipc;
+  let findResultListener = null;
+  let findWiredWcId = null;
+  const wireFindEvents = (wc) => {
+    if (findWiredWcId === wc.id && findResultListener) return;
+    if (findWiredWcId && findResultListener) {
+      const previous = tabManager.findTabByWebContentsId(findWiredWcId);
+      previous?.view.webContents.removeListener(
+        "found-in-page",
+        findResultListener
+      );
+    }
+    findWiredWcId = wc.id;
+    if (wc.isDestroyed()) return;
+    const listener = (_event, result) => {
+      if (!chromeView.webContents.isDestroyed()) {
+        chromeView.webContents.send(Channels.FIND_IN_PAGE_RESULT, result);
+      }
+    };
+    findResultListener = listener;
+    wc.on("found-in-page", listener);
+    const capturedWcId = wc.id;
+    wc.once("destroyed", () => {
+      if (findWiredWcId === capturedWcId) {
+        findWiredWcId = null;
+        findResultListener = null;
+      }
+    });
+  };
+  ipc.handle(Channels.TAB_CREATE, (_e, url) => {
+    return tabManager.createTab(url || loadSettings().defaultUrl);
+  });
+  ipc.handle(Channels.TAB_CLOSE, (_e, id) => {
+    tabManager.closeTab(id);
+    layoutSecondaryViews(state2);
+  });
+  ipc.handle(Channels.TAB_SWITCH, (_e, id) => {
+    tabManager.switchTab(id);
+    layoutSecondaryViews(state2);
+  });
+  ipc.handle(Channels.TAB_NAVIGATE, (_e, id, url) => {
+    return tabManager.navigateTab(id, url);
+  });
+  ipc.handle(Channels.TAB_BACK, (_e, id) => tabManager.goBack(id));
+  ipc.handle(Channels.TAB_FORWARD, (_e, id) => tabManager.goForward(id));
+  ipc.handle(Channels.TAB_RELOAD, (_e, id) => tabManager.reloadTab(id));
+  ipc.handle(Channels.TAB_TOGGLE_AD_BLOCK, (_e, id) => {
+    const tab = tabManager.getTab(id);
+    if (!tab) return null;
+    const enabled = !tab.state.adBlockingEnabled;
+    tab.setAdBlockingEnabled(enabled);
+    return enabled;
+  });
+  ipc.handle(Channels.TAB_ZOOM_IN, (_e, id) => tabManager.zoomIn(id));
+  ipc.handle(Channels.TAB_ZOOM_OUT, (_e, id) => tabManager.zoomOut(id));
+  ipc.handle(Channels.TAB_ZOOM_RESET, (_e, id) => tabManager.zoomReset(id));
+  ipc.handle(Channels.TAB_REOPEN_CLOSED, () => {
+    const id = tabManager.reopenClosedTab();
+    if (id) layoutSecondaryViews(state2);
+    return id;
+  });
+  ipc.handle(Channels.TAB_DUPLICATE, (_e, id) => {
+    const newId = tabManager.duplicateTab(id);
+    if (newId) layoutSecondaryViews(state2);
+    return newId;
+  });
+  ipc.handle(Channels.TAB_PIN, (_e, id) => tabManager.pinTab(id));
+  ipc.handle(Channels.TAB_UNPIN, (_e, id) => tabManager.unpinTab(id));
+  ipc.handle(
+    Channels.TAB_GROUP_CREATE,
+    (_e, id) => tabManager.createGroupFromTab(id)
+  );
+  ipc.handle(
+    Channels.TAB_GROUP_ADD_TAB,
+    (_e, id, groupId) => tabManager.assignTabToGroup(id, groupId)
+  );
+  ipc.handle(
+    Channels.TAB_GROUP_REMOVE_TAB,
+    (_e, id) => tabManager.removeTabFromGroup(id)
+  );
+  ipc.handle(
+    Channels.TAB_GROUP_TOGGLE_COLLAPSED,
+    (_e, groupId) => tabManager.toggleGroupCollapsed(groupId)
+  );
+  ipc.handle(
+    Channels.TAB_GROUP_SET_COLOR,
+    (_e, groupId, color) => tabManager.setGroupColor(groupId, color)
+  );
+  ipc.handle(
+    Channels.TAB_TOGGLE_MUTE,
+    (_e, id) => tabManager.toggleMuted(id)
+  );
+  ipc.handle(Channels.TAB_PRINT, (_e, id) => tabManager.printTab(id));
+  ipc.handle(
+    Channels.TAB_PRINT_TO_PDF,
+    (_e, id) => tabManager.saveTabAsPdf(id)
+  );
+  ipc.handle(Channels.TAB_STATE_GET, () => ({
+    tabs: tabManager.getAllStates(),
+    activeId: tabManager.getActiveTabId() || ""
+  }));
+  ipc.on(
+    Channels.TAB_CONTEXT_MENU,
+    (_e, id) => showTabContextMenu(state2, id)
+  );
+  ipc.on(
+    Channels.TAB_GROUP_CONTEXT_MENU,
+    (_e, groupId) => showGroupContextMenu(state2, groupId)
+  );
+  ipc.handle(Channels.OPEN_NEW_WINDOW, () => createSecondaryWindow());
+  ipc.handle(Channels.OPEN_PRIVATE_WINDOW, () => {
+    const { createPrivateWindow: createPrivateWindow2 } = require("../private/window");
+    createPrivateWindow2();
+  });
+  ipc.handle(Channels.IS_PRIVATE_MODE, () => false);
+  ipc.handle(Channels.WINDOW_MINIMIZE, () => state2.window.minimize());
+  ipc.handle(Channels.WINDOW_MAXIMIZE, () => {
+    if (state2.window.isMaximized()) state2.window.unmaximize();
+    else state2.window.maximize();
+  });
+  ipc.handle(Channels.WINDOW_CLOSE, () => state2.window.close());
+  ipc.handle(Channels.SETTINGS_VISIBILITY, () => false);
+  ipc.handle(Channels.FOCUS_MODE_TOGGLE, () => false);
+  ipc.handle(Channels.SIDEBAR_TOGGLE, () => ({ open: false, width: 0 }));
+  ipc.handle(Channels.DEVTOOLS_PANEL_TOGGLE, () => ({ open: false }));
+  ipc.handle(
+    Channels.FIND_IN_PAGE_START,
+    (_e, text, options) => {
+      const tab = tabManager.getActiveTab();
+      if (!tab) return null;
+      const wc = tab.view.webContents;
+      if (wc.isDestroyed()) return null;
+      wireFindEvents(wc);
+      return wc.findInPage(text, {
+        forward: options?.forward ?? true,
+        findNext: options?.findNext ?? false
+      });
+    }
+  );
+  ipc.handle(Channels.FIND_IN_PAGE_NEXT, (_e, forward) => {
+    const tab = tabManager.getActiveTab();
+    if (!tab) return null;
+    const wc = tab.view.webContents;
+    if (wc.isDestroyed()) return null;
+    wireFindEvents(wc);
+    return wc.findInPage("", { forward: forward ?? true, findNext: true });
+  });
+  ipc.handle(
+    Channels.FIND_IN_PAGE_STOP,
+    (_e, action) => {
+      const tab = tabManager.getActiveTab();
+      if (!tab) return;
+      const wc = tab.view.webContents;
+      if (wc.isDestroyed()) return;
+      wc.stopFindInPage(action ?? "clearSelection");
+    }
+  );
+}
+function createSecondaryWindow() {
+  const win = new electron.BaseWindow({
+    width: 1280,
+    height: 800,
+    minWidth: 800,
+    minHeight: 600,
+    frame: false,
+    show: false,
+    backgroundColor: "#1a1a1e",
+    title: "Vessel"
+  });
+  const chromeView = new electron.WebContentsView({
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  chromeView.setBackgroundColor("#00000000");
+  win.contentView.addChildView(chromeView);
+  const tabManager = new TabManager(win, (tabs, activeId) => {
+    if (!chromeView.webContents.isDestroyed()) {
+      chromeView.webContents.send(Channels.TAB_STATE_UPDATE, tabs, activeId);
+    }
+    layoutSecondaryViews(state2);
+  });
+  const state2 = { window: win, chromeView, tabManager };
+  installAdBlocking(tabManager);
+  installDownloadHandler(chromeView);
+  registerSecondaryIpcHandlers(state2);
+  win.on("resize", () => layoutSecondaryViews(state2));
+  win.on("show", () => layoutSecondaryViews(state2));
+  win.on("closed", () => {
+    secondaryWindows.delete(state2);
+    unregisterAdBlockingTabManager(tabManager);
+    unregisterDownloadHandler(chromeView);
+    tabManager.destroyAllTabs();
+  });
+  secondaryWindows.add(state2);
+  chromeView.webContents.once("dom-ready", () => {
+    tabManager.createTab(loadSettings().defaultUrl);
+    layoutSecondaryViews(state2);
+  });
+  loadSecondaryRenderer(chromeView);
+  win.show();
+  return state2;
+}
 let activeChatProvider = null;
 const logger$4 = createLogger("IPC");
 const VALID_APPROVAL_MODES = ["auto", "confirm-dangerous", "manual"];
@@ -22925,6 +24017,9 @@ function registerIpcHandlers(windowState, runtime2) {
   electron.ipcMain.handle(Channels.OPEN_PRIVATE_WINDOW, () => {
     createPrivateWindow();
   });
+  electron.ipcMain.handle(Channels.OPEN_NEW_WINDOW, () => {
+    createSecondaryWindow();
+  });
   electron.ipcMain.handle(Channels.IS_PRIVATE_MODE, () => false);
   let sidebarResizeRecoveryTimer = null;
   let sidebarResizeActive = false;
@@ -23136,9 +24231,77 @@ function registerIpcHandlers(windowState, runtime2) {
     if (newId) layoutViews(windowState);
     return newId;
   });
+  electron.ipcMain.handle(Channels.TAB_PIN, (_, id) => {
+    assertString(id, "id");
+    tabManager.pinTab(id);
+  });
+  electron.ipcMain.handle(Channels.TAB_UNPIN, (_, id) => {
+    assertString(id, "id");
+    tabManager.unpinTab(id);
+  });
+  electron.ipcMain.handle(Channels.TAB_GROUP_CREATE, (_, id) => {
+    assertString(id, "id");
+    return tabManager.createGroupFromTab(id);
+  });
+  electron.ipcMain.handle(Channels.TAB_GROUP_ADD_TAB, (_, id, groupId) => {
+    assertString(id, "id");
+    assertString(groupId, "groupId");
+    tabManager.assignTabToGroup(id, groupId);
+  });
+  electron.ipcMain.handle(Channels.TAB_GROUP_REMOVE_TAB, (_, id) => {
+    assertString(id, "id");
+    tabManager.removeTabFromGroup(id);
+  });
+  electron.ipcMain.handle(Channels.TAB_GROUP_TOGGLE_COLLAPSED, (_, groupId) => {
+    assertString(groupId, "groupId");
+    return tabManager.toggleGroupCollapsed(groupId);
+  });
+  electron.ipcMain.handle(
+    Channels.TAB_GROUP_SET_COLOR,
+    (_, groupId, color) => {
+      assertString(groupId, "groupId");
+      assertString(color, "color");
+      tabManager.setGroupColor(groupId, color);
+    }
+  );
+  electron.ipcMain.handle(Channels.TAB_TOGGLE_MUTE, (_, id) => {
+    assertString(id, "id");
+    return tabManager.toggleMuted(id);
+  });
+  electron.ipcMain.handle(Channels.TAB_PRINT, (_, id) => {
+    assertString(id, "id");
+    tabManager.printTab(id);
+  });
+  electron.ipcMain.handle(Channels.TAB_PRINT_TO_PDF, (_, id) => {
+    assertString(id, "id");
+    return tabManager.saveTabAsPdf(id);
+  });
   electron.ipcMain.on(Channels.TAB_CONTEXT_MENU, (_event, id) => {
     assertString(id, "id");
+    const tab = tabManager.getTab(id);
+    const isPinned = tab?.state.isPinned ?? false;
+    const groupId = tab?.state.groupId;
+    const isMuted = tab?.state.isMuted ?? false;
+    const groups = tabManager.getAllStates().filter((state2) => state2.groupId && state2.groupId !== groupId).reduce(
+      (map, state2) => map.set(state2.groupId, {
+        id: state2.groupId,
+        name: state2.groupName || "Group"
+      }),
+      /* @__PURE__ */ new Map()
+    );
     const menu = new electron.Menu();
+    menu.append(
+      new electron.MenuItem({
+        label: isPinned ? "Unpin Tab" : "Pin Tab",
+        click: () => {
+          if (isPinned) {
+            tabManager.unpinTab(id);
+          } else {
+            tabManager.pinTab(id);
+          }
+        }
+      })
+    );
     menu.append(
       new electron.MenuItem({
         label: "Duplicate Tab",
@@ -23150,13 +24313,102 @@ function registerIpcHandlers(windowState, runtime2) {
     );
     menu.append(
       new electron.MenuItem({
-        label: "Close Tab",
+        label: "Add to New Group",
         click: () => {
-          tabManager.closeTab(id);
-          layoutViews(windowState);
+          tabManager.createGroupFromTab(id);
         }
       })
     );
+    if (groups.size > 0) {
+      menu.append(
+        new electron.MenuItem({
+          label: "Add to Group",
+          submenu: [...groups.values()].map(
+            (group) => new electron.MenuItem({
+              label: group.name,
+              click: () => tabManager.assignTabToGroup(id, group.id)
+            })
+          )
+        })
+      );
+    }
+    if (groupId) {
+      menu.append(
+        new electron.MenuItem({
+          label: "Remove from Group",
+          click: () => {
+            tabManager.removeTabFromGroup(id);
+          }
+        })
+      );
+    }
+    menu.append(
+      new electron.MenuItem({
+        label: isMuted ? "Unmute Tab" : "Mute Tab",
+        click: () => {
+          tabManager.toggleMuted(id);
+        }
+      })
+    );
+    menu.append(new electron.MenuItem({ type: "separator" }));
+    menu.append(
+      new electron.MenuItem({
+        label: "Print Page",
+        click: () => {
+          tabManager.printTab(id);
+        }
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        label: "Save Page as PDF",
+        click: () => {
+          void tabManager.saveTabAsPdf(id).catch((error) => {
+            logger$4.warn("Failed to save page as PDF:", error);
+          });
+        }
+      })
+    );
+    if (!isPinned) {
+      menu.append(new electron.MenuItem({ type: "separator" }));
+      menu.append(
+        new electron.MenuItem({
+          label: "Close Tab",
+          click: () => {
+            tabManager.closeTab(id);
+            layoutViews(windowState);
+          }
+        })
+      );
+    }
+    menu.popup({ window: mainWindow });
+  });
+  electron.ipcMain.on(Channels.TAB_GROUP_CONTEXT_MENU, (_event, groupId) => {
+    assertString(groupId, "groupId");
+    const firstTab = tabManager.getAllStates().find((tab) => tab.groupId === groupId);
+    if (!firstTab) return;
+    const menu = new electron.Menu();
+    menu.append(
+      new electron.MenuItem({
+        label: firstTab.groupCollapsed ? "Expand Group" : "Collapse Group",
+        click: () => {
+          tabManager.toggleGroupCollapsed(groupId);
+        }
+      })
+    );
+    menu.append(
+      new electron.MenuItem({
+        label: "Group Color",
+        submenu: TAB_GROUP_COLORS.map(
+          (color) => new electron.MenuItem({
+            label: TAB_GROUP_COLOR_LABELS[color],
+            type: "radio",
+            checked: firstTab.groupColor === color,
+            click: () => tabManager.setGroupColor(groupId, color)
+          })
+        )
+      })
+    );
     menu.popup({ window: mainWindow });
   });
   electron.ipcMain.handle(Channels.TAB_STATE_GET, () => ({
@@ -23423,6 +24675,41 @@ function registerIpcHandlers(windowState, runtime2) {
     trackBookmarkAction("remove");
     return removeBookmark(id);
   });
+  electron.ipcMain.handle(
+    Channels.BOOKMARKS_EXPORT_HTML,
+    async (_, options) => {
+      const { canceled, filePath } = await electron.dialog.showSaveDialog({
+        title: "Export Bookmarks",
+        defaultPath: "vessel-bookmarks.html",
+        filters: [{ name: "HTML Bookmarks", extensions: ["html"] }]
+      });
+      if (canceled || !filePath) return null;
+      const content = exportBookmarksHtml({
+        includeNotes: options?.includeNotes ?? false
+      });
+      await fs.promises.writeFile(filePath, content, "utf-8");
+      trackBookmarkAction("export");
+      return {
+        filePath,
+        count: getState().bookmarks.length
+      };
+    }
+  );
+  electron.ipcMain.handle(Channels.BOOKMARKS_EXPORT_JSON, async () => {
+    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+      title: "Export Vessel Bookmark Archive",
+      defaultPath: "vessel-bookmarks.json",
+      filters: [{ name: "Vessel Bookmark Archive", extensions: ["json"] }]
+    });
+    if (canceled || !filePath) return null;
+    const content = exportBookmarksJson();
+    await fs.promises.writeFile(filePath, content, "utf-8");
+    trackBookmarkAction("export");
+    return {
+      filePath,
+      count: getState().bookmarks.length
+    };
+  });
   electron.ipcMain.handle(Channels.FOLDER_REMOVE, (_, id, deleteContents) => {
     trackBookmarkAction("folder_remove");
     return removeFolder(id, deleteContents ?? false);
@@ -24691,6 +25978,16 @@ function setupAppMenu(handlers) {
     {
       label: "File",
       submenu: [
+        {
+          label: "New Window",
+          accelerator: "CommandOrControl+N",
+          click: handlers.newWindow
+        },
+        {
+          label: "Save Page As...",
+          accelerator: "CommandOrControl+S",
+          click: handlers.savePageAs
+        },
         {
           label: "Reopen Closed Tab",
           accelerator: "CommandOrControl+Shift+T",
@@ -24727,6 +26024,12 @@ function setupAppMenu(handlers) {
           label: "Actual Size",
           accelerator: "CommandOrControl+0",
           click: handlers.zoomReset
+        },
+        { type: "separator" },
+        {
+          label: "View Page Source",
+          accelerator: "CommandOrControl+U",
+          click: handlers.viewPageSource
         }
       ]
     }
@@ -25088,6 +26391,9 @@ async function bootstrap() {
   registerIpcHandlers(windowState, runtime);
   registerHighlightShortcut(windowState.mainWindow, tabManager);
   setupAppMenu({
+    newWindow: () => {
+      createSecondaryWindow();
+    },
     reopenClosedTab: () => {
       const id = tabManager.reopenClosedTab();
       if (id) layoutViews(windowState);
@@ -25103,6 +26409,16 @@ async function bootstrap() {
     zoomReset: () => {
       const id = tabManager.getActiveTabId();
       if (id) tabManager.zoomReset(id);
+    },
+    viewPageSource: () => {
+      const activeTab = tabManager.getActiveTab();
+      if (activeTab) activeTab.viewSource();
+    },
+    savePageAs: () => {
+      const activeTabId = tabManager.getActiveTabId();
+      if (activeTabId) {
+        void tabManager.savePage(activeTabId);
+      }
     }
   });
   subscribe((state2) => {