@quanta-intellect/vessel-browser 0.1.56 → 0.1.58

package/out/main/index.js

@@ -1376,6 +1376,10 @@ async function highlightBatchOnPage(wc, entries) {
 }
 const HIGHLIGHT_SELECTOR = "'.__vessel-highlight, .__vessel-highlight-text'";
 async function getHighlightCount(wc) {
+  if (wc.isDestroyed()) return 0;
+  if (wc.isLoading()) return 0;
+  const currentUrl = wc.getURL();
+  if (!currentUrl || currentUrl === "about:blank") return 0;
   return wc.executeJavaScript(
     `document.querySelectorAll(${HIGHLIGHT_SELECTOR}).length`
   );
@@ -2615,7 +2619,9 @@ const Channels = {
   TAB_BACK: "tab:back",
   TAB_FORWARD: "tab:forward",
   TAB_RELOAD: "tab:reload",
+  TAB_STATE_GET: "tab:state-get",
   TAB_STATE_UPDATE: "tab:state-update",
+  RENDERER_VIEW_READY: "renderer:view-ready",
   // AI
   AI_QUERY: "ai:query",
   AI_STREAM_START: "ai:stream-start",
@@ -5518,9 +5524,9 @@ function layoutViews(state2) {
   if (uiState.sidebarOpen) {
     sidebarView.setBounds({
       x: width - sidebarWidth - resizeHandleOverlap,
-      y: 0,
+      y: chromeHeight,
       width: sidebarWidth + resizeHandleOverlap,
-      height
+      height: height - chromeHeight
     });
   } else {
     sidebarView.setBounds({ x: width, y: 0, width: 0, height: 0 });
@@ -22938,6 +22944,10 @@ function registerIpcHandlers(windowState, runtime2) {
   electron.ipcMain.handle(Channels.TAB_RELOAD, (_, id) => {
     tabManager.reloadTab(id);
   });
+  electron.ipcMain.handle(Channels.TAB_STATE_GET, () => ({
+    tabs: tabManager.getAllStates(),
+    activeId: tabManager.getActiveTabId() || ""
+  }));
   electron.ipcMain.handle(Channels.AI_QUERY, async (_, query, history) => {
     const settings2 = loadSettings();
     const chatConfig = settings2.chatProvider;
@@ -23049,6 +23059,16 @@ function registerIpcHandlers(windowState, runtime2) {
     setSetting("sidebarWidth", windowState.uiState.sidebarWidth);
     layoutViews(windowState);
   });
+  electron.ipcMain.on(
+    Channels.RENDERER_VIEW_READY,
+    (_event, view) => {
+      if (view !== "sidebar") return;
+      if (!windowState.uiState.sidebarOpen) {
+        windowState.uiState.sidebarOpen = true;
+        layoutViews(windowState);
+      }
+    }
+  );
   electron.ipcMain.handle(Channels.FOCUS_MODE_TOGGLE, () => {
     windowState.uiState.focusMode = !windowState.uiState.focusMode;
     layoutViews(windowState);
@@ -24750,6 +24770,7 @@ async function bootstrap() {
     windowState.mainWindow.show();
     closeSplash(splash, 0);
   };
+  let didInitializeChromeRenderer = false;
   const splashTimeout = setTimeout(() => {
     console.warn("[bootstrap] Renderer did not finish loading before splash timeout");
     revealMainWindow();
@@ -24776,8 +24797,9 @@ async function bootstrap() {
   installDownloadHandler(chromeView);
   startBackgroundRevalidation();
   startTelemetry();
-  loadRenderers(chromeView, sidebarView, devtoolsPanelView);
-  chromeView.webContents.once("did-finish-load", () => {
+  const initializeChromeRenderer = () => {
+    if (didInitializeChromeRenderer) return;
+    didInitializeChromeRenderer = true;
     const savedSession = runtime.getState().session;
     if (settings2.autoRestoreSession && savedSession?.tabs.length) {
       runtime.restoreSession(savedSession);
@@ -24790,6 +24812,12 @@ async function bootstrap() {
     clearTimeout(splashTimeout);
     revealMainWindow();
     void maybeShowStartupHealthDialog(windowState);
+  };
+  chromeView.webContents.once("dom-ready", () => {
+    initializeChromeRenderer();
+  });
+  chromeView.webContents.once("did-finish-load", () => {
+    initializeChromeRenderer();
   });
   chromeView.webContents.once(
     "did-fail-load",
@@ -24805,6 +24833,7 @@ async function bootstrap() {
       revealMainWindow();
     }
   );
+  loadRenderers(chromeView, sidebarView, devtoolsPanelView);
   startMcpServer(tabManager, runtime, settings2.mcpPort).catch((err) => {
     console.error("[bootstrap] MCP server failed to start:", err);
   });

package/out/preload/content-script.js

@@ -1,6 +1,5 @@
 "use strict";
 const electron = require("electron");
-const channels = require("./chunks/channels-Dfv8z3Ui.js");
 var Readability = { exports: {} };
 var hasRequiredReadability$1;
 function requireReadability$1() {
@@ -2187,11 +2186,11 @@ function emitPageDiffDirty() {
   const nextSignature = getPageDiffSignature();
   if (!nextSignature || nextSignature === lastPageDiffSignature) return;
   lastPageDiffSignature = nextSignature;
-  electron.ipcRenderer.send(channels.Channels.PAGE_DIFF_DIRTY);
+  electron.ipcRenderer.send("page:diff-dirty");
 }
 function notifyPageDiffActivity() {
   if (pageDiffActivityThrottleTimer) return;
-  electron.ipcRenderer.send(channels.Channels.PAGE_DIFF_ACTIVITY);
+  electron.ipcRenderer.send("page:diff-activity");
   pageDiffActivityThrottleTimer = setTimeout(() => {
     pageDiffActivityThrottleTimer = null;
   }, PAGE_DIFF_ACTIVITY_THROTTLE_MS);

package/out/preload/index.js

@@ -1,241 +1,362 @@
 "use strict";
 const electron = require("electron");
-const channels = require("./chunks/channels-Dfv8z3Ui.js");
+const Channels = {
+  // Tab management
+  TAB_CREATE: "tab:create",
+  TAB_CLOSE: "tab:close",
+  TAB_SWITCH: "tab:switch",
+  TAB_NAVIGATE: "tab:navigate",
+  TAB_BACK: "tab:back",
+  TAB_FORWARD: "tab:forward",
+  TAB_RELOAD: "tab:reload",
+  TAB_STATE_GET: "tab:state-get",
+  TAB_STATE_UPDATE: "tab:state-update",
+  RENDERER_VIEW_READY: "renderer:view-ready",
+  // AI
+  AI_QUERY: "ai:query",
+  AI_STREAM_START: "ai:stream-start",
+  AI_STREAM_CHUNK: "ai:stream-chunk",
+  AI_STREAM_END: "ai:stream-end",
+  AI_STREAM_IDLE: "ai:stream-idle",
+  AUTOMATION_ACTIVITY_START: "automation:activity-start",
+  AUTOMATION_ACTIVITY_CHUNK: "automation:activity-chunk",
+  AUTOMATION_ACTIVITY_END: "automation:activity-end",
+  AI_CANCEL: "ai:cancel",
+  AI_FETCH_MODELS: "ai:fetch-models",
+  AGENT_RUNTIME_GET: "agent-runtime:get",
+  AGENT_RUNTIME_UPDATE: "agent-runtime:update",
+  AGENT_PAUSE: "agent:pause",
+  AGENT_RESUME: "agent:resume",
+  AGENT_SET_APPROVAL_MODE: "agent:set-approval-mode",
+  AGENT_APPROVAL_RESOLVE: "agent:approval-resolve",
+  AGENT_CHECKPOINT_CREATE: "agent:checkpoint-create",
+  AGENT_CHECKPOINT_RESTORE: "agent:checkpoint-restore",
+  AGENT_SESSION_CAPTURE: "agent:session-capture",
+  AGENT_SESSION_RESTORE: "agent:session-restore",
+  // Content
+  CONTENT_EXTRACT: "content:extract",
+  READER_MODE_TOGGLE: "reader:toggle",
+  // UI state
+  SIDEBAR_TOGGLE: "ui:sidebar-toggle",
+  SIDEBAR_RESIZE: "ui:sidebar-resize",
+  SIDEBAR_RESIZE_START: "ui:sidebar-resize-start",
+  SIDEBAR_RESIZE_COMMIT: "ui:sidebar-resize-commit",
+  SIDEBAR_CONTEXT_MENU: "ui:sidebar-context-menu",
+  FOCUS_MODE_TOGGLE: "ui:focus-mode-toggle",
+  SETTINGS_VISIBILITY: "ui:settings-visibility",
+  // Settings
+  SETTINGS_GET: "settings:get",
+  SETTINGS_SET: "settings:set",
+  SETTINGS_UPDATE: "settings:update",
+  SETTINGS_HEALTH_GET: "settings:health:get",
+  SETTINGS_HEALTH_UPDATE: "settings:health:update",
+  // Bookmarks
+  BOOKMARKS_GET: "bookmarks:get",
+  BOOKMARKS_UPDATE: "bookmarks:update",
+  BOOKMARK_SAVE: "bookmarks:save",
+  BOOKMARK_REMOVE: "bookmarks:remove",
+  BOOKMARK_ADD_CONTEXT_TO_CHAT: "bookmarks:add-context-to-chat",
+  FOLDER_CREATE: "bookmarks:folder-create",
+  FOLDER_REMOVE: "bookmarks:folder-remove",
+  FOLDER_RENAME: "bookmarks:folder-rename",
+  // Highlights
+  HIGHLIGHT_CAPTURE: "highlights:capture",
+  HIGHLIGHT_CAPTURE_RESULT: "highlights:capture-result",
+  HIGHLIGHT_NAV_COUNT: "highlights:nav-count",
+  HIGHLIGHT_COUNT_UPDATE: "highlights:count-update",
+  HIGHLIGHT_NAV_SCROLL: "highlights:nav-scroll",
+  HIGHLIGHT_NAV_REMOVE: "highlights:nav-remove",
+  HIGHLIGHT_NAV_CLEAR: "highlights:nav-clear",
+  SIDEBAR_HIGHLIGHT_ACTION: "highlights:sidebar-action",
+  // DevTools panel
+  DEVTOOLS_PANEL_TOGGLE: "devtools-panel:toggle",
+  DEVTOOLS_PANEL_STATE: "devtools-panel:state",
+  DEVTOOLS_PANEL_RESIZE: "devtools-panel:resize",
+  // Find in page
+  FIND_IN_PAGE_START: "find:start",
+  FIND_IN_PAGE_NEXT: "find:next",
+  FIND_IN_PAGE_STOP: "find:stop",
+  FIND_IN_PAGE_RESULT: "find:result",
+  // Browsing history
+  HISTORY_GET: "history:get",
+  HISTORY_SEARCH: "history:search",
+  HISTORY_CLEAR: "history:clear",
+  HISTORY_UPDATE: "history:update",
+  // Premium
+  PREMIUM_GET_STATE: "premium:get-state",
+  PREMIUM_ACTIVATION_START: "premium:activation-start",
+  PREMIUM_ACTIVATION_VERIFY: "premium:activation-verify",
+  PREMIUM_CHECKOUT: "premium:checkout",
+  PREMIUM_PORTAL: "premium:portal",
+  PREMIUM_RESET: "premium:reset",
+  PREMIUM_TRACK_CONTEXT: "premium:track-context",
+  PREMIUM_UPDATE: "premium:update",
+  // Agent Credential Vault
+  VAULT_LIST: "vault:list",
+  VAULT_ADD: "vault:add",
+  VAULT_UPDATE: "vault:update",
+  VAULT_REMOVE: "vault:remove",
+  VAULT_AUDIT_LOG: "vault:audit-log",
+  // Automation kits
+  AUTOMATION_GET_INSTALLED: "automation:get-installed",
+  AUTOMATION_INSTALL_FROM_FILE: "automation:install-from-file",
+  AUTOMATION_UNINSTALL: "automation:uninstall",
+  // Scheduled jobs
+  SCHEDULE_GET_ALL: "schedule:get-all",
+  SCHEDULE_CREATE: "schedule:create",
+  SCHEDULE_UPDATE: "schedule:update",
+  SCHEDULE_DELETE: "schedule:delete",
+  SCHEDULE_JOBS_UPDATE: "schedule:jobs-update",
+  // Window controls
+  WINDOW_MINIMIZE: "window:minimize",
+  WINDOW_MAXIMIZE: "window:maximize",
+  WINDOW_CLOSE: "window:close",
+  // Autofill
+  AUTOFILL_LIST: "autofill:list",
+  AUTOFILL_ADD: "autofill:add",
+  AUTOFILL_UPDATE: "autofill:update",
+  AUTOFILL_DELETE: "autofill:delete",
+  AUTOFILL_FILL: "autofill:fill",
+  PAGE_CHANGED: "page:changed",
+  PAGE_DIFF_GET: "page:diff-get"
+};
 const api = {
   tabs: {
-    create: (url) => electron.ipcRenderer.invoke(channels.Channels.TAB_CREATE, url),
-    close: (id) => electron.ipcRenderer.invoke(channels.Channels.TAB_CLOSE, id),
-    switch: (id) => electron.ipcRenderer.invoke(channels.Channels.TAB_SWITCH, id),
-    navigate: (id, url, postBody) => electron.ipcRenderer.invoke(channels.Channels.TAB_NAVIGATE, id, url, postBody),
-    back: (id) => electron.ipcRenderer.invoke(channels.Channels.TAB_BACK, id),
-    forward: (id) => electron.ipcRenderer.invoke(channels.Channels.TAB_FORWARD, id),
-    reload: (id) => electron.ipcRenderer.invoke(channels.Channels.TAB_RELOAD, id),
+    create: (url) => electron.ipcRenderer.invoke(Channels.TAB_CREATE, url),
+    close: (id) => electron.ipcRenderer.invoke(Channels.TAB_CLOSE, id),
+    switch: (id) => electron.ipcRenderer.invoke(Channels.TAB_SWITCH, id),
+    navigate: (id, url, postBody) => electron.ipcRenderer.invoke(Channels.TAB_NAVIGATE, id, url, postBody),
+    back: (id) => electron.ipcRenderer.invoke(Channels.TAB_BACK, id),
+    forward: (id) => electron.ipcRenderer.invoke(Channels.TAB_FORWARD, id),
+    reload: (id) => electron.ipcRenderer.invoke(Channels.TAB_RELOAD, id),
+    getState: () => electron.ipcRenderer.invoke(Channels.TAB_STATE_GET),
     onStateUpdate: (cb) => {
       const handler = (_, tabs, activeId) => cb(tabs, activeId);
-      electron.ipcRenderer.on(channels.Channels.TAB_STATE_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.TAB_STATE_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.TAB_STATE_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.TAB_STATE_UPDATE, handler);
     }
   },
   ai: {
-    query: (prompt, history) => electron.ipcRenderer.invoke(channels.Channels.AI_QUERY, prompt, history),
+    query: (prompt, history) => electron.ipcRenderer.invoke(Channels.AI_QUERY, prompt, history),
     onStreamStart: (cb) => {
       const handler = (_, prompt) => cb(prompt);
-      electron.ipcRenderer.on(channels.Channels.AI_STREAM_START, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AI_STREAM_START, handler);
+      electron.ipcRenderer.on(Channels.AI_STREAM_START, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_START, handler);
     },
     onStreamChunk: (cb) => {
       const handler = (_, chunk) => cb(chunk);
-      electron.ipcRenderer.on(channels.Channels.AI_STREAM_CHUNK, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AI_STREAM_CHUNK, handler);
+      electron.ipcRenderer.on(Channels.AI_STREAM_CHUNK, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_CHUNK, handler);
     },
     onStreamEnd: (cb) => {
       const handler = (_, status = "completed") => cb(status);
-      electron.ipcRenderer.on(channels.Channels.AI_STREAM_END, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AI_STREAM_END, handler);
+      electron.ipcRenderer.on(Channels.AI_STREAM_END, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_END, handler);
     },
     onStreamIdle: (cb) => {
       const handler = () => cb();
-      electron.ipcRenderer.on(channels.Channels.AI_STREAM_IDLE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AI_STREAM_IDLE, handler);
+      electron.ipcRenderer.on(Channels.AI_STREAM_IDLE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_IDLE, handler);
     },
     onAutomationActivityStart: (cb) => {
       const handler = (_, entry) => cb(entry);
-      electron.ipcRenderer.on(channels.Channels.AUTOMATION_ACTIVITY_START, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AUTOMATION_ACTIVITY_START, handler);
+      electron.ipcRenderer.on(Channels.AUTOMATION_ACTIVITY_START, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AUTOMATION_ACTIVITY_START, handler);
     },
     onAutomationActivityChunk: (cb) => {
       const handler = (_, payload) => cb(payload);
-      electron.ipcRenderer.on(channels.Channels.AUTOMATION_ACTIVITY_CHUNK, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AUTOMATION_ACTIVITY_CHUNK, handler);
+      electron.ipcRenderer.on(Channels.AUTOMATION_ACTIVITY_CHUNK, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AUTOMATION_ACTIVITY_CHUNK, handler);
     },
     onAutomationActivityEnd: (cb) => {
       const handler = (_, payload) => cb(payload);
-      electron.ipcRenderer.on(channels.Channels.AUTOMATION_ACTIVITY_END, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AUTOMATION_ACTIVITY_END, handler);
+      electron.ipcRenderer.on(Channels.AUTOMATION_ACTIVITY_END, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AUTOMATION_ACTIVITY_END, handler);
     },
-    cancel: () => electron.ipcRenderer.invoke(channels.Channels.AI_CANCEL),
-    fetchModels: (config) => electron.ipcRenderer.invoke(channels.Channels.AI_FETCH_MODELS, config),
-    getRuntime: () => electron.ipcRenderer.invoke(channels.Channels.AGENT_RUNTIME_GET),
+    cancel: () => electron.ipcRenderer.invoke(Channels.AI_CANCEL),
+    fetchModels: (config) => electron.ipcRenderer.invoke(Channels.AI_FETCH_MODELS, config),
+    getRuntime: () => electron.ipcRenderer.invoke(Channels.AGENT_RUNTIME_GET),
     onRuntimeUpdate: (cb) => {
       const handler = (_, state) => cb(state);
-      electron.ipcRenderer.on(channels.Channels.AGENT_RUNTIME_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.AGENT_RUNTIME_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.AGENT_RUNTIME_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AGENT_RUNTIME_UPDATE, handler);
     },
-    pause: () => electron.ipcRenderer.invoke(channels.Channels.AGENT_PAUSE),
-    resume: () => electron.ipcRenderer.invoke(channels.Channels.AGENT_RESUME),
-    setApprovalMode: (mode) => electron.ipcRenderer.invoke(channels.Channels.AGENT_SET_APPROVAL_MODE, mode),
-    resolveApproval: (approvalId, approved) => electron.ipcRenderer.invoke(channels.Channels.AGENT_APPROVAL_RESOLVE, approvalId, approved),
-    createCheckpoint: (name, note) => electron.ipcRenderer.invoke(channels.Channels.AGENT_CHECKPOINT_CREATE, name, note),
-    restoreCheckpoint: (checkpointId) => electron.ipcRenderer.invoke(channels.Channels.AGENT_CHECKPOINT_RESTORE, checkpointId),
-    captureSession: (note) => electron.ipcRenderer.invoke(channels.Channels.AGENT_SESSION_CAPTURE, note),
-    restoreSession: (snapshot) => electron.ipcRenderer.invoke(channels.Channels.AGENT_SESSION_RESTORE, snapshot)
+    pause: () => electron.ipcRenderer.invoke(Channels.AGENT_PAUSE),
+    resume: () => electron.ipcRenderer.invoke(Channels.AGENT_RESUME),
+    setApprovalMode: (mode) => electron.ipcRenderer.invoke(Channels.AGENT_SET_APPROVAL_MODE, mode),
+    resolveApproval: (approvalId, approved) => electron.ipcRenderer.invoke(Channels.AGENT_APPROVAL_RESOLVE, approvalId, approved),
+    createCheckpoint: (name, note) => electron.ipcRenderer.invoke(Channels.AGENT_CHECKPOINT_CREATE, name, note),
+    restoreCheckpoint: (checkpointId) => electron.ipcRenderer.invoke(Channels.AGENT_CHECKPOINT_RESTORE, checkpointId),
+    captureSession: (note) => electron.ipcRenderer.invoke(Channels.AGENT_SESSION_CAPTURE, note),
+    restoreSession: (snapshot) => electron.ipcRenderer.invoke(Channels.AGENT_SESSION_RESTORE, snapshot)
   },
   content: {
-    extract: () => electron.ipcRenderer.invoke(channels.Channels.CONTENT_EXTRACT),
-    toggleReader: () => electron.ipcRenderer.invoke(channels.Channels.READER_MODE_TOGGLE)
+    extract: () => electron.ipcRenderer.invoke(Channels.CONTENT_EXTRACT),
+    toggleReader: () => electron.ipcRenderer.invoke(Channels.READER_MODE_TOGGLE)
   },
   highlights: {
-    capture: () => electron.ipcRenderer.invoke(channels.Channels.HIGHLIGHT_CAPTURE),
+    capture: () => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_CAPTURE),
     onCaptureResult: (cb) => {
       const handler = (_, result) => cb(result);
-      electron.ipcRenderer.on(channels.Channels.HIGHLIGHT_CAPTURE_RESULT, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.HIGHLIGHT_CAPTURE_RESULT, handler);
+      electron.ipcRenderer.on(Channels.HIGHLIGHT_CAPTURE_RESULT, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.HIGHLIGHT_CAPTURE_RESULT, handler);
     },
-    getCount: () => electron.ipcRenderer.invoke(channels.Channels.HIGHLIGHT_NAV_COUNT),
+    getCount: () => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_NAV_COUNT),
     onCountUpdate: (cb) => {
       const handler = (_, count) => cb(count);
-      electron.ipcRenderer.on(channels.Channels.HIGHLIGHT_COUNT_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.HIGHLIGHT_COUNT_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.HIGHLIGHT_COUNT_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.HIGHLIGHT_COUNT_UPDATE, handler);
     },
-    scrollTo: (index) => electron.ipcRenderer.invoke(channels.Channels.HIGHLIGHT_NAV_SCROLL, index),
-    remove: (index) => electron.ipcRenderer.invoke(channels.Channels.HIGHLIGHT_NAV_REMOVE, index),
-    clearAll: () => electron.ipcRenderer.invoke(channels.Channels.HIGHLIGHT_NAV_CLEAR),
+    scrollTo: (index) => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_NAV_SCROLL, index),
+    remove: (index) => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_NAV_REMOVE, index),
+    clearAll: () => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_NAV_CLEAR),
     onSidebarAction: (cb) => {
       const handler = (_, action) => cb(action);
-      electron.ipcRenderer.on(channels.Channels.SIDEBAR_HIGHLIGHT_ACTION, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.SIDEBAR_HIGHLIGHT_ACTION, handler);
+      electron.ipcRenderer.on(Channels.SIDEBAR_HIGHLIGHT_ACTION, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SIDEBAR_HIGHLIGHT_ACTION, handler);
     }
   },
   ui: {
-    toggleSidebar: () => electron.ipcRenderer.invoke(channels.Channels.SIDEBAR_TOGGLE),
-    startSidebarResize: () => electron.ipcRenderer.invoke(channels.Channels.SIDEBAR_RESIZE_START),
-    resizeSidebar: (width) => electron.ipcRenderer.invoke(channels.Channels.SIDEBAR_RESIZE, width),
-    commitSidebarResize: () => electron.ipcRenderer.invoke(channels.Channels.SIDEBAR_RESIZE_COMMIT),
+    toggleSidebar: () => electron.ipcRenderer.invoke(Channels.SIDEBAR_TOGGLE),
+    startSidebarResize: () => electron.ipcRenderer.invoke(Channels.SIDEBAR_RESIZE_START),
+    resizeSidebar: (width) => electron.ipcRenderer.invoke(Channels.SIDEBAR_RESIZE, width),
+    commitSidebarResize: () => electron.ipcRenderer.invoke(Channels.SIDEBAR_RESIZE_COMMIT),
+    rendererReady: (view) => electron.ipcRenderer.send(Channels.RENDERER_VIEW_READY, view),
     onSidebarContextMenu: (cb) => {
       const handler = (_, position) => cb(position);
-      electron.ipcRenderer.on(channels.Channels.SIDEBAR_CONTEXT_MENU, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.SIDEBAR_CONTEXT_MENU, handler);
+      electron.ipcRenderer.on(Channels.SIDEBAR_CONTEXT_MENU, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SIDEBAR_CONTEXT_MENU, handler);
     },
-    toggleFocusMode: () => electron.ipcRenderer.invoke(channels.Channels.FOCUS_MODE_TOGGLE),
-    setSettingsVisibility: (open) => electron.ipcRenderer.invoke(channels.Channels.SETTINGS_VISIBILITY, open)
+    toggleFocusMode: () => electron.ipcRenderer.invoke(Channels.FOCUS_MODE_TOGGLE),
+    setSettingsVisibility: (open) => electron.ipcRenderer.invoke(Channels.SETTINGS_VISIBILITY, open)
   },
   settings: {
-    get: () => electron.ipcRenderer.invoke(channels.Channels.SETTINGS_GET),
-    getHealth: () => electron.ipcRenderer.invoke(channels.Channels.SETTINGS_HEALTH_GET),
+    get: () => electron.ipcRenderer.invoke(Channels.SETTINGS_GET),
+    getHealth: () => electron.ipcRenderer.invoke(Channels.SETTINGS_HEALTH_GET),
     onHealthUpdate: (cb) => {
       const handler = (_, health) => cb(health);
-      electron.ipcRenderer.on(channels.Channels.SETTINGS_HEALTH_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.SETTINGS_HEALTH_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.SETTINGS_HEALTH_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SETTINGS_HEALTH_UPDATE, handler);
     },
-    set: (key, value) => electron.ipcRenderer.invoke(channels.Channels.SETTINGS_SET, key, value),
+    set: (key, value) => electron.ipcRenderer.invoke(Channels.SETTINGS_SET, key, value),
     onUpdate: (cb) => {
       const handler = (_, settings) => cb(settings);
-      electron.ipcRenderer.on(channels.Channels.SETTINGS_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.SETTINGS_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.SETTINGS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SETTINGS_UPDATE, handler);
     }
   },
   bookmarks: {
-    get: () => electron.ipcRenderer.invoke(channels.Channels.BOOKMARKS_GET),
-    saveBookmark: (url, title, folderId, note) => electron.ipcRenderer.invoke(channels.Channels.BOOKMARK_SAVE, url, title, folderId, note),
-    removeBookmark: (id) => electron.ipcRenderer.invoke(channels.Channels.BOOKMARK_REMOVE, id),
-    createFolder: (name) => electron.ipcRenderer.invoke(channels.Channels.FOLDER_CREATE, name),
-    createFolderWithSummary: (name, summary) => electron.ipcRenderer.invoke(channels.Channels.FOLDER_CREATE, name, summary),
-    removeFolder: (id, deleteContents) => electron.ipcRenderer.invoke(channels.Channels.FOLDER_REMOVE, id, deleteContents),
-    renameFolder: (id, newName, summary) => electron.ipcRenderer.invoke(channels.Channels.FOLDER_RENAME, id, newName, summary),
+    get: () => electron.ipcRenderer.invoke(Channels.BOOKMARKS_GET),
+    saveBookmark: (url, title, folderId, note) => electron.ipcRenderer.invoke(Channels.BOOKMARK_SAVE, url, title, folderId, note),
+    removeBookmark: (id) => electron.ipcRenderer.invoke(Channels.BOOKMARK_REMOVE, id),
+    createFolder: (name) => electron.ipcRenderer.invoke(Channels.FOLDER_CREATE, name),
+    createFolderWithSummary: (name, summary) => electron.ipcRenderer.invoke(Channels.FOLDER_CREATE, name, summary),
+    removeFolder: (id, deleteContents) => electron.ipcRenderer.invoke(Channels.FOLDER_REMOVE, id, deleteContents),
+    renameFolder: (id, newName, summary) => electron.ipcRenderer.invoke(Channels.FOLDER_RENAME, id, newName, summary),
     onAddContextToChat: (cb) => {
       const handler = (_, bookmarkId) => cb(bookmarkId);
-      electron.ipcRenderer.on(channels.Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT, handler);
+      electron.ipcRenderer.on(Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT, handler);
       return () => electron.ipcRenderer.removeListener(
-        channels.Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT,
+        Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT,
         handler
       );
     },
     onUpdate: (cb) => {
       const handler = (_, state) => cb(state);
-      electron.ipcRenderer.on(channels.Channels.BOOKMARKS_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.BOOKMARKS_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.BOOKMARKS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.BOOKMARKS_UPDATE, handler);
     }
   },
   devtoolsPanel: {
-    toggle: () => electron.ipcRenderer.invoke(channels.Channels.DEVTOOLS_PANEL_TOGGLE),
-    resize: (height) => electron.ipcRenderer.invoke(channels.Channels.DEVTOOLS_PANEL_RESIZE, height),
+    toggle: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_TOGGLE),
+    resize: (height) => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_RESIZE, height),
     onStateUpdate: (cb) => {
       const handler = (_, state) => cb(state);
-      electron.ipcRenderer.on(channels.Channels.DEVTOOLS_PANEL_STATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.DEVTOOLS_PANEL_STATE, handler);
+      electron.ipcRenderer.on(Channels.DEVTOOLS_PANEL_STATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DEVTOOLS_PANEL_STATE, handler);
     }
   },
   find: {
-    start: (text, options) => electron.ipcRenderer.invoke(channels.Channels.FIND_IN_PAGE_START, text, options),
-    next: (forward) => electron.ipcRenderer.invoke(channels.Channels.FIND_IN_PAGE_NEXT, forward),
-    stop: (action) => electron.ipcRenderer.invoke(channels.Channels.FIND_IN_PAGE_STOP, action),
+    start: (text, options) => electron.ipcRenderer.invoke(Channels.FIND_IN_PAGE_START, text, options),
+    next: (forward) => electron.ipcRenderer.invoke(Channels.FIND_IN_PAGE_NEXT, forward),
+    stop: (action) => electron.ipcRenderer.invoke(Channels.FIND_IN_PAGE_STOP, action),
     onResult: (cb) => {
       const handler = (_, result) => cb(result);
-      electron.ipcRenderer.on(channels.Channels.FIND_IN_PAGE_RESULT, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.FIND_IN_PAGE_RESULT, handler);
+      electron.ipcRenderer.on(Channels.FIND_IN_PAGE_RESULT, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.FIND_IN_PAGE_RESULT, handler);
     }
   },
   history: {
-    get: () => electron.ipcRenderer.invoke(channels.Channels.HISTORY_GET),
-    search: (query) => electron.ipcRenderer.invoke(channels.Channels.HISTORY_SEARCH, query),
-    clear: () => electron.ipcRenderer.invoke(channels.Channels.HISTORY_CLEAR),
+    get: () => electron.ipcRenderer.invoke(Channels.HISTORY_GET),
+    search: (query) => electron.ipcRenderer.invoke(Channels.HISTORY_SEARCH, query),
+    clear: () => electron.ipcRenderer.invoke(Channels.HISTORY_CLEAR),
     onUpdate: (cb) => {
       const handler = (_, state) => cb(state);
-      electron.ipcRenderer.on(channels.Channels.HISTORY_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.HISTORY_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.HISTORY_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.HISTORY_UPDATE, handler);
     }
   },
   premium: {
-    getState: () => electron.ipcRenderer.invoke(channels.Channels.PREMIUM_GET_STATE),
-    requestCode: (email) => electron.ipcRenderer.invoke(channels.Channels.PREMIUM_ACTIVATION_START, email),
+    getState: () => electron.ipcRenderer.invoke(Channels.PREMIUM_GET_STATE),
+    requestCode: (email) => electron.ipcRenderer.invoke(Channels.PREMIUM_ACTIVATION_START, email),
     verifyCode: (email, code, challengeToken) => electron.ipcRenderer.invoke(
-      channels.Channels.PREMIUM_ACTIVATION_VERIFY,
+      Channels.PREMIUM_ACTIVATION_VERIFY,
       email,
       code,
       challengeToken
     ),
-    checkout: (email) => electron.ipcRenderer.invoke(channels.Channels.PREMIUM_CHECKOUT, email),
-    portal: () => electron.ipcRenderer.invoke(channels.Channels.PREMIUM_PORTAL),
-    reset: () => electron.ipcRenderer.invoke(channels.Channels.PREMIUM_RESET),
-    trackContext: (step) => electron.ipcRenderer.invoke(channels.Channels.PREMIUM_TRACK_CONTEXT, step),
+    checkout: (email) => electron.ipcRenderer.invoke(Channels.PREMIUM_CHECKOUT, email),
+    portal: () => electron.ipcRenderer.invoke(Channels.PREMIUM_PORTAL),
+    reset: () => electron.ipcRenderer.invoke(Channels.PREMIUM_RESET),
+    trackContext: (step) => electron.ipcRenderer.invoke(Channels.PREMIUM_TRACK_CONTEXT, step),
     onUpdate: (cb) => {
       const handler = (_, state) => cb(state);
-      electron.ipcRenderer.on(channels.Channels.PREMIUM_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.PREMIUM_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.PREMIUM_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.PREMIUM_UPDATE, handler);
     }
   },
   vault: {
-    list: () => electron.ipcRenderer.invoke(channels.Channels.VAULT_LIST),
-    add: (entry) => electron.ipcRenderer.invoke(channels.Channels.VAULT_ADD, entry),
-    update: (id, updates) => electron.ipcRenderer.invoke(channels.Channels.VAULT_UPDATE, id, updates),
-    remove: (id) => electron.ipcRenderer.invoke(channels.Channels.VAULT_REMOVE, id),
-    auditLog: (limit) => electron.ipcRenderer.invoke(channels.Channels.VAULT_AUDIT_LOG, limit)
+    list: () => electron.ipcRenderer.invoke(Channels.VAULT_LIST),
+    add: (entry) => electron.ipcRenderer.invoke(Channels.VAULT_ADD, entry),
+    update: (id, updates) => electron.ipcRenderer.invoke(Channels.VAULT_UPDATE, id, updates),
+    remove: (id) => electron.ipcRenderer.invoke(Channels.VAULT_REMOVE, id),
+    auditLog: (limit) => electron.ipcRenderer.invoke(Channels.VAULT_AUDIT_LOG, limit)
   },
   automation: {
-    getInstalled: () => electron.ipcRenderer.invoke(channels.Channels.AUTOMATION_GET_INSTALLED),
-    installFromFile: () => electron.ipcRenderer.invoke(channels.Channels.AUTOMATION_INSTALL_FROM_FILE),
-    uninstall: (id) => electron.ipcRenderer.invoke(channels.Channels.AUTOMATION_UNINSTALL, id)
+    getInstalled: () => electron.ipcRenderer.invoke(Channels.AUTOMATION_GET_INSTALLED),
+    installFromFile: () => electron.ipcRenderer.invoke(Channels.AUTOMATION_INSTALL_FROM_FILE),
+    uninstall: (id) => electron.ipcRenderer.invoke(Channels.AUTOMATION_UNINSTALL, id)
   },
   schedule: {
-    getAll: () => electron.ipcRenderer.invoke(channels.Channels.SCHEDULE_GET_ALL),
-    create: (job) => electron.ipcRenderer.invoke(channels.Channels.SCHEDULE_CREATE, job),
-    update: (id, updates) => electron.ipcRenderer.invoke(channels.Channels.SCHEDULE_UPDATE, id, updates),
-    delete: (id) => electron.ipcRenderer.invoke(channels.Channels.SCHEDULE_DELETE, id),
+    getAll: () => electron.ipcRenderer.invoke(Channels.SCHEDULE_GET_ALL),
+    create: (job) => electron.ipcRenderer.invoke(Channels.SCHEDULE_CREATE, job),
+    update: (id, updates) => electron.ipcRenderer.invoke(Channels.SCHEDULE_UPDATE, id, updates),
+    delete: (id) => electron.ipcRenderer.invoke(Channels.SCHEDULE_DELETE, id),
     onJobsUpdate: (cb) => {
       const handler = (_, updatedJobs) => cb(updatedJobs);
-      electron.ipcRenderer.on(channels.Channels.SCHEDULE_JOBS_UPDATE, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.SCHEDULE_JOBS_UPDATE, handler);
+      electron.ipcRenderer.on(Channels.SCHEDULE_JOBS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SCHEDULE_JOBS_UPDATE, handler);
     }
   },
   window: {
-    minimize: () => electron.ipcRenderer.invoke(channels.Channels.WINDOW_MINIMIZE),
-    maximize: () => electron.ipcRenderer.invoke(channels.Channels.WINDOW_MAXIMIZE),
-    close: () => electron.ipcRenderer.invoke(channels.Channels.WINDOW_CLOSE)
+    minimize: () => electron.ipcRenderer.invoke(Channels.WINDOW_MINIMIZE),
+    maximize: () => electron.ipcRenderer.invoke(Channels.WINDOW_MAXIMIZE),
+    close: () => electron.ipcRenderer.invoke(Channels.WINDOW_CLOSE)
   },
   autofill: {
-    list: () => electron.ipcRenderer.invoke(channels.Channels.AUTOFILL_LIST),
-    add: (profile) => electron.ipcRenderer.invoke(channels.Channels.AUTOFILL_ADD, profile),
-    update: (id, updates) => electron.ipcRenderer.invoke(channels.Channels.AUTOFILL_UPDATE, id, updates),
-    delete: (id) => electron.ipcRenderer.invoke(channels.Channels.AUTOFILL_DELETE, id),
-    fill: (profileId) => electron.ipcRenderer.invoke(channels.Channels.AUTOFILL_FILL, profileId)
+    list: () => electron.ipcRenderer.invoke(Channels.AUTOFILL_LIST),
+    add: (profile) => electron.ipcRenderer.invoke(Channels.AUTOFILL_ADD, profile),
+    update: (id, updates) => electron.ipcRenderer.invoke(Channels.AUTOFILL_UPDATE, id, updates),
+    delete: (id) => electron.ipcRenderer.invoke(Channels.AUTOFILL_DELETE, id),
+    fill: (profileId) => electron.ipcRenderer.invoke(Channels.AUTOFILL_FILL, profileId)
   },
   pageDiff: {
     onChanged: (cb) => {
       const handler = (_, diff) => cb(diff);
-      electron.ipcRenderer.on(channels.Channels.PAGE_CHANGED, handler);
-      return () => electron.ipcRenderer.removeListener(channels.Channels.PAGE_CHANGED, handler);
+      electron.ipcRenderer.on(Channels.PAGE_CHANGED, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.PAGE_CHANGED, handler);
     },
-    get: () => electron.ipcRenderer.invoke(channels.Channels.PAGE_DIFF_GET)
+    get: () => electron.ipcRenderer.invoke(Channels.PAGE_DIFF_GET)
   }
 };
 electron.contextBridge.exposeInMainWorld("vessel", api);

package/out/renderer/assets/{index-DRj77a_O.css → index-Bn4ixapT.css}

@@ -1511,7 +1511,7 @@
 
 .sidebar-tab {
     position: relative;
-    padding: 9px 12px 10px;
+    padding: 9px 8px 10px;
     font-size: 11.5px;
     white-space: nowrap;
     flex-shrink: 0;
@@ -4767,6 +4767,7 @@ button:active:not(:disabled) {
 
 .chrome {
     position: relative;
+    -webkit-app-region: no-drag;
 }
 
 .loading-bar {

package/out/renderer/assets/{index-DRVDsSQe.js → index-DGIC7Iij.js}

@@ -1489,15 +1489,30 @@ delegateEvents(["click"]);
 const [tabs, setTabs] = createSignal([]);
 const [activeTabId, setActiveTabId] = createSignal("");
 let initialized$3 = false;
+let initPromise$2 = null;
 function init$3() {
+  if (initPromise$2) return initPromise$2;
   if (initialized$3) return;
   initialized$3 = true;
-  window.vessel.tabs.onStateUpdate(
-    (newTabs, newActiveId) => {
-      setTabs(newTabs);
-      setActiveTabId(newActiveId);
+  initPromise$2 = (async () => {
+    try {
+      window.vessel.tabs.onStateUpdate(
+        (newTabs, newActiveId) => {
+          setTabs(newTabs);
+          setActiveTabId(newActiveId);
+        }
+      );
+      const initialState = await window.vessel.tabs.getState();
+      setTabs(initialState.tabs);
+      setActiveTabId(initialState.activeId);
+    } catch (error) {
+      initialized$3 = false;
+      console.error("Failed to initialize tabs store", error);
+    } finally {
+      initPromise$2 = null;
     }
-  );
+  })();
+  return initPromise$2;
 }
 function useTabs() {
   init$3();
@@ -9447,6 +9462,7 @@ const App = () => {
     }
   };
   onMount(() => {
+    window.vessel.ui.rendererReady(view);
     if (view !== "chrome") return;
     const cleanupKeys = setupKeybindings({
       openCommandBar,

package/out/renderer/index.html

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; font-src 'self' data:;" />
     <title>Vessel</title>
-    <script type="module" crossorigin src="./assets/index-DRVDsSQe.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-DRj77a_O.css">
+    <script type="module" crossorigin src="./assets/index-DGIC7Iij.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-Bn4ixapT.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quanta-intellect/vessel-browser",
   "mcpName": "io.github.unmodeled-tyler/vessel-browser",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "AI-native web browser runtime for autonomous agents with human supervision",
   "main": "./out/main/index.js",
   "bin": {

package/out/preload/chunks/channels-Dfv8z3Ui.js

@@ -1,123 +0,0 @@
-"use strict";
-const Channels = {
-  // Tab management
-  TAB_CREATE: "tab:create",
-  TAB_CLOSE: "tab:close",
-  TAB_SWITCH: "tab:switch",
-  TAB_NAVIGATE: "tab:navigate",
-  TAB_BACK: "tab:back",
-  TAB_FORWARD: "tab:forward",
-  TAB_RELOAD: "tab:reload",
-  TAB_STATE_UPDATE: "tab:state-update",
-  // AI
-  AI_QUERY: "ai:query",
-  AI_STREAM_START: "ai:stream-start",
-  AI_STREAM_CHUNK: "ai:stream-chunk",
-  AI_STREAM_END: "ai:stream-end",
-  AI_STREAM_IDLE: "ai:stream-idle",
-  AUTOMATION_ACTIVITY_START: "automation:activity-start",
-  AUTOMATION_ACTIVITY_CHUNK: "automation:activity-chunk",
-  AUTOMATION_ACTIVITY_END: "automation:activity-end",
-  AI_CANCEL: "ai:cancel",
-  AI_FETCH_MODELS: "ai:fetch-models",
-  AGENT_RUNTIME_GET: "agent-runtime:get",
-  AGENT_RUNTIME_UPDATE: "agent-runtime:update",
-  AGENT_PAUSE: "agent:pause",
-  AGENT_RESUME: "agent:resume",
-  AGENT_SET_APPROVAL_MODE: "agent:set-approval-mode",
-  AGENT_APPROVAL_RESOLVE: "agent:approval-resolve",
-  AGENT_CHECKPOINT_CREATE: "agent:checkpoint-create",
-  AGENT_CHECKPOINT_RESTORE: "agent:checkpoint-restore",
-  AGENT_SESSION_CAPTURE: "agent:session-capture",
-  AGENT_SESSION_RESTORE: "agent:session-restore",
-  // Content
-  CONTENT_EXTRACT: "content:extract",
-  READER_MODE_TOGGLE: "reader:toggle",
-  // UI state
-  SIDEBAR_TOGGLE: "ui:sidebar-toggle",
-  SIDEBAR_RESIZE: "ui:sidebar-resize",
-  SIDEBAR_RESIZE_START: "ui:sidebar-resize-start",
-  SIDEBAR_RESIZE_COMMIT: "ui:sidebar-resize-commit",
-  SIDEBAR_CONTEXT_MENU: "ui:sidebar-context-menu",
-  FOCUS_MODE_TOGGLE: "ui:focus-mode-toggle",
-  SETTINGS_VISIBILITY: "ui:settings-visibility",
-  // Settings
-  SETTINGS_GET: "settings:get",
-  SETTINGS_SET: "settings:set",
-  SETTINGS_UPDATE: "settings:update",
-  SETTINGS_HEALTH_GET: "settings:health:get",
-  SETTINGS_HEALTH_UPDATE: "settings:health:update",
-  // Bookmarks
-  BOOKMARKS_GET: "bookmarks:get",
-  BOOKMARKS_UPDATE: "bookmarks:update",
-  BOOKMARK_SAVE: "bookmarks:save",
-  BOOKMARK_REMOVE: "bookmarks:remove",
-  BOOKMARK_ADD_CONTEXT_TO_CHAT: "bookmarks:add-context-to-chat",
-  FOLDER_CREATE: "bookmarks:folder-create",
-  FOLDER_REMOVE: "bookmarks:folder-remove",
-  FOLDER_RENAME: "bookmarks:folder-rename",
-  // Highlights
-  HIGHLIGHT_CAPTURE: "highlights:capture",
-  HIGHLIGHT_CAPTURE_RESULT: "highlights:capture-result",
-  HIGHLIGHT_NAV_COUNT: "highlights:nav-count",
-  HIGHLIGHT_COUNT_UPDATE: "highlights:count-update",
-  HIGHLIGHT_NAV_SCROLL: "highlights:nav-scroll",
-  HIGHLIGHT_NAV_REMOVE: "highlights:nav-remove",
-  HIGHLIGHT_NAV_CLEAR: "highlights:nav-clear",
-  SIDEBAR_HIGHLIGHT_ACTION: "highlights:sidebar-action",
-  // DevTools panel
-  DEVTOOLS_PANEL_TOGGLE: "devtools-panel:toggle",
-  DEVTOOLS_PANEL_STATE: "devtools-panel:state",
-  DEVTOOLS_PANEL_RESIZE: "devtools-panel:resize",
-  // Find in page
-  FIND_IN_PAGE_START: "find:start",
-  FIND_IN_PAGE_NEXT: "find:next",
-  FIND_IN_PAGE_STOP: "find:stop",
-  FIND_IN_PAGE_RESULT: "find:result",
-  // Browsing history
-  HISTORY_GET: "history:get",
-  HISTORY_SEARCH: "history:search",
-  HISTORY_CLEAR: "history:clear",
-  HISTORY_UPDATE: "history:update",
-  // Premium
-  PREMIUM_GET_STATE: "premium:get-state",
-  PREMIUM_ACTIVATION_START: "premium:activation-start",
-  PREMIUM_ACTIVATION_VERIFY: "premium:activation-verify",
-  PREMIUM_CHECKOUT: "premium:checkout",
-  PREMIUM_PORTAL: "premium:portal",
-  PREMIUM_RESET: "premium:reset",
-  PREMIUM_TRACK_CONTEXT: "premium:track-context",
-  PREMIUM_UPDATE: "premium:update",
-  // Agent Credential Vault
-  VAULT_LIST: "vault:list",
-  VAULT_ADD: "vault:add",
-  VAULT_UPDATE: "vault:update",
-  VAULT_REMOVE: "vault:remove",
-  VAULT_AUDIT_LOG: "vault:audit-log",
-  // Automation kits
-  AUTOMATION_GET_INSTALLED: "automation:get-installed",
-  AUTOMATION_INSTALL_FROM_FILE: "automation:install-from-file",
-  AUTOMATION_UNINSTALL: "automation:uninstall",
-  // Scheduled jobs
-  SCHEDULE_GET_ALL: "schedule:get-all",
-  SCHEDULE_CREATE: "schedule:create",
-  SCHEDULE_UPDATE: "schedule:update",
-  SCHEDULE_DELETE: "schedule:delete",
-  SCHEDULE_JOBS_UPDATE: "schedule:jobs-update",
-  // Window controls
-  WINDOW_MINIMIZE: "window:minimize",
-  WINDOW_MAXIMIZE: "window:maximize",
-  WINDOW_CLOSE: "window:close",
-  // Autofill
-  AUTOFILL_LIST: "autofill:list",
-  AUTOFILL_ADD: "autofill:add",
-  AUTOFILL_UPDATE: "autofill:update",
-  AUTOFILL_DELETE: "autofill:delete",
-  AUTOFILL_FILL: "autofill:fill",
-  // Page snapshots / What Changed
-  PAGE_DIFF_ACTIVITY: "page:diff-activity",
-  PAGE_CHANGED: "page:changed",
-  PAGE_DIFF_GET: "page:diff-get",
-  PAGE_DIFF_DIRTY: "page:diff-dirty"
-};
-exports.Channels = Channels;