@mseep/vessel-browser 0.1.0

package/out/preload/index.js

@@ -0,0 +1,737 @@
+"use strict";
+const electron = require("electron");
+const AIChannels = {
+  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",
+  AI_RESEARCH_CLARIFICATION: "ai:research-clarification",
+  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_CHECKPOINT_UPDATE_NOTE: "agent:checkpoint-update-note",
+  AGENT_UNDO_LAST_ACTION: "agent:undo-last-action",
+  AGENT_SESSION_CAPTURE: "agent:session-capture",
+  AGENT_SESSION_RESTORE: "agent:session-restore",
+  AGENT_TASK_START: "agent:task-start",
+  AGENT_TASK_UPDATE: "agent:task-update",
+  AGENT_TASK_NOTE: "agent:task-note",
+  AGENT_TASK_BLOCKER: "agent:task-blocker",
+  AGENT_TASK_RESOLVE: "agent:task-resolve",
+  AGENT_TASK_ABANDON: "agent:task-abandon",
+  AGENT_TASK_CLEAR: "agent:task-clear"
+};
+const AutofillChannels = {
+  AUTOFILL_LIST: "autofill:list",
+  AUTOFILL_ADD: "autofill:add",
+  AUTOFILL_UPDATE: "autofill:update",
+  AUTOFILL_DELETE: "autofill:delete",
+  AUTOFILL_FILL: "autofill:fill"
+};
+const AutomationChannels = {
+  AUTOMATION_GET_INSTALLED: "automation:get-installed",
+  AUTOMATION_INSTALL_FROM_FILE: "automation:install-from-file",
+  AUTOMATION_CREATE_FROM_TEXT: "automation:create-from-text",
+  AUTOMATION_UPDATE_FROM_TEXT: "automation:update-from-text",
+  AUTOMATION_UNINSTALL: "automation:uninstall",
+  AUTOMATION_ACTIVITY_START: "automation:activity-start",
+  AUTOMATION_ACTIVITY_CHUNK: "automation:activity-chunk",
+  AUTOMATION_ACTIVITY_END: "automation:activity-end",
+  SCHEDULE_GET_ALL: "schedule:get-all",
+  SCHEDULE_CREATE: "schedule:create",
+  SCHEDULE_UPDATE: "schedule:update",
+  SCHEDULE_DELETE: "schedule:delete",
+  SCHEDULE_JOBS_UPDATE: "schedule:jobs-update"
+};
+const BookmarkChannels = {
+  BOOKMARKS_GET: "bookmarks:get",
+  BOOKMARKS_UPDATE: "bookmarks:update",
+  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",
+  BOOKMARKS_IMPORT_HTML: "bookmarks:import-html",
+  BOOKMARKS_IMPORT_JSON: "bookmarks:import-json",
+  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",
+  FOLDER_EXPORT_HTML: "bookmarks:folder-export-html"
+};
+const BrowsingDataChannels = {
+  CLEAR_BROWSING_DATA: "browsing-data:clear",
+  CLEAR_BROWSING_DATA_OPEN: "browsing-data:open"
+};
+const CodexChannels = {
+  CODEX_START_AUTH: "codex:start-auth",
+  CODEX_CANCEL_AUTH: "codex:cancel-auth",
+  CODEX_AUTH_STATUS: "codex:auth-status",
+  CODEX_DISCONNECT: "codex:disconnect"
+};
+const ContentChannels = {
+  CONTENT_EXTRACT: "content:extract",
+  READER_MODE_TOGGLE: "reader:toggle",
+  PAGE_DIFF_ACTIVITY: "page:diff-activity",
+  PAGE_CHANGED: "page:changed",
+  PAGE_DIFF_GET: "page:diff-get",
+  PAGE_DIFF_HISTORY: "page:diff-history",
+  PAGE_DIFF_DIRTY: "page:diff-dirty"
+};
+const DevToolsChannels = {
+  DEVTOOLS_PANEL_TOGGLE: "devtools-panel:toggle",
+  DEVTOOLS_PANEL_CLOSE: "devtools-panel:close",
+  DEVTOOLS_PANEL_OPEN_TAB: "devtools-panel:open-tab",
+  DEVTOOLS_PANEL_SELECT_TAB: "devtools-panel:select-tab",
+  DEVTOOLS_PANEL_STATE_GET: "devtools-panel:state-get",
+  DEVTOOLS_PANEL_STATE: "devtools-panel:state",
+  DEVTOOLS_PANEL_RESIZE_START: "devtools-panel:resize-start",
+  DEVTOOLS_PANEL_RESIZE: "devtools-panel:resize",
+  DEVTOOLS_PANEL_RESIZE_COMMIT: "devtools-panel:resize-commit",
+  DEVTOOLS_PANEL_POPOUT: "devtools-panel:popout",
+  DEVTOOLS_PANEL_DOCK: "devtools-panel:dock",
+  DEVTOOLS_PANEL_HOST_STATE_GET: "devtools-panel:host-state-get",
+  DEVTOOLS_PANEL_HOST_STATE: "devtools-panel:host-state",
+  DEVTOOLS_PAGE_MAP_REVEAL: "devtools-panel:page-map:reveal"
+};
+const DownloadChannels = {
+  DOWNLOAD_STARTED: "download:started",
+  DOWNLOAD_PROGRESS: "download:progress",
+  DOWNLOAD_DONE: "download:done",
+  DOWNLOADS_GET: "downloads:get",
+  DOWNLOADS_CLEAR: "downloads:clear",
+  DOWNLOADS_OPEN: "downloads:open",
+  DOWNLOADS_SHOW_IN_FOLDER: "downloads:show-in-folder",
+  DOWNLOADS_UPDATE: "downloads:update"
+};
+const HighlightChannels = {
+  HIGHLIGHT_CAPTURE: "highlights:capture",
+  HIGHLIGHT_CAPTURE_RESULT: "highlights:capture-result",
+  HIGHLIGHT_SELECTION: "vessel:highlight-selection",
+  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"
+};
+const HistoryChannels = {
+  HISTORY_GET: "history:get",
+  HISTORY_LIST: "history:list",
+  HISTORY_SEARCH: "history:search",
+  HISTORY_CLEAR: "history:clear",
+  HISTORY_UPDATE: "history:update",
+  HISTORY_EXPORT_HTML: "history:export-html",
+  HISTORY_EXPORT_JSON: "history:export-json",
+  HISTORY_IMPORT: "history:import"
+};
+const HumanVaultChannels = {
+  HUMAN_VAULT_LIST: "human-vault:list",
+  HUMAN_VAULT_GET: "human-vault:get",
+  HUMAN_VAULT_SAVE: "human-vault:save",
+  HUMAN_VAULT_UPDATE: "human-vault:update",
+  HUMAN_VAULT_REMOVE: "human-vault:remove",
+  HUMAN_VAULT_AUDIT_LOG: "human-vault:audit-log"
+};
+const McpChannels = {
+  MCP_REGENERATE_TOKEN: "mcp:regenerate-token"
+};
+const OpenRouterChannels = {
+  OPENROUTER_START_AUTH: "openrouter:start-auth",
+  OPENROUTER_CANCEL_AUTH: "openrouter:cancel-auth",
+  OPENROUTER_AUTH_STATUS: "openrouter:auth-status"
+};
+const PermissionChannels = {
+  PERMISSIONS_GET: "permissions:get",
+  PERMISSIONS_CLEAR: "permissions:clear",
+  PERMISSIONS_CLEAR_ORIGIN: "permissions:clear-origin"
+};
+const PremiumChannels = {
+  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"
+};
+const ResearchChannels = {
+  RESEARCH_STATE_GET: "research:state-get",
+  RESEARCH_STATE_UPDATE: "research:state-update",
+  RESEARCH_START_BRIEF: "research:start-brief",
+  RESEARCH_CONFIRM_BRIEF: "research:confirm-brief",
+  RESEARCH_APPROVE_OBJECTIVES: "research:approve-objectives",
+  RESEARCH_SET_MODE: "research:set-mode",
+  RESEARCH_SET_TRACES: "research:set-traces",
+  RESEARCH_CANCEL: "research:cancel",
+  RESEARCH_STOP_AND_SYNTHESIZE: "research:stop-and-synthesize",
+  RESEARCH_EXPORT_REPORT: "research:export-report"
+};
+const SecurityChannels = {
+  SECURITY_STATE_UPDATE: "security:state-update",
+  SECURITY_SHOW_DETAILS: "security:show-details",
+  SECURITY_PROCEED_ANYWAY: "security:proceed-anyway",
+  SECURITY_GO_BACK_TO_SAFETY: "security:go-back-to-safety"
+};
+const SessionChannels = {
+  SESSION_LIST: "session:list",
+  SESSION_SAVE: "session:save",
+  SESSION_LOAD: "session:load",
+  SESSION_DELETE: "session:delete"
+};
+const SettingsChannels = {
+  SETTINGS_GET: "settings:get",
+  SETTINGS_SET: "settings:set",
+  SETTINGS_UPDATE: "settings:update",
+  SETTINGS_HEALTH_GET: "settings:health:get",
+  SETTINGS_HEALTH_UPDATE: "settings:health:update"
+};
+const SupportChannels = {
+  SUPPORT_SUBMIT_FEEDBACK: "support:submit-feedback"
+};
+const TabChannels = {
+  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",
+  TAB_TOGGLE_AD_BLOCK: "tab:toggle-ad-block",
+  TAB_ZOOM_IN: "tab:zoom-in",
+  TAB_ZOOM_OUT: "tab:zoom-out",
+  TAB_ZOOM_RESET: "tab:zoom-reset",
+  TAB_REOPEN_CLOSED: "tab:reopen-closed",
+  TAB_DUPLICATE: "tab:duplicate",
+  TAB_CONTEXT_MENU: "tab:context-menu",
+  TAB_PIN: "tab:pin",
+  TAB_UNPIN: "tab:unpin",
+  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",
+  TAB_TOGGLE_MUTE: "tab:toggle-mute",
+  TAB_PRINT: "tab:print",
+  TAB_PRINT_TO_PDF: "tab:print-to-pdf",
+  TAB_TOGGLE_PIP: "tab:toggle-pip"
+};
+const UIChannels = {
+  SIDEBAR_TOGGLE: "ui:sidebar-toggle",
+  SIDEBAR_NAVIGATE: "ui:sidebar-navigate",
+  SIDEBAR_RESIZE: "ui:sidebar-resize",
+  SIDEBAR_RESIZE_START: "ui:sidebar-resize-start",
+  SIDEBAR_RESIZE_COMMIT: "ui:sidebar-resize-commit",
+  SIDEBAR_POPOUT: "ui:sidebar-popout",
+  SIDEBAR_DOCK: "ui:sidebar-dock",
+  SIDEBAR_STATE_UPDATE: "ui:sidebar-state-update",
+  SIDEBAR_CONTEXT_MENU: "ui:sidebar-context-menu",
+  FOCUS_MODE_TOGGLE: "ui:focus-mode-toggle",
+  SETTINGS_VISIBILITY: "ui:settings-visibility"
+};
+const UpdateChannels = {
+  UPDATES_CHECK: "updates:check",
+  UPDATES_OPEN_DOWNLOAD: "updates:open-download"
+};
+const VaultChannels = {
+  VAULT_LIST: "vault:list",
+  VAULT_ADD: "vault:add",
+  VAULT_UPDATE: "vault:update",
+  VAULT_REMOVE: "vault:remove",
+  VAULT_AUDIT_LOG: "vault:audit-log"
+};
+const WindowControlChannels = {
+  WINDOW_MINIMIZE: "window:minimize",
+  WINDOW_MAXIMIZE: "window:maximize",
+  WINDOW_CLOSE: "window:close",
+  OPEN_NEW_WINDOW: "window:open-new",
+  OPEN_PRIVATE_WINDOW: "private:open-window",
+  IS_PRIVATE_MODE: "private:is-private",
+  FIND_IN_PAGE_START: "find:start",
+  FIND_IN_PAGE_NEXT: "find:next",
+  FIND_IN_PAGE_STOP: "find:stop",
+  FIND_IN_PAGE_RESULT: "find:result"
+};
+const Channels = {
+  ...AIChannels,
+  ...AutofillChannels,
+  ...AutomationChannels,
+  ...BookmarkChannels,
+  ...BrowsingDataChannels,
+  ...CodexChannels,
+  ...ContentChannels,
+  ...DevToolsChannels,
+  ...DownloadChannels,
+  ...HighlightChannels,
+  ...HistoryChannels,
+  ...HumanVaultChannels,
+  ...McpChannels,
+  ...OpenRouterChannels,
+  ...PermissionChannels,
+  ...PremiumChannels,
+  ...ResearchChannels,
+  ...SecurityChannels,
+  ...SessionChannels,
+  ...SettingsChannels,
+  ...SupportChannels,
+  ...TabChannels,
+  ...UIChannels,
+  ...UpdateChannels,
+  ...VaultChannels,
+  ...WindowControlChannels
+};
+const api = {
+  tabs: {
+    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),
+    toggleAdBlock: (id) => electron.ipcRenderer.invoke(Channels.TAB_TOGGLE_AD_BLOCK, id),
+    zoomIn: (id) => electron.ipcRenderer.invoke(Channels.TAB_ZOOM_IN, id),
+    zoomOut: (id) => electron.ipcRenderer.invoke(Channels.TAB_ZOOM_OUT, id),
+    zoomReset: (id) => electron.ipcRenderer.invoke(Channels.TAB_ZOOM_RESET, id),
+    reopenClosed: () => electron.ipcRenderer.invoke(Channels.TAB_REOPEN_CLOSED),
+    duplicate: (id) => electron.ipcRenderer.invoke(Channels.TAB_DUPLICATE, id),
+    showContextMenu: (id) => electron.ipcRenderer.send(Channels.TAB_CONTEXT_MENU, id),
+    openPrivateWindow: () => electron.ipcRenderer.invoke(Channels.OPEN_PRIVATE_WINDOW),
+    isPrivateMode: () => electron.ipcRenderer.invoke(Channels.IS_PRIVATE_MODE),
+    pin: (id) => electron.ipcRenderer.invoke(Channels.TAB_PIN, id),
+    unpin: (id) => electron.ipcRenderer.invoke(Channels.TAB_UNPIN, id),
+    createGroup: (id) => electron.ipcRenderer.invoke(Channels.TAB_GROUP_CREATE, id),
+    addToGroup: (id, groupId) => electron.ipcRenderer.invoke(Channels.TAB_GROUP_ADD_TAB, id, groupId),
+    removeFromGroup: (id) => electron.ipcRenderer.invoke(Channels.TAB_GROUP_REMOVE_TAB, id),
+    toggleGroupCollapsed: (groupId) => electron.ipcRenderer.invoke(Channels.TAB_GROUP_TOGGLE_COLLAPSED, groupId),
+    setGroupColor: (groupId, color) => electron.ipcRenderer.invoke(Channels.TAB_GROUP_SET_COLOR, groupId, color),
+    showGroupContextMenu: (groupId) => electron.ipcRenderer.send(Channels.TAB_GROUP_CONTEXT_MENU, groupId),
+    toggleMute: (id) => electron.ipcRenderer.invoke(Channels.TAB_TOGGLE_MUTE, id),
+    print: (id) => electron.ipcRenderer.invoke(Channels.TAB_PRINT, id),
+    printToPdf: (id) => electron.ipcRenderer.invoke(Channels.TAB_PRINT_TO_PDF, id),
+    openNewWindow: () => electron.ipcRenderer.invoke(Channels.OPEN_NEW_WINDOW),
+    getState: () => electron.ipcRenderer.invoke(Channels.TAB_STATE_GET),
+    onStateUpdate: (cb) => {
+      const handler = (_, tabs, activeId) => cb(tabs, activeId);
+      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.AI_QUERY, prompt, history),
+    onStreamStart: (cb) => {
+      const handler = (_, prompt) => cb(prompt);
+      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.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.AI_STREAM_END, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_END, handler);
+    },
+    onStreamIdle: (cb) => {
+      const handler = () => cb();
+      electron.ipcRenderer.on(Channels.AI_STREAM_IDLE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_IDLE, handler);
+    },
+    onResearchClarification: (cb) => {
+      const handler = (_, payload) => cb(payload);
+      electron.ipcRenderer.on(Channels.AI_RESEARCH_CLARIFICATION, handler);
+      return () => electron.ipcRenderer.removeListener(
+        Channels.AI_RESEARCH_CLARIFICATION,
+        handler
+      );
+    },
+    onAutomationActivityStart: (cb) => {
+      const handler = (_, entry) => cb(entry);
+      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.AUTOMATION_ACTIVITY_CHUNK, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AUTOMATION_ACTIVITY_CHUNK, handler);
+    },
+    onAutomationActivityEnd: (cb) => {
+      const handler = (_, payload) => cb(payload);
+      electron.ipcRenderer.on(Channels.AUTOMATION_ACTIVITY_END, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AUTOMATION_ACTIVITY_END, handler);
+    },
+    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.AGENT_RUNTIME_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.AGENT_RUNTIME_UPDATE, handler);
+    },
+    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),
+    updateCheckpointNote: (checkpointId, note) => electron.ipcRenderer.invoke(Channels.AGENT_CHECKPOINT_UPDATE_NOTE, checkpointId, note),
+    undoLastAction: () => electron.ipcRenderer.invoke(Channels.AGENT_UNDO_LAST_ACTION),
+    captureSession: (note) => electron.ipcRenderer.invoke(Channels.AGENT_SESSION_CAPTURE, note),
+    restoreSession: (snapshot) => electron.ipcRenderer.invoke(Channels.AGENT_SESSION_RESTORE, snapshot),
+    startTaskMemory: (goal) => electron.ipcRenderer.invoke(Channels.AGENT_TASK_START, goal),
+    updateTaskMemory: (patch) => electron.ipcRenderer.invoke(Channels.AGENT_TASK_UPDATE, patch),
+    addTaskNote: (text) => electron.ipcRenderer.invoke(Channels.AGENT_TASK_NOTE, text),
+    setTaskBlocker: (blocker) => electron.ipcRenderer.invoke(Channels.AGENT_TASK_BLOCKER, blocker),
+    resolveTaskMemory: (summary) => electron.ipcRenderer.invoke(Channels.AGENT_TASK_RESOLVE, summary),
+    abandonTaskMemory: (reason) => electron.ipcRenderer.invoke(Channels.AGENT_TASK_ABANDON, reason),
+    clearTaskMemory: () => electron.ipcRenderer.invoke(Channels.AGENT_TASK_CLEAR)
+  },
+  research: {
+    getState: () => electron.ipcRenderer.invoke(Channels.RESEARCH_STATE_GET),
+    onStateUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.RESEARCH_STATE_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.RESEARCH_STATE_UPDATE, handler);
+    },
+    startBrief: (query) => electron.ipcRenderer.invoke(Channels.RESEARCH_START_BRIEF, query),
+    confirmBrief: () => electron.ipcRenderer.invoke(Channels.RESEARCH_CONFIRM_BRIEF),
+    approveObjectives: (options) => electron.ipcRenderer.invoke(Channels.RESEARCH_APPROVE_OBJECTIVES, options ?? {}),
+    setMode: (mode) => electron.ipcRenderer.invoke(Channels.RESEARCH_SET_MODE, mode),
+    setTraces: (include) => electron.ipcRenderer.invoke(Channels.RESEARCH_SET_TRACES, include),
+    cancel: () => electron.ipcRenderer.invoke(Channels.RESEARCH_CANCEL),
+    stopAndSynthesize: () => electron.ipcRenderer.invoke(Channels.RESEARCH_STOP_AND_SYNTHESIZE),
+    exportReport: () => electron.ipcRenderer.invoke(Channels.RESEARCH_EXPORT_REPORT)
+  },
+  content: {
+    extract: () => electron.ipcRenderer.invoke(Channels.CONTENT_EXTRACT),
+    toggleReader: () => electron.ipcRenderer.invoke(Channels.READER_MODE_TOGGLE)
+  },
+  highlights: {
+    capture: () => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_CAPTURE),
+    onCaptureResult: (cb) => {
+      const handler = (_, result) => cb(result);
+      electron.ipcRenderer.on(Channels.HIGHLIGHT_CAPTURE_RESULT, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.HIGHLIGHT_CAPTURE_RESULT, handler);
+    },
+    getCount: () => electron.ipcRenderer.invoke(Channels.HIGHLIGHT_NAV_COUNT),
+    onCountUpdate: (cb) => {
+      const handler = (_, count) => cb(count);
+      electron.ipcRenderer.on(Channels.HIGHLIGHT_COUNT_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.HIGHLIGHT_COUNT_UPDATE, handler);
+    },
+    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.SIDEBAR_HIGHLIGHT_ACTION, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SIDEBAR_HIGHLIGHT_ACTION, handler);
+    }
+  },
+  ui: {
+    toggleSidebar: () => electron.ipcRenderer.invoke(Channels.SIDEBAR_TOGGLE),
+    openSidebarTab: (tab) => electron.ipcRenderer.invoke(Channels.SIDEBAR_NAVIGATE, tab),
+    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),
+    popOutSidebar: () => electron.ipcRenderer.invoke(Channels.SIDEBAR_POPOUT),
+    dockSidebar: () => electron.ipcRenderer.invoke(Channels.SIDEBAR_DOCK),
+    rendererReady: (view) => electron.ipcRenderer.send(Channels.RENDERER_VIEW_READY, view),
+    onSidebarContextMenu: (cb) => {
+      const handler = (_, position) => cb(position);
+      electron.ipcRenderer.on(Channels.SIDEBAR_CONTEXT_MENU, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SIDEBAR_CONTEXT_MENU, handler);
+    },
+    onSidebarNavigate: (cb) => {
+      const handler = (_, tab) => cb(tab);
+      electron.ipcRenderer.on(Channels.SIDEBAR_NAVIGATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SIDEBAR_NAVIGATE, handler);
+    },
+    onSidebarStateUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.SIDEBAR_STATE_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SIDEBAR_STATE_UPDATE, handler);
+    },
+    toggleFocusMode: () => electron.ipcRenderer.invoke(Channels.FOCUS_MODE_TOGGLE),
+    setSettingsVisibility: (open) => electron.ipcRenderer.invoke(Channels.SETTINGS_VISIBILITY, open)
+  },
+  settings: {
+    get: () => electron.ipcRenderer.invoke(Channels.SETTINGS_GET),
+    getHealth: () => electron.ipcRenderer.invoke(Channels.SETTINGS_HEALTH_GET),
+    regenerateMcpToken: () => electron.ipcRenderer.invoke(Channels.MCP_REGENERATE_TOKEN),
+    onHealthUpdate: (cb) => {
+      const handler = (_, health) => cb(health);
+      electron.ipcRenderer.on(Channels.SETTINGS_HEALTH_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SETTINGS_HEALTH_UPDATE, handler);
+    },
+    set: (key, value) => electron.ipcRenderer.invoke(Channels.SETTINGS_SET, key, value),
+    onUpdate: (cb) => {
+      const handler = (_, settings) => cb(settings);
+      electron.ipcRenderer.on(Channels.SETTINGS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SETTINGS_UPDATE, handler);
+    }
+  },
+  support: {
+    submitFeedback: (email, message) => electron.ipcRenderer.invoke(Channels.SUPPORT_SUBMIT_FEEDBACK, email, message)
+  },
+  bookmarks: {
+    get: () => electron.ipcRenderer.invoke(Channels.BOOKMARKS_GET),
+    saveBookmark: (url, title, folderId, note, intent, expectedContent, keyFields, agentHints) => electron.ipcRenderer.invoke(
+      Channels.BOOKMARK_SAVE,
+      url,
+      title,
+      folderId,
+      note,
+      intent,
+      expectedContent,
+      keyFields,
+      agentHints
+    ),
+    updateBookmark: (id, updates) => electron.ipcRenderer.invoke(Channels.BOOKMARK_UPDATE, id, updates),
+    removeBookmark: (id) => electron.ipcRenderer.invoke(Channels.BOOKMARK_REMOVE, id),
+    exportHtml: (options) => electron.ipcRenderer.invoke(Channels.BOOKMARKS_EXPORT_HTML, options),
+    exportJson: () => electron.ipcRenderer.invoke(Channels.BOOKMARKS_EXPORT_JSON),
+    exportFolderHtml: (folderId, options) => electron.ipcRenderer.invoke(Channels.FOLDER_EXPORT_HTML, folderId, options),
+    importHtml: () => electron.ipcRenderer.invoke(Channels.BOOKMARKS_IMPORT_HTML),
+    importJson: () => electron.ipcRenderer.invoke(Channels.BOOKMARKS_IMPORT_JSON),
+    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.BOOKMARK_ADD_CONTEXT_TO_CHAT, handler);
+      return () => electron.ipcRenderer.removeListener(
+        Channels.BOOKMARK_ADD_CONTEXT_TO_CHAT,
+        handler
+      );
+    },
+    onUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.BOOKMARKS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.BOOKMARKS_UPDATE, handler);
+    }
+  },
+  devtoolsPanel: {
+    toggle: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_TOGGLE),
+    close: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_CLOSE),
+    openTab: (tab) => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_OPEN_TAB, tab),
+    startResize: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_RESIZE_START),
+    resize: (height) => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_RESIZE, height),
+    commitResize: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_RESIZE_COMMIT),
+    popOut: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_POPOUT),
+    dock: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_DOCK),
+    getState: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_STATE_GET),
+    getHostState: () => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PANEL_HOST_STATE_GET),
+    revealElement: (selector) => electron.ipcRenderer.invoke(Channels.DEVTOOLS_PAGE_MAP_REVEAL, { selector }),
+    onStateUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.DEVTOOLS_PANEL_STATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DEVTOOLS_PANEL_STATE, handler);
+    },
+    onHostStateUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.DEVTOOLS_PANEL_HOST_STATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DEVTOOLS_PANEL_HOST_STATE, handler);
+    },
+    onSelectTab: (cb) => {
+      const handler = (_, tab) => cb(tab);
+      electron.ipcRenderer.on(Channels.DEVTOOLS_PANEL_SELECT_TAB, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DEVTOOLS_PANEL_SELECT_TAB, handler);
+    }
+  },
+  find: {
+    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.FIND_IN_PAGE_RESULT, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.FIND_IN_PAGE_RESULT, handler);
+    }
+  },
+  history: {
+    get: () => electron.ipcRenderer.invoke(Channels.HISTORY_GET),
+    list: (offset, limit) => electron.ipcRenderer.invoke(Channels.HISTORY_LIST, offset, limit),
+    search: (query) => electron.ipcRenderer.invoke(Channels.HISTORY_SEARCH, query),
+    clear: () => electron.ipcRenderer.invoke(Channels.HISTORY_CLEAR),
+    exportHtml: () => electron.ipcRenderer.invoke(Channels.HISTORY_EXPORT_HTML),
+    exportJson: () => electron.ipcRenderer.invoke(Channels.HISTORY_EXPORT_JSON),
+    importFile: () => electron.ipcRenderer.invoke(Channels.HISTORY_IMPORT),
+    onUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.HISTORY_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.HISTORY_UPDATE, handler);
+    }
+  },
+  premium: {
+    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.PREMIUM_ACTIVATION_VERIFY,
+      email,
+      code,
+      challengeToken
+    ),
+    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.PREMIUM_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.PREMIUM_UPDATE, handler);
+    }
+  },
+  sessions: {
+    list: () => electron.ipcRenderer.invoke(Channels.SESSION_LIST),
+    save: (name) => electron.ipcRenderer.invoke(Channels.SESSION_SAVE, name),
+    load: (name) => electron.ipcRenderer.invoke(Channels.SESSION_LOAD, name),
+    delete: (name) => electron.ipcRenderer.invoke(Channels.SESSION_DELETE, name)
+  },
+  vault: {
+    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)
+  },
+  humanVault: {
+    list: (domain) => electron.ipcRenderer.invoke(Channels.HUMAN_VAULT_LIST, domain),
+    get: (id) => electron.ipcRenderer.invoke(Channels.HUMAN_VAULT_GET, id),
+    save: (entry) => electron.ipcRenderer.invoke(Channels.HUMAN_VAULT_SAVE, entry),
+    update: (id, updates) => electron.ipcRenderer.invoke(Channels.HUMAN_VAULT_UPDATE, id, updates),
+    remove: (id) => electron.ipcRenderer.invoke(Channels.HUMAN_VAULT_REMOVE, id),
+    auditLog: (limit) => electron.ipcRenderer.invoke(Channels.HUMAN_VAULT_AUDIT_LOG, limit)
+  },
+  automation: {
+    getInstalled: () => electron.ipcRenderer.invoke(Channels.AUTOMATION_GET_INSTALLED),
+    installFromFile: () => electron.ipcRenderer.invoke(Channels.AUTOMATION_INSTALL_FROM_FILE),
+    createFromText: (source) => electron.ipcRenderer.invoke(Channels.AUTOMATION_CREATE_FROM_TEXT, source),
+    updateFromText: (id, source) => electron.ipcRenderer.invoke(Channels.AUTOMATION_UPDATE_FROM_TEXT, id, source),
+    uninstall: (id) => electron.ipcRenderer.invoke(Channels.AUTOMATION_UNINSTALL, id)
+  },
+  schedule: {
+    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.SCHEDULE_JOBS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SCHEDULE_JOBS_UPDATE, handler);
+    }
+  },
+  window: {
+    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.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)
+  },
+  downloads: {
+    getAll: () => electron.ipcRenderer.invoke(Channels.DOWNLOADS_GET),
+    clear: () => electron.ipcRenderer.invoke(Channels.DOWNLOADS_CLEAR),
+    open: (id) => electron.ipcRenderer.invoke(Channels.DOWNLOADS_OPEN, id),
+    showInFolder: (id) => electron.ipcRenderer.invoke(Channels.DOWNLOADS_SHOW_IN_FOLDER, id),
+    onUpdate: (cb) => {
+      const handler = (_, items) => cb(items);
+      electron.ipcRenderer.on(Channels.DOWNLOADS_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DOWNLOADS_UPDATE, handler);
+    },
+    onStarted: (cb) => {
+      const handler = (_, info) => cb(info);
+      electron.ipcRenderer.on(Channels.DOWNLOAD_STARTED, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DOWNLOAD_STARTED, handler);
+    },
+    onProgress: (cb) => {
+      const handler = (_, info) => cb(info);
+      electron.ipcRenderer.on(Channels.DOWNLOAD_PROGRESS, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DOWNLOAD_PROGRESS, handler);
+    },
+    onDone: (cb) => {
+      const handler = (_, info) => cb(info);
+      electron.ipcRenderer.on(Channels.DOWNLOAD_DONE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.DOWNLOAD_DONE, handler);
+    }
+  },
+  pageDiff: {
+    onChanged: (cb) => {
+      const handler = (_, diff) => cb(diff);
+      electron.ipcRenderer.on(Channels.PAGE_CHANGED, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.PAGE_CHANGED, handler);
+    },
+    get: () => electron.ipcRenderer.invoke(Channels.PAGE_DIFF_GET),
+    getHistory: () => electron.ipcRenderer.invoke(Channels.PAGE_DIFF_HISTORY)
+  },
+  security: {
+    onStateUpdate: (cb) => {
+      const handler = (_, data) => cb(data.tabId, data.state);
+      electron.ipcRenderer.on(Channels.SECURITY_STATE_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.SECURITY_STATE_UPDATE, handler);
+    },
+    showDetails: (state) => electron.ipcRenderer.invoke(Channels.SECURITY_SHOW_DETAILS, state),
+    proceedAnyway: (tabId) => electron.ipcRenderer.invoke(Channels.SECURITY_PROCEED_ANYWAY, tabId),
+    goBackToSafety: (tabId) => electron.ipcRenderer.invoke(Channels.SECURITY_GO_BACK_TO_SAFETY, tabId)
+  },
+  updates: {
+    check: () => electron.ipcRenderer.invoke(Channels.UPDATES_CHECK),
+    openDownload: () => electron.ipcRenderer.invoke(Channels.UPDATES_OPEN_DOWNLOAD)
+  },
+  permissions: {
+    getAll: () => electron.ipcRenderer.invoke(Channels.PERMISSIONS_GET),
+    clear: () => electron.ipcRenderer.invoke(Channels.PERMISSIONS_CLEAR),
+    clearOrigin: (origin) => electron.ipcRenderer.invoke(Channels.PERMISSIONS_CLEAR_ORIGIN, origin)
+  },
+  browsingData: {
+    clear: (options) => electron.ipcRenderer.invoke(Channels.CLEAR_BROWSING_DATA, options),
+    onOpenDialog: (cb) => {
+      const handler = () => cb();
+      electron.ipcRenderer.on(Channels.CLEAR_BROWSING_DATA_OPEN, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.CLEAR_BROWSING_DATA_OPEN, handler);
+    }
+  },
+  pip: {
+    toggle: () => electron.ipcRenderer.invoke(Channels.TAB_TOGGLE_PIP)
+  },
+  codex: {
+    startAuth: () => electron.ipcRenderer.invoke(Channels.CODEX_START_AUTH),
+    cancelAuth: () => electron.ipcRenderer.invoke(Channels.CODEX_CANCEL_AUTH),
+    disconnect: () => electron.ipcRenderer.invoke(Channels.CODEX_DISCONNECT),
+    onAuthStatus: (cb) => {
+      const handler = (_, payload) => cb(payload);
+      electron.ipcRenderer.on(Channels.CODEX_AUTH_STATUS, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.CODEX_AUTH_STATUS, handler);
+    }
+  },
+  openrouter: {
+    startAuth: () => electron.ipcRenderer.invoke(Channels.OPENROUTER_START_AUTH),
+    cancelAuth: () => electron.ipcRenderer.invoke(Channels.OPENROUTER_CANCEL_AUTH),
+    onAuthStatus: (cb) => {
+      const handler = (_, payload) => cb(payload);
+      electron.ipcRenderer.on(Channels.OPENROUTER_AUTH_STATUS, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.OPENROUTER_AUTH_STATUS, handler);
+    }
+  }
+};
+electron.contextBridge.exposeInMainWorld("vessel", api);