npm - @quanta-intellect/vessel-browser - Versions diffs - 0.1.90 → 0.1.94 - Mend

@quanta-intellect/vessel-browser 0.1.90 → 0.1.94

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 (6) hide show

package/out/main/index.js +1045 -569
package/out/preload/index.js +33 -1
package/out/renderer/assets/{index-CHSGQlQr.css → index-BFKx2klB.css} +82 -1
package/out/renderer/assets/{index-Bu2bPSV-.js → index-BeUwMCx4.js} +430 -171
package/out/renderer/index.html +3 -3
package/package.json +10 -6

package/out/main/index.js CHANGED Viewed

@@ -104,10 +104,23 @@ function canUseSafeStorage$1() {
     return false;
   }
 }
+function writePrivateFile(filePath2, data) {
+  fs.writeFileSync(filePath2, data, { mode: 384 });
+  try {
+    fs.chmodSync(filePath2, 384);
+  } catch {
+  }
+}
+function assertSafeStorageAvailable() {
+  if (!canUseSafeStorage$1()) {
+    throw new Error("OS-backed secret storage is unavailable; refusing to store secrets on disk.");
+  }
+}
 function readStoredProviderSecret() {
   try {
+    if (!canUseSafeStorage$1()) return null;
     const raw = fs.readFileSync(getChatProviderSecretPath());
-    const decoded = canUseSafeStorage$1() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
+    const decoded = electron.safeStorage.decryptString(raw);
     const parsed = JSON.parse(decoded);
     if (parsed && typeof parsed === "object" && typeof parsed.providerId === "string" && typeof parsed.apiKey === "string") {
       return parsed;
@@ -117,15 +130,12 @@ function readStoredProviderSecret() {
   return null;
 }
 function writeStoredProviderSecret(secret) {
-  const filePath = getChatProviderSecretPath();
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  assertSafeStorageAvailable();
+  const filePath2 = getChatProviderSecretPath();
+  fs.mkdirSync(path.dirname(filePath2), { recursive: true });
   const payload = JSON.stringify(secret);
-  if (canUseSafeStorage$1()) {
-    const encrypted = electron.safeStorage.encryptString(payload);
-    fs.writeFileSync(filePath, encrypted, { mode: 384 });
-    return;
-  }
-  fs.writeFileSync(filePath, payload, { mode: 384 });
+  const encrypted = electron.safeStorage.encryptString(payload);
+  writePrivateFile(filePath2, encrypted);
 }
 function clearStoredProviderSecret() {
   try {
@@ -138,8 +148,9 @@ function getCodexTokensPath() {
 }
 function readStoredCodexTokens() {
   try {
+    if (!canUseSafeStorage$1()) return null;
     const raw = fs.readFileSync(getCodexTokensPath());
-    const decoded = canUseSafeStorage$1() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
+    const decoded = electron.safeStorage.decryptString(raw);
     const parsed = JSON.parse(decoded);
     if (parsed && typeof parsed === "object" && typeof parsed.accessToken === "string" && typeof parsed.refreshToken === "string") {
       return parsed;
@@ -149,15 +160,12 @@ function readStoredCodexTokens() {
   return null;
 }
 function writeStoredCodexTokens(tokens) {
-  const filePath = getCodexTokensPath();
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  assertSafeStorageAvailable();
+  const filePath2 = getCodexTokensPath();
+  fs.mkdirSync(path.dirname(filePath2), { recursive: true });
   const payload = JSON.stringify(tokens);
-  if (canUseSafeStorage$1()) {
-    const encrypted = electron.safeStorage.encryptString(payload);
-    fs.writeFileSync(filePath, encrypted, { mode: 384 });
-    return;
-  }
-  fs.writeFileSync(filePath, payload, { mode: 384 });
+  const encrypted = electron.safeStorage.encryptString(payload);
+  writePrivateFile(filePath2, encrypted);
 }
 function clearStoredCodexTokens() {
   try {
@@ -282,11 +290,11 @@ function saveSettings() {
     }
   }, SAVE_DEBOUNCE_MS$6);
 }
-function setSetting(key, value) {
+function setSetting(key2, value) {
   loadSettings();
-  if (key === "mcpPort") {
+  if (key2 === "mcpPort") {
     settings.mcpPort = sanitizePort(value);
-  } else if (key === "chatProvider") {
+  } else if (key2 === "chatProvider") {
     const nextProvider = value;
     if (!nextProvider) {
       clearStoredProviderSecret();
@@ -314,7 +322,7 @@ function setSetting(key, value) {
       };
     }
   } else {
-    settings[key] = value;
+    settings[key2] = value;
   }
   saveSettings();
   return { ...settings };
@@ -375,6 +383,28 @@ function assertPermittedNavigationURL(url) {
     throw new Error(policyError);
   }
 }
+function loadPermittedNavigationURL(wc, url) {
+  assertPermittedNavigationURL(url);
+  return wc.loadURL(url);
+}
+function loadInternalDataURL(wc, dataUrl) {
+  if (!dataUrl.startsWith("data:text/html;charset=utf-8,")) {
+    throw new Error("Blocked unexpected internal data URL");
+  }
+  return wc.loadURL(dataUrl);
+}
+function loadTrustedAppURL(wc, url) {
+  const parsed = new URL(url);
+  if (!["file:", "http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`Blocked unexpected app URL scheme: ${parsed.protocol}`);
+  }
+  const isHttp = parsed.protocol === "http:" || parsed.protocol === "https:";
+  const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+  if (isHttp && !isLocalhost) {
+    throw new Error(`Blocked unexpected app URL host: ${parsed.hostname}`);
+  }
+  return wc.loadURL(parsed.toString());
+}
 const MAX_CUSTOM_HISTORY = 50;
 const READER_MODE_DATA_URL_PREFIX = "data:text/html;charset=utf-8,";
 const logger$m = createLogger("Tab");
@@ -490,27 +520,27 @@ class Tab {
     this.view.webContents.on("before-input-event", (event, input) => {
       if (!input.control && !input.meta) return;
       if (input.type !== "keyDown") return;
-      const key = input.key.toLowerCase();
+      const key2 = input.key.toLowerCase();
       const wc = this.view.webContents;
-      if (key === "+" || key === "=") {
+      if (key2 === "+" || key2 === "=") {
         this.zoomIn();
         event.preventDefault();
         return;
       }
-      if (key === "-") {
+      if (key2 === "-") {
         this.zoomOut();
         event.preventDefault();
         return;
       }
-      if (key === "0") {
+      if (key2 === "0") {
         this.zoomReset();
         event.preventDefault();
         return;
       }
-      if (key === "c") wc.copy();
-      else if (key === "v") wc.paste();
-      else if (key === "x") wc.cut();
-      else if (key === "a") wc.selectAll();
+      if (key2 === "c") wc.copy();
+      else if (key2 === "v") wc.paste();
+      else if (key2 === "x") wc.cut();
+      else if (key2 === "a") wc.selectAll();
     });
     this.setupListeners();
     if (url) {
@@ -784,8 +814,8 @@ class Tab {
     }
     if (postBody) {
       const params = new URLSearchParams();
-      for (const [key, value] of Object.entries(postBody)) {
-        params.set(key, value);
+      for (const [key2, value] of Object.entries(postBody)) {
+        params.set(key2, value);
       }
       return this.guardedLoadURL(url, {
         method: "POST",
@@ -1059,22 +1089,22 @@ function encodeStoredData(payload, secure) {
   return payload;
 }
 function loadJsonFile({
-  filePath,
+  filePath: filePath2,
   fallback,
-  parse,
+  parse: parse2,
   secure = false
 }) {
   try {
-    const raw = fs.readFileSync(filePath);
+    const raw = fs.readFileSync(filePath2);
     const decoded = decodeStoredData(raw, secure);
-    return parse(JSON.parse(decoded));
+    return parse2(JSON.parse(decoded));
   } catch {
     return fallback;
   }
 }
 function createDebouncedJsonPersistence({
   debounceMs,
-  filePath,
+  filePath: filePath2,
   getValue,
   logLabel,
   resetOnSchedule = false,
@@ -1097,9 +1127,9 @@ function createDebouncedJsonPersistence({
       2
     );
     const data = encodeStoredData(payload, secure);
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true }).then(
+    await fs.promises.mkdir(path.dirname(filePath2), { recursive: true }).then(
       () => fs.promises.writeFile(
-        filePath,
+        filePath2,
         data,
         typeof data === "string" ? { encoding: "utf-8", mode: 384 } : { mode: 384 }
       )
@@ -1125,7 +1155,7 @@ function createDebouncedJsonPersistence({
     flush: flush2
   };
 }
-let state$4 = null;
+let state$5 = null;
 const listeners$2 = /* @__PURE__ */ new Set();
 const SAVE_DEBOUNCE_MS$5 = 250;
 function getHighlightsPath() {
@@ -1135,19 +1165,19 @@ function createPersistence$1() {
   return createDebouncedJsonPersistence({
     debounceMs: SAVE_DEBOUNCE_MS$5,
     filePath: getHighlightsPath(),
-    getValue: () => state$4,
+    getValue: () => state$5,
     logLabel: "highlights",
     resetOnSchedule: true
   });
 }
-let persistence$5 = null;
+let persistence$7 = null;
 function getPersistence$1() {
-  persistence$5 ??= createPersistence$1();
-  return persistence$5;
+  persistence$7 ??= createPersistence$1();
+  return persistence$7;
 }
 function load$4() {
-  if (state$4) return state$4;
-  state$4 = loadJsonFile({
+  if (state$5) return state$5;
+  state$5 = loadJsonFile({
     filePath: getHighlightsPath(),
     fallback: { highlights: [] },
     parse: (raw) => {
@@ -1157,16 +1187,16 @@ function load$4() {
       };
     }
   });
-  return state$4;
+  return state$5;
 }
-function save$2() {
+function save$3() {
   getPersistence$1().schedule();
 }
-function emit$2() {
-  if (!state$4) return;
-  const snapshot = { highlights: [...state$4.highlights] };
+function emit$4() {
+  if (!state$5) return;
+  const snapshot2 = { highlights: [...state$5.highlights] };
   for (const listener of listeners$2) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 function normalizeUrl$1(rawUrl) {
@@ -1180,12 +1210,12 @@ function normalizeUrl$1(rawUrl) {
 }
 function getState$2() {
   load$4();
-  return { highlights: [...state$4.highlights] };
+  return { highlights: [...state$5.highlights] };
 }
 function getHighlightsForUrl(url) {
   load$4();
   const normalized = normalizeUrl$1(url);
-  return state$4.highlights.filter((h) => h.url === normalized);
+  return state$5.highlights.filter((h) => h.url === normalized);
 }
 function addHighlight(url, selector, text, label, color, source) {
   load$4();
@@ -1199,45 +1229,45 @@ function addHighlight(url, selector, text, label, color, source) {
     source: source || void 0,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state$4.highlights.push(highlight);
-  save$2();
-  emit$2();
+  state$5.highlights.push(highlight);
+  save$3();
+  emit$4();
   return highlight;
 }
 function removeHighlight(id) {
   load$4();
-  const index = state$4.highlights.findIndex((h) => h.id === id);
+  const index = state$5.highlights.findIndex((h) => h.id === id);
   if (index === -1) return null;
-  const [removed] = state$4.highlights.splice(index, 1);
-  save$2();
-  emit$2();
+  const [removed] = state$5.highlights.splice(index, 1);
+  save$3();
+  emit$4();
   return removed;
 }
 function findHighlightByText(url, text) {
   load$4();
   const normalized = normalizeUrl$1(url);
-  return state$4.highlights.find(
+  return state$5.highlights.find(
     (h) => h.url === normalized && h.text && h.text === text
   ) ?? null;
 }
 function updateHighlightColor(id, color) {
   load$4();
-  const highlight = state$4.highlights.find((h) => h.id === id);
+  const highlight = state$5.highlights.find((h) => h.id === id);
   if (!highlight) return null;
   highlight.color = color;
-  save$2();
-  emit$2();
+  save$3();
+  emit$4();
   return highlight;
 }
 function clearHighlightsForUrl(url) {
   load$4();
   const normalized = normalizeUrl$1(url);
-  const before = state$4.highlights.length;
-  state$4.highlights = state$4.highlights.filter((h) => h.url !== normalized);
-  const removed = before - state$4.highlights.length;
+  const before = state$5.highlights.length;
+  state$5.highlights = state$5.highlights.filter((h) => h.url !== normalized);
+  const removed = before - state$5.highlights.length;
   if (removed > 0) {
-    save$2();
-    emit$2();
+    save$3();
+    emit$4();
   }
   return removed;
 }
@@ -1867,14 +1897,14 @@ function persistHighlight(url, text) {
 }
 const MAX_HISTORY_ENTRIES = 5e3;
 const SAVE_DEBOUNCE_MS$4 = 250;
-let state$3 = null;
+let state$4 = null;
 const listeners$1 = /* @__PURE__ */ new Set();
 function getHistoryPath() {
   return path.join(electron.app.getPath("userData"), "vessel-history.json");
 }
 function load$3() {
-  if (state$3) return state$3;
-  state$3 = loadJsonFile({
+  if (state$4) return state$4;
+  state$4 = loadJsonFile({
     filePath: getHistoryPath(),
     fallback: { entries: [] },
     parse: (raw) => {
@@ -1884,27 +1914,27 @@ function load$3() {
       };
     }
   });
-  return state$3;
+  return state$4;
 }
-const persistence$4 = createDebouncedJsonPersistence({
+const persistence$6 = createDebouncedJsonPersistence({
   debounceMs: SAVE_DEBOUNCE_MS$4,
   filePath: getHistoryPath(),
-  getValue: () => state$3,
+  getValue: () => state$4,
   logLabel: "history"
 });
-function save$1() {
-  persistence$4.schedule();
+function save$2() {
+  persistence$6.schedule();
 }
-function emit$1() {
-  if (!state$3) return;
-  const snapshot = { entries: [...state$3.entries] };
+function emit$3() {
+  if (!state$4) return;
+  const snapshot2 = { entries: [...state$4.entries] };
   for (const listener of listeners$1) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 function getState$1() {
   load$3();
-  return { entries: [...state$3.entries] };
+  return { entries: [...state$4.entries] };
 }
 function subscribe$1(listener) {
   listeners$1.add(listener);
@@ -1915,12 +1945,12 @@ function subscribe$1(listener) {
 function addEntry$1(url, title) {
   if (!url || url === "about:blank") return;
   load$3();
-  const last = state$3.entries[0];
+  const last = state$4.entries[0];
   if (last && last.url === url) {
     if (title && title !== last.title) {
       last.title = title;
-      save$1();
-      emit$1();
+      save$2();
+      emit$3();
     }
     return;
   }
@@ -1929,25 +1959,25 @@ function addEntry$1(url, title) {
     title: title || url,
     visitedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state$3.entries.unshift(entry);
-  if (state$3.entries.length > MAX_HISTORY_ENTRIES) {
-    state$3.entries = state$3.entries.slice(0, MAX_HISTORY_ENTRIES);
+  state$4.entries.unshift(entry);
+  if (state$4.entries.length > MAX_HISTORY_ENTRIES) {
+    state$4.entries = state$4.entries.slice(0, MAX_HISTORY_ENTRIES);
   }
-  save$1();
-  emit$1();
+  save$2();
+  emit$3();
 }
 function search(query, limit = 50) {
   load$3();
-  if (!query.trim()) return state$3.entries.slice(0, limit);
+  if (!query.trim()) return state$4.entries.slice(0, limit);
   const normalized = query.toLowerCase();
-  return state$3.entries.filter(
+  return state$4.entries.filter(
     (e) => e.url.toLowerCase().includes(normalized) || e.title.toLowerCase().includes(normalized)
   ).slice(0, limit);
 }
 function clearAll$1() {
-  state$3 = { entries: [] };
-  save$1();
-  emit$1();
+  state$4 = { entries: [] };
+  save$2();
+  emit$3();
 }
 function clearByTimeRange(timeRange) {
   load$3();
@@ -1957,12 +1987,12 @@ function clearByTimeRange(timeRange) {
   }
   const now = Date.now();
   const cutoff = new Date(now - timeRangeToMs(timeRange));
-  state$3.entries = state$3.entries.filter((entry) => {
+  state$4.entries = state$4.entries.filter((entry) => {
     const visitedAt = new Date(entry.visitedAt).getTime();
     return Number.isNaN(visitedAt) || visitedAt < cutoff.getTime();
   });
-  save$1();
-  emit$1();
+  save$2();
+  emit$3();
 }
 function timeRangeToMs(range) {
   switch (range) {
@@ -2016,7 +2046,7 @@ function importHistoryFromJson(content) {
     const parsed = JSON.parse(content);
     const entries = Array.isArray(parsed?.entries) ? parsed.entries : [];
     load$3();
-    const existingUrls = new Set(state$3.entries.map((e) => e.url));
+    const existingUrls = new Set(state$4.entries.map((e) => e.url));
     for (const entry of entries) {
       if (!entry?.url || typeof entry.url !== "string") {
         errors++;
@@ -2026,7 +2056,7 @@ function importHistoryFromJson(content) {
         skipped++;
         continue;
       }
-      state$3.entries.push({
+      state$4.entries.push({
         url: entry.url,
         title: typeof entry.title === "string" ? entry.title : entry.url,
         visitedAt: typeof entry.visitedAt === "string" ? entry.visitedAt : (/* @__PURE__ */ new Date()).toISOString()
@@ -2034,14 +2064,14 @@ function importHistoryFromJson(content) {
       existingUrls.add(entry.url);
       imported++;
     }
-    state$3.entries.sort(
+    state$4.entries.sort(
       (a, b) => new Date(b.visitedAt).getTime() - new Date(a.visitedAt).getTime()
     );
-    if (state$3.entries.length > MAX_HISTORY_ENTRIES) {
-      state$3.entries = state$3.entries.slice(0, MAX_HISTORY_ENTRIES);
+    if (state$4.entries.length > MAX_HISTORY_ENTRIES) {
+      state$4.entries = state$4.entries.slice(0, MAX_HISTORY_ENTRIES);
     }
-    save$1();
-    emit$1();
+    save$2();
+    emit$3();
   } catch {
     errors++;
   }
@@ -2052,7 +2082,7 @@ function importHistoryFromHtml(content) {
   let skipped = 0;
   let errors = 0;
   load$3();
-  const existingUrls = new Set(state$3.entries.map((e) => e.url));
+  const existingUrls = new Set(state$4.entries.map((e) => e.url));
   const hrefRegex = /<A\s+[^>]*HREF="([^"]+)"[^>]*>([^<]*)<\/A>/gi;
   let match;
   while ((match = hrefRegex.exec(content)) !== null) {
@@ -2063,7 +2093,7 @@ function importHistoryFromHtml(content) {
       else errors++;
       continue;
     }
-    state$3.entries.push({
+    state$4.entries.push({
       url,
       title,
       visitedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -2071,18 +2101,18 @@ function importHistoryFromHtml(content) {
     existingUrls.add(url);
     imported++;
   }
-  state$3.entries.sort(
+  state$4.entries.sort(
     (a, b) => new Date(b.visitedAt).getTime() - new Date(a.visitedAt).getTime()
   );
-  if (state$3.entries.length > MAX_HISTORY_ENTRIES) {
-    state$3.entries = state$3.entries.slice(0, MAX_HISTORY_ENTRIES);
+  if (state$4.entries.length > MAX_HISTORY_ENTRIES) {
+    state$4.entries = state$4.entries.slice(0, MAX_HISTORY_ENTRIES);
   }
-  save$1();
-  emit$1();
+  save$2();
+  emit$3();
   return { imported, skipped, errors };
 }
 function flushPersist$3() {
-  return persistence$4.flush();
+  return persistence$6.flush();
 }
 const MAX_CONSOLE_ENTRIES = 500;
 const MAX_NETWORK_ENTRIES = 200;
@@ -2093,6 +2123,8 @@ class DevToolsSession {
     this.tabId = tabId;
     this.wc = wc;
   }
+  tabId;
+  wc;
   attached = false;
   attachingPromise = null;
   consoleDomainEnabled = false;
@@ -2439,18 +2471,18 @@ class DevToolsSession {
     if (result?.__error) throw new Error(result.__error);
     return { type, origin, entries: result ?? {} };
   }
-  async setStorage(type, key, value) {
+  async setStorage(type, key2, value) {
     const storageType = type === "localStorage" ? "localStorage" : "sessionStorage";
     if (value === null) {
       await this.wc.executeJavaScript(
-        `window.${storageType}.removeItem(${JSON.stringify(key)})`
+        `window.${storageType}.removeItem(${JSON.stringify(key2)})`
       );
-      return `Removed "${key}" from ${type}`;
+      return `Removed "${key2}" from ${type}`;
     }
     await this.wc.executeJavaScript(
-      `window.${storageType}.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`
+      `window.${storageType}.setItem(${JSON.stringify(key2)}, ${JSON.stringify(value)})`
     );
-    return `Set ${type}["${key}"] = ${value.length > 80 ? value.slice(0, 77) + "..." : value}`;
+    return `Set ${type}["${key2}"] = ${value.length > 80 ? value.slice(0, 77) + "..." : value}`;
   }
   // ---------------------------------------------------------------------------
   // Performance
@@ -3015,23 +3047,23 @@ class TabManager {
   async saveTabAsPdf(id) {
     const tab = this.tabs.get(id);
     if (!tab) return null;
-    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+    const { canceled, filePath: filePath2 } = 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;
+    if (canceled || !filePath2) return null;
     const data = await tab.view.webContents.printToPDF({
       printBackground: true
     });
-    await fs.promises.writeFile(filePath, data);
-    return filePath;
+    await fs.promises.writeFile(filePath2, data);
+    return filePath2;
   }
   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({
+    const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
       title: "Save Page As",
       defaultPath: sanitizePageFilename(
         tab.state.title || "Vessel Page",
@@ -3041,9 +3073,9 @@ class TabManager {
         { name: format === "MHTML" ? "MHTML" : "HTML", extensions: [ext] }
       ]
     });
-    if (canceled || !filePath) return null;
-    await tab.view.webContents.savePage(filePath, format);
-    return filePath;
+    if (canceled || !filePath2) return null;
+    await tab.view.webContents.savePage(filePath2, format);
+    return filePath2;
   }
   getActiveTab() {
     return this.activeTabId ? this.tabs.get(this.activeTabId) : void 0;
@@ -3108,11 +3140,11 @@ class TabManager {
       note
     };
   }
-  restoreSession(snapshot) {
-    const tabs = snapshot.tabs.length > 0 ? snapshot.tabs : [{ id: "", url: "about:blank", title: "New Tab" }];
+  restoreSession(snapshot2) {
+    const tabs = snapshot2.tabs.length > 0 ? snapshot2.tabs : [{ id: "", url: "about:blank", title: "New Tab" }];
     const activeIndex = Math.max(
       0,
-      Math.min(snapshot.activeIndex, tabs.length - 1)
+      Math.min(snapshot2.activeIndex, tabs.length - 1)
     );
     this.destroyAllTabs();
     const restoredGroups = /* @__PURE__ */ new Map();
@@ -3127,11 +3159,11 @@ class TabManager {
         this.pinTab(ids[index]);
       }
       if (tab.groupName && ids[index]) {
-        const key = `${tab.groupName}|${tab.groupColor ?? "blue"}`;
-        let groupId = restoredGroups.get(key);
+        const key2 = `${tab.groupName}|${tab.groupColor ?? "blue"}`;
+        let groupId = restoredGroups.get(key2);
         if (!groupId) {
           groupId = crypto$1.randomUUID();
-          restoredGroups.set(key, groupId);
+          restoredGroups.set(key2, groupId);
           this.tabGroups.set(groupId, {
             id: groupId,
             name: tab.groupName,
@@ -3375,6 +3407,7 @@ const Channels = {
   SETTINGS_UPDATE: "settings:update",
   SETTINGS_HEALTH_GET: "settings:health:get",
   SETTINGS_HEALTH_UPDATE: "settings:health:update",
+  MCP_REGENERATE_TOKEN: "mcp:regenerate-token",
   // Bookmarks
   BOOKMARKS_GET: "bookmarks:get",
   BOOKMARKS_UPDATE: "bookmarks:update",
@@ -3456,6 +3489,11 @@ const Channels = {
   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",
   // Premium
   PREMIUM_GET_STATE: "premium:get-state",
   PREMIUM_ACTIVATION_START: "premium:activation-start",
@@ -3518,7 +3556,14 @@ const Channels = {
   CODEX_START_AUTH: "codex:start-auth",
   CODEX_CANCEL_AUTH: "codex:cancel-auth",
   CODEX_AUTH_STATUS: "codex:auth-status",
-  CODEX_DISCONNECT: "codex:disconnect"
+  CODEX_DISCONNECT: "codex:disconnect",
+  // Updates
+  UPDATES_CHECK: "updates:check",
+  UPDATES_OPEN_DOWNLOAD: "updates:open-download",
+  // Permissions
+  PERMISSIONS_GET: "permissions:get",
+  PERMISSIONS_CLEAR: "permissions:clear",
+  PERMISSIONS_CLEAR_ORIGIN: "permissions:clear-origin"
 };
 const MAX_DETAIL_ITEMS = 3;
 const MIN_BLOCK_SIMILARITY = 0.82;
@@ -3760,25 +3805,25 @@ function normalizeQueryValue(value) {
 }
 function serializeSnapshotParams(params) {
   return params.map(
-    ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+    ([key2, value]) => `${encodeURIComponent(key2)}=${encodeURIComponent(value)}`
   ).join("&");
 }
 function normalizeSnapshotParams(entries, pathname) {
   return Array.from(entries).filter(
-    ([key, value]) => shouldKeepSnapshotQueryParam(pathname, key, value)
-  ).map(([key, value]) => [
-    key.trim().toLowerCase(),
+    ([key2, value]) => shouldKeepSnapshotQueryParam(pathname, key2, value)
+  ).map(([key2, value]) => [
+    key2.trim().toLowerCase(),
     normalizeQueryValue(value)
   ]).sort(
     ([keyA, valueA], [keyB, valueB]) => keyA === keyB ? valueA.localeCompare(valueB) : keyA.localeCompare(keyB)
   );
 }
 function shouldKeepSnapshotQueryParam(pathname, rawKey, value) {
-  const key = rawKey.trim().toLowerCase();
-  if (!key || !value.trim()) return false;
-  if (key.startsWith("utm_")) return false;
-  if (TRACKING_QUERY_KEYS.has(key)) return false;
-  if (SNAPSHOT_QUERY_KEYS.has(key)) return true;
+  const key2 = rawKey.trim().toLowerCase();
+  if (!key2 || !value.trim()) return false;
+  if (key2.startsWith("utm_")) return false;
+  if (TRACKING_QUERY_KEYS.has(key2)) return false;
+  if (SNAPSHOT_QUERY_KEYS.has(key2)) return true;
   return /\/(search|results|browse|discover|find|category|tag|topics?|collections?|list)(\/|$)/i.test(
     pathname
   );
@@ -3863,15 +3908,15 @@ function load$2() {
       const next = /* @__PURE__ */ new Map();
       if (!Array.isArray(raw)) return next;
       for (const entry of raw) {
-        const snapshot = normalizeStoredSnapshot(entry);
-        if (snapshot) next.set(snapshot.url, snapshot);
+        const snapshot2 = normalizeStoredSnapshot(entry);
+        if (snapshot2) next.set(snapshot2.url, snapshot2);
       }
       return next;
     }
   });
   return snapshots;
 }
-const persistence$3 = createDebouncedJsonPersistence({
+const persistence$5 = createDebouncedJsonPersistence({
   debounceMs: SAVE_DEBOUNCE_MS$3,
   filePath: getFilePath$1(),
   getValue: () => snapshots,
@@ -3890,21 +3935,21 @@ function getSnapshot(normalizedUrl) {
 }
 function saveSnapshot(rawUrl, title, textContent, headings) {
   const s = load$2();
-  const key = normalizeUrl(rawUrl);
-  const snapshot = {
-    url: key,
+  const key2 = normalizeUrl(rawUrl);
+  const snapshot2 = {
+    url: key2,
     title,
     textContent: textContent.slice(0, MAX_TEXT_LENGTH),
     headings: headings.map((h) => `${"#".repeat(h.level)} ${h.text}`).join("\n"),
     capturedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  s.delete(key);
-  s.set(key, snapshot);
-  persistence$3.schedule();
-  return snapshot;
+  s.delete(key2);
+  s.set(key2, snapshot2);
+  persistence$5.schedule();
+  return snapshot2;
 }
 function flushPersist$2() {
-  return persistence$3.flush();
+  return persistence$5.flush();
 }
 const SEARCH_ENGINE_HOSTS = [
   "google.",
@@ -4219,11 +4264,11 @@ function sanitizeValue(value, depth = 0) {
   const record = asRecord(value);
   if (!record || depth >= MAX_DEPTH) return void 0;
   const objectValue = {};
-  for (const [key, entry] of Object.entries(record)) {
-    if (SKIP_FIELDS.has(key)) continue;
+  for (const [key2, entry] of Object.entries(record)) {
+    if (SKIP_FIELDS.has(key2)) continue;
     const normalized = sanitizeValue(entry, depth + 1);
     if (normalized !== void 0) {
-      objectValue[key] = normalized;
+      objectValue[key2] = normalized;
     }
   }
   return Object.keys(objectValue).length > 0 ? objectValue : void 0;
@@ -4231,10 +4276,10 @@ function sanitizeValue(value, depth = 0) {
 function buildNormalizedAttributes(record, types) {
   const attributes = {};
   const consumed = /* @__PURE__ */ new Set();
-  const consume = (key, value) => {
+  const consume = (key2, value) => {
     if (value === void 0) return;
-    consumed.add(key);
-    attributes[key] = value;
+    consumed.add(key2);
+    attributes[key2] = value;
   };
   if (types.includes("Recipe")) {
     consume("yield", sanitizeValue(record.recipeYield));
@@ -4278,14 +4323,14 @@ function buildNormalizedAttributes(record, types) {
       attributes.questions = questions;
     }
   }
-  for (const [key, value] of Object.entries(record)) {
-    if (SKIP_FIELDS.has(key) || consumed.has(key)) continue;
-    if (key === "name" || key === "headline" || key === "url" || key === "description") {
+  for (const [key2, value] of Object.entries(record)) {
+    if (SKIP_FIELDS.has(key2) || consumed.has(key2)) continue;
+    if (key2 === "name" || key2 === "headline" || key2 === "url" || key2 === "description") {
       continue;
     }
     const normalized = sanitizeValue(value);
     if (normalized !== void 0) {
-      attributes[key] = normalized;
+      attributes[key2] = normalized;
     }
   }
   return attributes;
@@ -4305,7 +4350,7 @@ function collectCandidateEntities(value, results = [], seen = /* @__PURE__ */ ne
   if (types.length > 0 || hasIdentity) {
     results.push(record);
   }
-  for (const key of [
+  for (const key2 of [
     "@graph",
     "mainEntity",
     "mainEntityOfPage",
@@ -4318,7 +4363,7 @@ function collectCandidateEntities(value, results = [], seen = /* @__PURE__ */ ne
     "acceptedAnswer",
     "suggestedAnswer"
   ]) {
-    collectCandidateEntities(record[key], results, seen);
+    collectCandidateEntities(record[key2], results, seen);
   }
   return results;
 }
@@ -4331,11 +4376,11 @@ function dedupeKey(entity) {
     JSON.stringify(entity.attributes)
   ].join("::");
 }
-function extractEntitiesFromRecords(records, source) {
-  if (!records || records.length === 0) return [];
+function extractEntitiesFromRecords(records2, source) {
+  if (!records2 || records2.length === 0) return [];
   const entities = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const candidate of collectCandidateEntities(records)) {
+  for (const candidate of collectCandidateEntities(records2)) {
     const types = getTypes(candidate);
     const name = firstString(candidate.name, candidate.headline);
     const url = firstString(candidate.url, candidate["@id"]);
@@ -4355,9 +4400,9 @@ function extractEntitiesFromRecords(records, source) {
     addIfPresent(entity, "name", name);
     addIfPresent(entity, "url", url);
     addIfPresent(entity, "description", description);
-    const key = dedupeKey(entity);
-    if (seen.has(key)) continue;
-    seen.add(key);
+    const key2 = dedupeKey(entity);
+    if (seen.has(key2)) continue;
+    seen.add(key2);
     entities.push(entity);
   }
   return entities.slice(0, 25);
@@ -4380,13 +4425,13 @@ function extractEntityFromMetaTags(metaTags, pageTitle, pageUrl) {
   const url = metaTags["og:url"] || metaTags.canonical || pageUrl;
   const types = getMetaType(metaTags);
   const attributes = {};
-  for (const [key, value] of Object.entries(metaTags)) {
-    if (key === "og:title" || key === "twitter:title" || key === "title" || key === "og:description" || key === "description" || key === "twitter:description" || key === "og:url" || key === "canonical") {
+  for (const [key2, value] of Object.entries(metaTags)) {
+    if (key2 === "og:title" || key2 === "twitter:title" || key2 === "title" || key2 === "og:description" || key2 === "description" || key2 === "twitter:description" || key2 === "og:url" || key2 === "canonical") {
       continue;
     }
     const normalized = sanitizeValue(value);
     if (normalized !== void 0) {
-      attributes[key] = normalized;
+      attributes[key2] = normalized;
     }
   }
   const entity = {
@@ -4439,9 +4484,9 @@ function extractStructuredDataFromJsonLd(jsonLd, microdata, rdfa, metaTags, page
   const deduped = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entity of candidates) {
-    const key = dedupeKey(entity);
-    if (seen.has(key)) continue;
-    seen.add(key);
+    const key2 = dedupeKey(entity);
+    if (seen.has(key2)) continue;
+    seen.add(key2);
     deduped.push(entity);
   }
   if (deduped.length > 0) {
@@ -4455,9 +4500,9 @@ function extractStructuredDataFromJsonLd(jsonLd, microdata, rdfa, metaTags, page
     pageHeadings
   );
 }
-function addIfPresent(target, key, value) {
+function addIfPresent(target, key2, value) {
   if (value !== void 0) {
-    target[key] = value;
+    target[key2] = value;
   }
 }
 function okResult(value) {
@@ -4714,6 +4759,7 @@ const POSTHOG_API_KEY = process.env.POSTHOG_API_KEY || "phc_OMeM3P5cxJwl14lOKxYa
 const POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
 const BATCH_INTERVAL_MS = 6e4;
 const MAX_BATCH_SIZE = 50;
+const SENSITIVE_PROPERTY_RE = /url|uri|query|prompt|content|text|token|secret|key|password|credential|email|domain/i;
 function getDeviceIdPath() {
   return path.join(electron.app.getPath("userData"), ".vessel-device-id");
 }
@@ -4742,12 +4788,22 @@ function isEnabled() {
   if (process.env.VESSEL_DEV === "1") return false;
   return loadSettings().telemetryEnabled !== false;
 }
+function sanitizeTelemetryProperties(properties) {
+  const safe = {};
+  for (const [key2, value] of Object.entries(properties)) {
+    if (SENSITIVE_PROPERTY_RE.test(key2)) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      safe[key2] = typeof value === "string" ? value.slice(0, 120) : value;
+    }
+  }
+  return safe;
+}
 function trackEvent(event, properties = {}) {
   if (!isEnabled()) return;
   eventQueue.push({
     event,
     properties: {
-      ...properties,
+      ...sanitizeTelemetryProperties(properties),
       premium_status: isPremium() ? "premium" : "free",
       app_version: electron.app.getVersion(),
       platform: process.platform,
@@ -4770,8 +4826,8 @@ function trackProviderConfigured(providerId) {
     provider_id: providerId
   });
 }
-function trackSettingChanged(key) {
-  trackEvent("setting_changed", { setting_key: key });
+function trackSettingChanged(key2) {
+  trackEvent("setting_changed", { setting_key: key2 });
 }
 function trackApprovalModeChanged(mode) {
   trackEvent("approval_mode_changed", { mode });
@@ -4782,8 +4838,8 @@ function trackBookmarkAction(action) {
 function trackVaultAction(action) {
   trackEvent("vault_action", { action });
 }
-function trackExtractionFailed(domain, reason) {
-  trackEvent("extraction_failed", { domain, reason });
+function trackExtractionFailed(_domain, reason) {
+  trackEvent("extraction_failed", { reason });
 }
 function trackPremiumFunnel(step, context) {
   trackEvent("premium_funnel", { step, ...context });
@@ -4953,10 +5009,10 @@ function mapFormFields(forms, interactiveElements) {
     }
   }
   for (const el of interactiveElements) {
-    const key = el.selector || el.name || el.label || String(el.index);
-    if (formFieldSelectors.has(key)) {
+    const key2 = el.selector || el.name || el.label || String(el.index);
+    if (formFieldSelectors.has(key2)) {
       fields.push({
-        name: el.name || el.label || key,
+        name: el.name || el.label || key2,
         type: mapInputType(el),
         label: el.label,
         required: el.required,
@@ -6195,12 +6251,12 @@ function loadHistory() {
       return next;
     }
   });
-  for (const [key, bursts] of loaded.entries()) {
-    recentPageDiffBursts.set(key, bursts);
+  for (const [key2, bursts] of loaded.entries()) {
+    recentPageDiffBursts.set(key2, bursts);
   }
   return recentPageDiffBursts;
 }
-const persistence$2 = createDebouncedJsonPersistence({
+const persistence$4 = createDebouncedJsonPersistence({
   debounceMs: SAVE_DEBOUNCE_MS$2,
   filePath: getHistoryFilePath(),
   getValue: () => recentPageDiffBursts,
@@ -6217,20 +6273,20 @@ function getLatestPageDiff(rawUrl) {
 }
 function getPageDiffBursts(rawUrl) {
   if (!shouldTrackSnapshotUrl(rawUrl)) return [];
-  const key = normalizeUrl(rawUrl);
+  const key2 = normalizeUrl(rawUrl);
   const history = loadHistory();
-  const bursts = prunePageDiffHistory(history.get(key) ?? [], {
+  const bursts = prunePageDiffHistory(history.get(key2) ?? [], {
     maxAgeDays: MAX_HISTORY_DAYS,
     maxItems: MAX_PERSISTED_DIFF_BURSTS
   });
-  const current = history.get(key) ?? [];
+  const current = history.get(key2) ?? [];
   if (current.length !== bursts.length) {
     if (bursts.length > 0) {
-      history.set(key, bursts);
+      history.set(key2, bursts);
     } else {
-      history.delete(key);
+      history.delete(key2);
     }
-    persistence$2.schedule();
+    persistence$4.schedule();
   }
   return bursts.slice().reverse();
 }
@@ -6238,20 +6294,20 @@ function summarizeDiffBurst(diff) {
   const items = diff.changes.slice(0, 2).map((change) => `${change.section}: ${change.summary}`);
   return items.join(" | ");
 }
-function enrichWithBurstHistory(key, diff) {
+function enrichWithBurstHistory(key2, diff) {
   const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextBurst = {
     detectedAt,
     summary: summarizeDiffBurst(diff)
   };
   const history = loadHistory();
-  const bursts = appendPageDiffHistoryItem(history.get(key) ?? [], nextBurst, {
+  const bursts = appendPageDiffHistoryItem(history.get(key2) ?? [], nextBurst, {
     maxAgeDays: MAX_HISTORY_DAYS,
     maxItems: MAX_PERSISTED_DIFF_BURSTS,
     now: Date.parse(detectedAt)
   });
-  history.set(key, bursts);
-  persistence$2.schedule();
+  history.set(key2, bursts);
+  persistence$4.schedule();
   const recentBursts = bursts.slice(-5);
   return {
     ...diff,
@@ -6264,8 +6320,8 @@ function enrichWithBurstHistory(key, diff) {
 async function capturePageSnapshot(url, wc, sendToRendererViews) {
   try {
     if (!shouldTrackSnapshotUrl(url)) return;
-    const key = normalizeUrl(url);
-    const oldSnap = getSnapshot(key);
+    const key2 = normalizeUrl(url);
+    const oldSnap = getSnapshot(key2);
     const content = await extractContent(wc);
     const textContent = content.content || "";
     const title = content.title || "";
@@ -6274,14 +6330,14 @@ async function capturePageSnapshot(url, wc, sendToRendererViews) {
     if (oldSnap) {
       const diff = diffSnapshots(oldSnap, textContent, title, currentHeadings);
       if (diff.hasChanges) {
-        const enrichedDiff = enrichWithBurstHistory(key, diff);
-        latestPageDiffs.set(key, enrichedDiff);
+        const enrichedDiff = enrichWithBurstHistory(key2, diff);
+        latestPageDiffs.set(key2, enrichedDiff);
         sendToRendererViews(Channels.PAGE_CHANGED, enrichedDiff);
       } else {
-        latestPageDiffs.delete(key);
+        latestPageDiffs.delete(key2);
       }
     } else {
-      latestPageDiffs.delete(key);
+      latestPageDiffs.delete(key2);
     }
     saveSnapshot(url, title, textContent, headings);
   } catch {
@@ -6333,19 +6389,19 @@ function schedulePageSnapshotCapture(wc, sendToRendererViews, delayMs = 0) {
 function enableClipboardShortcuts(view) {
   view.webContents.on("before-input-event", (event, input) => {
     if (!input.control && !input.meta) return;
-    const key = input.key.toLowerCase();
+    const key2 = input.key.toLowerCase();
     const wc = view.webContents;
     if (input.type === "keyDown") {
-      if (key === "c") {
+      if (key2 === "c") {
         wc.copy();
         event.preventDefault();
-      } else if (key === "v") {
+      } else if (key2 === "v") {
         wc.paste();
         event.preventDefault();
-      } else if (key === "x") {
+      } else if (key2 === "x") {
         wc.cut();
         event.preventDefault();
-      } else if (key === "a") {
+      } else if (key2 === "a") {
         wc.selectAll();
         event.preventDefault();
       }
@@ -6759,15 +6815,15 @@ function onRuntimeHealthChange(listener) {
   };
 }
 function getMcpStatus() {
-  return state$2.mcp.status;
+  return state$3.mcp.status;
 }
 function emitRuntimeHealthChange() {
-  const snapshot = getRuntimeHealth();
+  const snapshot2 = getRuntimeHealth();
   for (const listener of runtimeHealthChangeListeners) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
-const state$2 = {
+const state$3 = {
   userDataPath: "",
   settingsPath: "",
   startupIssues: [],
@@ -6780,43 +6836,43 @@ const state$2 = {
   }
 };
 function initializeRuntimeHealth(paths) {
-  state$2.userDataPath = paths.userDataPath;
-  state$2.settingsPath = paths.settingsPath;
-  state$2.mcp.configuredPort = paths.configuredPort;
-  state$2.mcp.activePort = null;
-  state$2.mcp.endpoint = null;
-  state$2.mcp.status = "stopped";
-  state$2.mcp.message = "MCP server has not started yet.";
+  state$3.userDataPath = paths.userDataPath;
+  state$3.settingsPath = paths.settingsPath;
+  state$3.mcp.configuredPort = paths.configuredPort;
+  state$3.mcp.activePort = null;
+  state$3.mcp.endpoint = null;
+  state$3.mcp.status = "stopped";
+  state$3.mcp.message = "MCP server has not started yet.";
   emitRuntimeHealthChange();
 }
 function setStartupIssues(issues) {
-  state$2.startupIssues = issues.map((issue) => ({ ...issue }));
+  state$3.startupIssues = issues.map((issue) => ({ ...issue }));
   emitRuntimeHealthChange();
 }
 function getRuntimeHealth() {
   return {
-    userDataPath: state$2.userDataPath,
-    settingsPath: state$2.settingsPath,
-    startupIssues: state$2.startupIssues.map((issue) => ({ ...issue })),
-    mcp: { ...state$2.mcp }
+    userDataPath: state$3.userDataPath,
+    settingsPath: state$3.settingsPath,
+    startupIssues: state$3.startupIssues.map((issue) => ({ ...issue })),
+    mcp: { ...state$3.mcp }
   };
 }
 function setMcpHealth(update) {
   if (typeof update.configuredPort === "number") {
-    state$2.mcp.configuredPort = update.configuredPort;
+    state$3.mcp.configuredPort = update.configuredPort;
   }
   if ("activePort" in update) {
-    state$2.mcp.activePort = update.activePort ?? null;
+    state$3.mcp.activePort = update.activePort ?? null;
   }
   if ("endpoint" in update) {
-    state$2.mcp.endpoint = update.endpoint ?? null;
+    state$3.mcp.endpoint = update.endpoint ?? null;
   }
-  const prevStatus = state$2.mcp.status;
-  state$2.mcp.status = update.status;
-  state$2.mcp.message = update.message;
-  if (prevStatus !== state$2.mcp.status) {
+  const prevStatus = state$3.mcp.status;
+  state$3.mcp.status = update.status;
+  state$3.mcp.message = update.message;
+  if (prevStatus !== state$3.mcp.status) {
     for (const listener of mcpStatusChangeListeners) {
-      listener(state$2.mcp.status);
+      listener(state$3.mcp.status);
     }
   }
   emitRuntimeHealthChange();
@@ -7728,8 +7784,8 @@ function scalarArgsForTool(name, scalar) {
   return null;
 }
 function firstStringArg(args, keys) {
-  for (const key of keys) {
-    const value = args[key];
+  for (const key2 of keys) {
+    const value = args[key2];
     if (typeof value === "string" && value.trim()) {
       return value.trim();
     }
@@ -8461,6 +8517,17 @@ class OpenAICompatProvider {
     this.abortController?.abort();
   }
 }
+async function openExternalAllowlisted(url, rule) {
+  const parsed = new URL(url);
+  const schemes = rule.schemes ?? ["https:"];
+  if (!schemes.includes(parsed.protocol)) {
+    throw new Error(`Blocked external URL scheme: ${parsed.protocol}`);
+  }
+  if (rule.hosts && !rule.hosts.includes(parsed.hostname)) {
+    throw new Error(`Blocked external URL host: ${parsed.hostname}`);
+  }
+  await electron.shell.openExternal(parsed.toString());
+}
 const logger$g = createLogger("CodexOAuth");
 const ISSUER = "https://auth.openai.com";
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
@@ -8797,7 +8864,7 @@ async function startCodexOAuth(onStatus) {
       activeFlow.port = port;
       const authUrl = buildAuthorizeUrl(port, pkce, state2);
       safeOnStatus("waiting");
-      electron.shell.openExternal(authUrl).catch((err) => {
+      openExternalAllowlisted(authUrl, { hosts: ["auth.openai.com"] }).catch((err) => {
         logger$g.warn("Failed to open browser, user will need the URL:", err);
       });
     }).catch(wrappedReject);
@@ -9020,8 +9087,8 @@ function extractLlamaCppCtxSize(payload) {
     const current = queue.shift();
     if (!current || typeof current !== "object" || visited.has(current)) continue;
     visited.add(current);
-    for (const [key, value] of Object.entries(current)) {
-      if (typeof value === "number" && Number.isFinite(value) && /^(n_ctx|ctx_size|context_size)$/i.test(key)) {
+    for (const [key2, value] of Object.entries(current)) {
+      if (typeof value === "number" && Number.isFinite(value) && /^(n_ctx|ctx_size|context_size)$/i.test(key2)) {
         return value;
       }
       if (value && typeof value === "object") {
@@ -9243,14 +9310,14 @@ function normalizeStoredRadioOption(option) {
 function dedupeCandidates(actions) {
   const seen = /* @__PURE__ */ new Set();
   return actions.filter((action) => {
-    const key = [
+    const key2 = [
       action.selector || "",
       action.label || "",
       action.role || "",
       action.labelSource || ""
     ].join("::");
-    if (seen.has(key)) return false;
-    seen.add(key);
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   });
 }
@@ -9495,11 +9562,11 @@ function getQuantityElements(page) {
   ];
   return elements.filter((el) => {
     if (!isQuantityLike(el)) return false;
-    const key = String(
+    const key2 = String(
       el.index ?? el.selector ?? `${el.type}|${el.name || ""}|${el.label || ""}|${el.value || ""}`
     );
-    if (seen.has(key)) return false;
-    seen.add(key);
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   });
 }
@@ -9541,9 +9608,9 @@ function getCartItemLinks(page) {
       return false;
     }
     if (blockedText.test(text) || blockedHref.test(href)) return false;
-    const key = `${normalizeComparable(text)}|${normalizeUrlForMatch(href) || href}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
+    const key2 = `${normalizeComparable(text)}|${normalizeUrlForMatch(href) || href}`;
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   }).slice(0, 12);
 }
@@ -9644,11 +9711,11 @@ function getPurchaseActionElements(page, options) {
     if (!isPurchaseActionElement(el)) return false;
     if (visibleOnly && !isVisibleToUser(el)) return false;
     if (el.blockedByOverlay) return false;
-    const key = String(
+    const key2 = String(
       el.index ?? el.selector ?? `${el.type}|${el.text || ""}|${el.label || ""}|${el.href || ""}`
     );
-    if (seen.has(key)) return false;
-    seen.add(key);
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   }).sort((a, b) => {
     const delta = purchaseActionPriority(a) - purchaseActionPriority(b);
@@ -9665,10 +9732,10 @@ function getOffscreenPurchaseActionElements(page) {
     )
   );
   return getPurchaseActionElements(page, { visibleOnly: false }).filter((el) => {
-    const key = String(
+    const key2 = String(
       el.index ?? el.selector ?? `${el.type}|${el.text || ""}|${el.label || ""}|${el.href || ""}`
     );
-    return !visibleKeys.has(key) && el.visible !== false;
+    return !visibleKeys.has(key2) && el.visible !== false;
   });
 }
 function getDialogFocusedElements(page) {
@@ -9934,7 +10001,7 @@ function formatStructuredValue(value, depth = 0) {
     const rendered = value.map((item) => formatStructuredValue(item, depth + 1)).filter(Boolean).slice(0, depth === 0 ? 8 : 5);
     return rendered.join(depth === 0 ? ", " : " | ");
   }
-  const entries = Object.entries(value).slice(0, 6).map(([key, entry]) => `${key}: ${formatStructuredValue(entry, depth + 1)}`).filter((entry) => !entry.endsWith(": "));
+  const entries = Object.entries(value).slice(0, 6).map(([key2, entry]) => `${key2}: ${formatStructuredValue(entry, depth + 1)}`).filter((entry) => !entry.endsWith(": "));
   return entries.join(", ");
 }
 function formatStructuredEntities(entities) {
@@ -9949,13 +10016,13 @@ function formatStructuredEntities(entities) {
     if (entity.url && entity.url !== entity.name) {
       lines.push(`  url: ${entity.url}`);
     }
-    for (const [key, value] of Object.entries(entity.attributes).slice(
+    for (const [key2, value] of Object.entries(entity.attributes).slice(
       0,
       8
     )) {
       const rendered = formatStructuredValue(value);
       if (rendered) {
-        lines.push(`  ${key}: ${rendered}`);
+        lines.push(`  ${key2}: ${rendered}`);
       }
     }
     return lines.join("\n");
@@ -10053,17 +10120,17 @@ function formatJsonLd(items) {
       }
       return String(val);
     };
-    for (const key of priorityFields) {
-      if (key in item) {
-        seen.add(key);
-        const rendered = renderValue(item[key]);
-        if (rendered) lines.push(`  ${key}: ${rendered}`);
+    for (const key2 of priorityFields) {
+      if (key2 in item) {
+        seen.add(key2);
+        const rendered = renderValue(item[key2]);
+        if (rendered) lines.push(`  ${key2}: ${rendered}`);
       }
     }
-    for (const [key, val] of Object.entries(item)) {
-      if (seen.has(key) || SKIP.has(key) || key === "@type") continue;
+    for (const [key2, val] of Object.entries(item)) {
+      if (seen.has(key2) || SKIP.has(key2) || key2 === "@type") continue;
       const rendered = renderValue(val);
-      if (rendered) lines.push(`  ${key}: ${rendered}`);
+      if (rendered) lines.push(`  ${key2}: ${rendered}`);
     }
     lines.push("");
   }
@@ -10198,9 +10265,9 @@ function getResultCandidates(page) {
   );
   const seen = /* @__PURE__ */ new Set();
   return scored.map(({ element }) => element).filter((element) => {
-    const key = `${normalizeComparable(element.text || "")}|${normalizeUrlForMatch(element.href) || ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
+    const key2 = `${normalizeComparable(element.text || "")}|${normalizeUrlForMatch(element.href) || ""}`;
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   });
 }
@@ -10997,9 +11064,9 @@ function getCompactPrimaryResultLinks(page, options) {
   })).filter(({ score }) => score >= (listingLike ? 5 : 7)).sort(
     (a, b) => b.score - a.score || (a.element.index ?? Number.MAX_SAFE_INTEGER) - (b.element.index ?? Number.MAX_SAFE_INTEGER)
   ).map(({ element }) => element).filter((element) => {
-    const key = `${normalizeComparable(element.text)}|${normalizeUrlForMatch(element.href) || ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
+    const key2 = `${normalizeComparable(element.text)}|${normalizeUrlForMatch(element.href) || ""}`;
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   }).slice(0, max);
 }
@@ -11045,9 +11112,9 @@ function formatElement(element) {
 function uniqueElements(elements) {
   const seen = /* @__PURE__ */ new Set();
   return elements.filter((element) => {
-    const key = `${element.index ?? ""}|${element.type}|${elementLabel(element)}|${element.href ?? ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
+    const key2 = `${element.index ?? ""}|${element.type}|${elementLabel(element)}|${element.href ?? ""}`;
+    if (seen.has(key2)) return false;
+    seen.add(key2);
     return true;
   });
 }
@@ -12370,12 +12437,12 @@ function normalizeAgentHints(value) {
     return void 0;
   }
   const normalized = Object.fromEntries(
-    Object.entries(value).map(([key, hint]) => [key.trim(), normalizeOptionalString(hint)]).filter((entry) => Boolean(entry[0] && entry[1]))
+    Object.entries(value).map(([key2, hint]) => [key2.trim(), normalizeOptionalString(hint)]).filter((entry) => Boolean(entry[0] && entry[1]))
   );
   return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
-function hasOwn(value, key) {
-  return Object.prototype.hasOwnProperty.call(value, key);
+function hasOwn(value, key2) {
+  return Object.prototype.hasOwnProperty.call(value, key2);
 }
 function normalizeBookmarkMetadata(input) {
   const normalized = {};
@@ -12413,7 +12480,7 @@ 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;
+let state$2 = null;
 const listeners = /* @__PURE__ */ new Set();
 function cloneState(current) {
   return {
@@ -12428,18 +12495,18 @@ function createPersistence() {
   return createDebouncedJsonPersistence({
     debounceMs: SAVE_DEBOUNCE_MS$1,
     filePath: getBookmarksPath(),
-    getValue: () => state$1,
+    getValue: () => state$2,
     logLabel: "bookmarks"
   });
 }
-let persistence$1 = null;
+let persistence$3 = null;
 function getPersistence() {
-  persistence$1 ??= createPersistence();
-  return persistence$1;
+  persistence$3 ??= createPersistence();
+  return persistence$3;
 }
 function load$1() {
-  if (state$1) return state$1;
-  state$1 = loadJsonFile({
+  if (state$2) return state$2;
+  state$2 = loadJsonFile({
     filePath: getBookmarksPath(),
     fallback: { folders: [], bookmarks: [] },
     parse: (raw) => {
@@ -12450,23 +12517,23 @@ function load$1() {
       };
     }
   });
-  return state$1;
+  return state$2;
 }
-function save() {
+function save$1() {
   getPersistence().schedule();
 }
 function assignDefinedBookmarkFields(bookmark, fields) {
   if (!fields) return;
-  for (const [key, value] of Object.entries(fields)) {
+  for (const [key2, value] of Object.entries(fields)) {
     if (value === void 0) continue;
-    Object.assign(bookmark, { [key]: value });
+    Object.assign(bookmark, { [key2]: value });
   }
 }
-function emit() {
-  if (!state$1) return;
-  const snapshot = cloneState(state$1);
+function emit$2() {
+  if (!state$2) return;
+  const snapshot2 = cloneState(state$2);
   for (const listener of listeners) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 function escapeBookmarkHtml(value) {
@@ -12483,7 +12550,7 @@ function getBookmarkDescription(bookmark) {
     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("; ")}` : ""
+    bookmark.agentHints && Object.keys(bookmark.agentHints).length > 0 ? `Agent hints: ${Object.entries(bookmark.agentHints).map(([key2, value]) => `${key2}: ${value}`).join("; ")}` : ""
   ].filter(Boolean);
   return lines.join("\n");
 }
@@ -12586,28 +12653,28 @@ function subscribe(listener) {
   };
 }
 function clearAll() {
-  state$1 = { folders: [], bookmarks: [] };
-  save();
-  emit();
+  state$2 = { folders: [], bookmarks: [] };
+  save$1();
+  emit$2();
 }
 function getBookmark(id) {
   load$1();
-  const bookmark = state$1.bookmarks.find((item) => item.id === id);
+  const bookmark = state$2.bookmarks.find((item) => item.id === id);
   return bookmark ? { ...bookmark } : null;
 }
 function getBookmarkByUrl(url) {
   load$1();
   const normalized = url.trim();
   if (!normalized) return null;
-  const bookmark = [...state$1.bookmarks].reverse().find((item) => item.url === normalized);
+  const bookmark = [...state$2.bookmarks].reverse().find((item) => item.url === normalized);
   return bookmark ? { ...bookmark } : null;
 }
 function getBookmarkByUrlInFolder(url, folderId) {
   load$1();
   const normalizedUrl = url.trim();
   if (!normalizedUrl) return null;
-  const targetFolderId = folderId && folderId !== UNSORTED_ID ? state$1.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
-  const bookmark = [...state$1.bookmarks].reverse().find(
+  const targetFolderId = folderId && folderId !== UNSORTED_ID ? state$2.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
+  const bookmark = [...state$2.bookmarks].reverse().find(
     (item) => item.url === normalizedUrl && item.folderId === targetFolderId
   );
   return bookmark ? { ...bookmark } : null;
@@ -12615,14 +12682,14 @@ function getBookmarkByUrlInFolder(url, folderId) {
 function getFolder(id) {
   load$1();
   if (!id || id === UNSORTED_ID) return null;
-  const folder = state$1.folders.find((item) => item.id === id);
+  const folder = state$2.folders.find((item) => item.id === id);
   return folder ? { ...folder } : null;
 }
 function findFolderByName(name) {
   load$1();
   const normalized = name.trim().toLowerCase();
   if (!normalized || normalized === "unsorted") return null;
-  const folder = state$1.folders.find(
+  const folder = state$2.folders.find(
     (item) => item.name.trim().toLowerCase() === normalized
   );
   return folder ? { ...folder } : null;
@@ -12630,7 +12697,7 @@ function findFolderByName(name) {
 function listFolderOverviews() {
   load$1();
   const counts = /* @__PURE__ */ new Map();
-  for (const bookmark of state$1.bookmarks) {
+  for (const bookmark of state$2.bookmarks) {
     counts.set(bookmark.folderId, (counts.get(bookmark.folderId) ?? 0) + 1);
   }
   return [
@@ -12639,7 +12706,7 @@ function listFolderOverviews() {
       name: "Unsorted",
       count: counts.get(UNSORTED_ID) ?? 0
     },
-    ...state$1.folders.map((folder) => ({
+    ...state$2.folders.map((folder) => ({
       id: folder.id,
       name: folder.name,
       summary: folder.summary,
@@ -12650,8 +12717,8 @@ function listFolderOverviews() {
 function searchBookmarks(query) {
   load$1();
   if (!query.trim()) return [];
-  return state$1.bookmarks.map((bookmark) => {
-    const folder = state$1.folders.find(
+  return state$2.bookmarks.map((bookmark) => {
+    const folder = state$2.folders.find(
       (item) => item.id === bookmark.folderId
     );
     const { matchedFields, score } = getBookmarkSearchMatch({
@@ -12689,9 +12756,9 @@ function createFolderWithSummary(name, summary) {
     summary: summary?.trim() || void 0,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  state$1.folders.push(folder);
-  save();
-  emit();
+  state$2.folders.push(folder);
+  save$1();
+  emit$2();
   return folder;
 }
 function ensureFolder(name, summary) {
@@ -12720,7 +12787,7 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
     throw new Error("Bookmark URL cannot be empty");
   }
   const normalizedTitle = title.trim() || normalizedUrl;
-  const targetId = folderId && folderId !== UNSORTED_ID ? state$1.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
+  const targetId = folderId && folderId !== UNSORTED_ID ? state$2.folders.find((f) => f.id === folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
   const duplicatePolicy = options?.onDuplicate ?? "ask";
   const existing = getBookmarkByUrlInFolder(normalizedUrl, targetId);
   if (existing) {
@@ -12731,7 +12798,7 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
       };
     }
     if (duplicatePolicy === "update") {
-      const bookmark2 = state$1.bookmarks.find((item) => item.id === existing.id);
+      const bookmark2 = state$2.bookmarks.find((item) => item.id === existing.id);
       if (!bookmark2) {
         return {
           status: "conflict",
@@ -12744,8 +12811,8 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
       }
       assignDefinedBookmarkFields(bookmark2, options?.extra);
       bookmark2.savedAt = (/* @__PURE__ */ new Date()).toISOString();
-      save();
-      emit();
+      save$1();
+      emit$2();
       return {
         status: "updated",
         bookmark: { ...bookmark2 }
@@ -12761,9 +12828,9 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
     savedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...options?.extra
   };
-  state$1.bookmarks.push(bookmark);
-  save();
-  emit();
+  state$2.bookmarks.push(bookmark);
+  save$1();
+  emit$2();
   return {
     status: "created",
     bookmark
@@ -12771,18 +12838,18 @@ function saveBookmarkWithPolicy(url, title, folderId, note, options) {
 }
 function removeBookmark(id) {
   load$1();
-  const before = state$1.bookmarks.length;
-  state$1.bookmarks = state$1.bookmarks.filter((b) => b.id !== id);
-  if (state$1.bookmarks.length !== before) {
-    save();
-    emit();
+  const before = state$2.bookmarks.length;
+  state$2.bookmarks = state$2.bookmarks.filter((b) => b.id !== id);
+  if (state$2.bookmarks.length !== before) {
+    save$1();
+    emit$2();
     return true;
   }
   return false;
 }
 function updateBookmark(id, updates) {
   load$1();
-  const bookmark = state$1.bookmarks.find((item) => item.id === id);
+  const bookmark = state$2.bookmarks.find((item) => item.id === id);
   if (!bookmark) return null;
   const metadataUpdates = normalizeBookmarkMetadataUpdate({
     intent: updates.intent,
@@ -12799,7 +12866,7 @@ function updateBookmark(id, updates) {
     bookmark.note = trimmed || void 0;
   }
   if (typeof updates.folderId === "string") {
-    bookmark.folderId = updates.folderId && updates.folderId !== UNSORTED_ID ? state$1.folders.find((item) => item.id === updates.folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
+    bookmark.folderId = updates.folderId && updates.folderId !== UNSORTED_ID ? state$2.folders.find((item) => item.id === updates.folderId)?.id ?? UNSORTED_ID : UNSORTED_ID;
   }
   if ("intent" in metadataUpdates) {
     bookmark.intent = metadataUpdates.intent;
@@ -12816,36 +12883,36 @@ function updateBookmark(id, updates) {
   if ("agentHints" in metadataUpdates) {
     bookmark.agentHints = metadataUpdates.agentHints;
   }
-  save();
-  emit();
+  save$1();
+  emit$2();
   return { ...bookmark };
 }
 function removeFolder(id, deleteContents = false) {
   load$1();
-  const exists = state$1.folders.some((f) => f.id === id);
+  const exists = state$2.folders.some((f) => f.id === id);
   if (!exists) return false;
   if (deleteContents) {
-    state$1.bookmarks = state$1.bookmarks.filter((b) => b.folderId !== id);
+    state$2.bookmarks = state$2.bookmarks.filter((b) => b.folderId !== id);
   } else {
-    state$1.bookmarks = state$1.bookmarks.map(
+    state$2.bookmarks = state$2.bookmarks.map(
       (b) => b.folderId === id ? { ...b, folderId: UNSORTED_ID } : b
     );
   }
-  state$1.folders = state$1.folders.filter((f) => f.id !== id);
-  save();
-  emit();
+  state$2.folders = state$2.folders.filter((f) => f.id !== id);
+  save$1();
+  emit$2();
   return true;
 }
 function renameFolder(id, newName, summary) {
   load$1();
-  const folder = state$1.folders.find((f) => f.id === id);
+  const folder = state$2.folders.find((f) => f.id === id);
   if (!folder) return null;
   const trimmed = newName.trim();
   if (!trimmed) return null;
   folder.name = trimmed;
   folder.summary = summary?.trim() || void 0;
-  save();
-  emit();
+  save$1();
+  emit$2();
   return { ...folder };
 }
 function flushPersist$1() {
@@ -12856,7 +12923,7 @@ function importBookmarksFromHtml(content) {
   let skipped = 0;
   let errors = 0;
   load$1();
-  const existingUrls = new Set(state$1.bookmarks.map((b) => b.url));
+  const existingUrls = new Set(state$2.bookmarks.map((b) => b.url));
   let currentFolderId = UNSORTED_ID;
   let currentFolderName = "Imported";
   const lines = content.split("\n");
@@ -12865,7 +12932,7 @@ function importBookmarksFromHtml(content) {
     const folderMatch = line.match(/<DT><H3[^>]*>([^<]+)<\/H3>/i);
     if (folderMatch) {
       currentFolderName = folderMatch[1].trim();
-      const existing = state$1.folders.find(
+      const existing = state$2.folders.find(
         (f) => f.name.toLowerCase() === currentFolderName.toLowerCase()
       );
       if (existing) {
@@ -12876,7 +12943,7 @@ function importBookmarksFromHtml(content) {
           name: currentFolderName,
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        state$1.folders.push(folder);
+        state$2.folders.push(folder);
         currentFolderId = folder.id;
       }
       continue;
@@ -12897,7 +12964,7 @@ function importBookmarksFromHtml(content) {
         else errors++;
         continue;
       }
-      state$1.bookmarks.push({
+      state$2.bookmarks.push({
         id: crypto$1.randomUUID(),
         url,
         title,
@@ -12909,8 +12976,8 @@ function importBookmarksFromHtml(content) {
     }
   }
   if (imported > 0) {
-    save();
-    emit();
+    save$1();
+    emit$2();
   }
   return { imported, skipped, errors };
 }
@@ -12923,14 +12990,14 @@ function importBookmarksFromJson(content) {
     const incomingFolders = Array.isArray(parsed?.folders) ? parsed.folders : [];
     const incomingBookmarks = Array.isArray(parsed?.bookmarks) ? parsed.bookmarks : [];
     load$1();
-    const existingUrls = new Set(state$1.bookmarks.map((b) => b.url));
+    const existingUrls = new Set(state$2.bookmarks.map((b) => b.url));
     const folderIdMap = /* @__PURE__ */ new Map();
     for (const folder of incomingFolders) {
       if (!folder?.id || !folder?.name) {
         errors++;
         continue;
       }
-      const existing = state$1.folders.find(
+      const existing = state$2.folders.find(
         (f) => f.name.toLowerCase() === folder.name.toLowerCase()
       );
       if (existing) {
@@ -12942,7 +13009,7 @@ function importBookmarksFromJson(content) {
           summary: folder.summary?.trim() || void 0,
           createdAt: folder.createdAt || (/* @__PURE__ */ new Date()).toISOString()
         };
-        state$1.folders.push(newFolder);
+        state$2.folders.push(newFolder);
         folderIdMap.set(folder.id, newFolder.id);
       }
     }
@@ -12956,7 +13023,7 @@ function importBookmarksFromJson(content) {
         continue;
       }
       const mappedFolderId = bookmark.folderId ? folderIdMap.get(bookmark.folderId) ?? UNSORTED_ID : UNSORTED_ID;
-      state$1.bookmarks.push({
+      state$2.bookmarks.push({
         id: crypto$1.randomUUID(),
         url: bookmark.url.trim(),
         title: typeof bookmark.title === "string" ? bookmark.title.trim() : bookmark.url,
@@ -12968,8 +13035,8 @@ function importBookmarksFromJson(content) {
       imported++;
     }
     if (imported > 0 || errors > 0) {
-      save();
-      emit();
+      save$1();
+      emit$2();
     }
   } catch {
     errors++;
@@ -12987,7 +13054,7 @@ async function captureLiveHighlightSnapshot(wc, savedHighlights = []) {
     savedHighlights.map((highlight) => normalizeText(highlight.text)).filter(Boolean)
   );
   try {
-    const snapshot = await wc.executeJavaScript(`(() => {
+    const snapshot2 = await wc.executeJavaScript(`(() => {
       const selection = window.getSelection?.()?.toString().trim() || "";
       const pageHighlights = Array.from(
         document.querySelectorAll("mark.__vessel-highlight-text[data-vessel-highlight]")
@@ -13009,36 +13076,36 @@ async function captureLiveHighlightSnapshot(wc, savedHighlights = []) {
       };
     })()`, true);
     const seen = /* @__PURE__ */ new Set();
-    const pageHighlights = (snapshot.pageHighlights ?? []).map((highlight) => ({
+    const pageHighlights = (snapshot2.pageHighlights ?? []).map((highlight) => ({
       text: normalizeText(highlight.text),
       color: highlight.color?.trim() || void 0
     })).filter((highlight) => highlight.text.length > 0).filter((highlight) => {
-      const key = `${highlight.text}\0${highlight.color ?? ""}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
+      const key2 = `${highlight.text}\0${highlight.color ?? ""}`;
+      if (seen.has(key2)) return false;
+      seen.add(key2);
       return true;
     }).map((highlight) => ({
       ...highlight,
       persisted: savedTexts.has(highlight.text)
     }));
-    const activeSelection = normalizeText(snapshot.activeSelection) || void 0;
+    const activeSelection = normalizeText(snapshot2.activeSelection) || void 0;
     return { activeSelection, pageHighlights };
   } catch {
     return { pageHighlights: [] };
   }
 }
-function formatLiveSelectionSection(snapshot) {
+function formatLiveSelectionSection(snapshot2) {
   const sections = [];
-  if (snapshot.activeSelection) {
-    const preview = snapshot.activeSelection.length > 400 ? `${snapshot.activeSelection.slice(0, 397)}...` : snapshot.activeSelection;
+  if (snapshot2.activeSelection) {
+    const preview = snapshot2.activeSelection.length > 400 ? `${snapshot2.activeSelection.slice(0, 397)}...` : snapshot2.activeSelection;
     sections.push(
       `## Active User Selection
 The user currently has this text selected on screen:
 - "${preview}"`
     );
   }
-  if (snapshot.pageHighlights.length > 0) {
-    const lines = snapshot.pageHighlights.map((highlight) => {
+  if (snapshot2.pageHighlights.length > 0) {
+    const lines = snapshot2.pageHighlights.map((highlight) => {
       const preview = highlight.text.length > 180 ? `${highlight.text.slice(0, 177)}...` : highlight.text;
       const details = [
         highlight.persisted ? "saved" : "visible only",
@@ -13364,17 +13431,17 @@ function sessionFileName(name) {
 function getSessionPath(name) {
   return path$1.join(ensureSessionsDir(), sessionFileName(name));
 }
-function writeSessionFile(filePath, data) {
+function writeSessionFile(filePath2, data) {
   fs$1.writeFileSync(
-    filePath,
+    filePath2,
     JSON.stringify({ version: SESSION_VERSION, ...data }, null, 2),
     { encoding: "utf-8", mode: 384 }
   );
-  fs$1.chmodSync(filePath, 384);
+  fs$1.chmodSync(filePath2, 384);
 }
-function readSessionFile(filePath) {
+function readSessionFile(filePath2) {
   try {
-    const raw = fs$1.readFileSync(filePath, "utf-8");
+    const raw = fs$1.readFileSync(filePath2, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.name !== "string") {
       return null;
@@ -13539,7 +13606,7 @@ async function saveNamedSession(tabManager, name) {
     const entries = await captureLocalStorageForOrigin(tabManager, origin);
     localStorage.push({ origin, entries });
   }
-  const snapshot = tabManager.snapshotSession(`Named session: ${normalizedName}`);
+  const snapshot2 = tabManager.snapshotSession(`Named session: ${normalizedName}`);
   const domains = [...new Set(cookies.map((cookie) => cookie.domain))].sort();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const data = {
@@ -13551,7 +13618,7 @@ async function saveNamedSession(tabManager, name) {
     domains,
     cookies,
     localStorage,
-    snapshot
+    snapshot: snapshot2
   };
   writeSessionFile(getSessionPath(normalizedName), data);
   return {
@@ -13595,9 +13662,9 @@ async function loadNamedSession(tabManager, name) {
   };
 }
 function deleteNamedSession(name) {
-  const filePath = getSessionPath(name);
-  if (!fs$1.existsSync(filePath)) return false;
-  fs$1.unlinkSync(filePath);
+  const filePath2 = getSessionPath(name);
+  if (!fs$1.existsSync(filePath2)) return false;
+  fs$1.unlinkSync(filePath2);
   return true;
 }
 function isInvalidTextTargetQuery(rawQuery) {
@@ -13906,8 +13973,8 @@ function compactSearchLikeResult(text) {
     return limitText(cleaned, 16, 1400);
   }
   const summary = cleaned.slice(0, markerIndex).trim();
-  const snapshot = cleaned.slice(markerIndex + marker.length).trim();
-  return [summary, compactReadPageResult(snapshot)].filter(Boolean).join("\n\n");
+  const snapshot2 = cleaned.slice(markerIndex + marker.length).trim();
+  return [summary, compactReadPageResult(snapshot2)].filter(Boolean).join("\n\n");
 }
 function compactCurrentTabResult(text) {
   try {
@@ -14956,7 +15023,7 @@ async function inspectElement(wc, selector, limit = 8) {
   return lines.join("\n");
 }
 async function getLocaleSnapshot(wc) {
-  const snapshot = await executePageScript(
+  const snapshot2 = await executePageScript(
     wc,
     `
     (function() {
@@ -14975,13 +15042,13 @@ async function getLocaleSnapshot(wc) {
       label: "locale snapshot"
     }
   );
-  if (!snapshot || snapshot === PAGE_SCRIPT_TIMEOUT || typeof snapshot !== "object") {
+  if (!snapshot2 || snapshot2 === PAGE_SCRIPT_TIMEOUT || typeof snapshot2 !== "object") {
     return null;
   }
   return {
-    lang: typeof snapshot.lang === "string" ? snapshot.lang.trim() : "",
-    url: typeof snapshot.url === "string" ? snapshot.url : wc.getURL(),
-    title: typeof snapshot.title === "string" ? snapshot.title : wc.getTitle()
+    lang: typeof snapshot2.lang === "string" ? snapshot2.lang.trim() : "",
+    url: typeof snapshot2.url === "string" ? snapshot2.url : wc.getURL(),
+    title: typeof snapshot2.title === "string" ? snapshot2.title : wc.getTitle()
   };
 }
 function primaryLanguageTag(value) {
@@ -14997,31 +15064,31 @@ function localeChanged(before, after) {
   const localeHint = /[?&](lang|locale|language|hl)=|\/(ja|jp|en|fr|de|es|it|ko|zh)(\/|$)/i;
   return before.url !== after.url && localeHint.test(after.url);
 }
-async function restoreLocaleSnapshot(wc, snapshot) {
-  if (!snapshot || wc.isDestroyed()) return;
+async function restoreLocaleSnapshot(wc, snapshot2) {
+  if (!snapshot2 || wc.isDestroyed()) return;
   try {
     if (typeof wc.canGoBack === "function" && wc.canGoBack()) {
       wc.goBack();
       await waitForLoad(wc, 3e3);
       const reverted = await getLocaleSnapshot(wc);
-      if (!localeChanged(snapshot, reverted)) {
+      if (!localeChanged(snapshot2, reverted)) {
         return;
       }
     }
   } catch (err) {
     logger$c.warn("Failed to restore locale via history navigation, trying URL reload fallback:", err);
   }
-  if (snapshot.url && snapshot.url !== wc.getURL()) {
+  if (snapshot2.url && snapshot2.url !== wc.getURL()) {
     try {
-      assertSafeURL(snapshot.url);
-      await wc.loadURL(snapshot.url);
+      assertSafeURL(snapshot2.url);
+      await wc.loadURL(snapshot2.url);
       await waitForLoad(wc, 3e3);
       return;
     } catch (err) {
       logger$c.warn("Failed to restore locale via safe URL load, trying page reload fallback:", err);
     }
   }
-  if (snapshot.url) {
+  if (snapshot2.url) {
     try {
       await wc.reload();
       await waitForLoad(wc, 3e3);
@@ -15054,9 +15121,9 @@ function isAddToCartText(text) {
 }
 function recordCartClick(url, text) {
   recentCartClicks.set(url, { text, ts: Date.now() });
-  for (const [key, entry] of recentCartClicks) {
+  for (const [key2, entry] of recentCartClicks) {
     if (Date.now() - entry.ts > CART_CLICK_COOLDOWN_MS) {
-      recentCartClicks.delete(key);
+      recentCartClicks.delete(key2);
     }
   }
 }
@@ -15103,9 +15170,9 @@ function normalizeCartProductKey(url) {
   }
 }
 function pruneCartAddedProducts(now = Date.now()) {
-  for (const [key, entry] of cartAddedProducts) {
+  for (const [key2, entry] of cartAddedProducts) {
     if (now - entry.ts > CART_ADDED_TTL_MS) {
-      cartAddedProducts.delete(key);
+      cartAddedProducts.delete(key2);
     }
   }
 }
@@ -15131,7 +15198,7 @@ function isProductAlreadyInCart(url) {
 function getCartAddedSummary(url) {
   pruneCartAddedProducts();
   const origin = cartOrigin(url);
-  const items = Array.from(cartAddedProducts.entries()).filter(([key]) => !origin || key.startsWith(`${origin}/`)).map(([_path, info]) => `- ${info.title}`).join("\n");
+  const items = Array.from(cartAddedProducts.entries()).filter(([key2]) => !origin || key2.startsWith(`${origin}/`)).map(([_path, info]) => `- ${info.title}`).join("\n");
   if (!items) return "";
   const count = items.split("\n").length;
   return `
@@ -16787,8 +16854,8 @@ async function submitForm(wc, args) {
   }
   return "Submitted form";
 }
-async function pressKeyDirect(wc, key, index, selector) {
-  return pressKey(wc, { key, index, selector });
+async function pressKeyDirect(wc, key2, index, selector) {
+  return pressKey(wc, { key: key2, index, selector });
 }
 async function submitFormDirect(wc, index, selector) {
   return submitForm(wc, { index, selector });
@@ -17154,8 +17221,8 @@ async function searchPage(wc, args) {
   return `Searched "${query}" (same page — results may have loaded dynamically)${await getPostSearchSummary(wc)}`;
 }
 async function pressKey(wc, args) {
-  const key = typeof args.key === "string" ? args.key.trim() : "";
-  if (!key) return "Error: No key provided";
+  const key2 = typeof args.key === "string" ? args.key.trim() : "";
+  if (!key2) return "Error: No key provided";
   const selector = await resolveSelector(wc, args.index, args.selector);
   const focusResult = await executePageScript(
     wc,
@@ -17193,16 +17260,16 @@ async function pressKey(wc, args) {
     return focusResult.error;
   }
   wc.focus();
-  const normalizedKey = key.length === 1 ? key : key[0].toUpperCase() + key.slice(1);
+  const normalizedKey = key2.length === 1 ? key2 : key2[0].toUpperCase() + key2.slice(1);
   const electronKeyCode = normalizedKey === "Enter" ? "Return" : normalizedKey === "ArrowUp" ? "Up" : normalizedKey === "ArrowDown" ? "Down" : normalizedKey === "ArrowLeft" ? "Left" : normalizedKey === "ArrowRight" ? "Right" : normalizedKey;
   wc.sendInputEvent({ type: "keyDown", keyCode: electronKeyCode });
-  if (key.length === 1) {
-    wc.sendInputEvent({ type: "char", keyCode: key });
+  if (key2.length === 1) {
+    wc.sendInputEvent({ type: "char", keyCode: key2 });
   }
   await sleep(16);
   wc.sendInputEvent({ type: "keyUp", keyCode: electronKeyCode });
   const label = "label" in focusResult && typeof focusResult.label === "string" ? focusResult.label : null;
-  return label ? `Pressed key: ${key} on ${label}` : `Pressed key: ${key}`;
+  return label ? `Pressed key: ${key2} on ${label}` : `Pressed key: ${key2}`;
 }
 async function getPostActionState$1(ctx, name) {
   const tab = ctx.tabManager.getActiveTab();
@@ -17612,8 +17679,8 @@ async function executeAction(name, args, ctx) {
           if (!wc) return "Error: No active tab";
           const beforeUrl = wc.getURL();
           const result2 = await pressKey(wc, args);
-          const key = typeof args.key === "string" ? args.key.trim() : "";
-          if (key === "Enter") {
+          const key2 = typeof args.key === "string" ? args.key.trim() : "";
+          if (key2 === "Enter") {
             await waitForPotentialNavigation(wc, beforeUrl, 3e3);
             const afterUrl = wc.getURL();
             if (afterUrl !== beforeUrl) {
@@ -18718,17 +18785,17 @@ function escapeYaml(value) {
 }
 function renderFrontmatter(data) {
   const lines = ["---"];
-  for (const [key, value] of Object.entries(data)) {
+  for (const [key2, value] of Object.entries(data)) {
     if (value == null) continue;
     if (Array.isArray(value)) {
       if (value.length === 0) continue;
-      lines.push(`${key}:`);
+      lines.push(`${key2}:`);
       for (const item of value) {
         lines.push(`  - ${escapeYaml(item)}`);
       }
       continue;
     }
-    lines.push(`${key}: ${escapeYaml(value)}`);
+    lines.push(`${key2}: ${escapeYaml(value)}`);
   }
   lines.push("---", "");
   return lines.join("\n");
@@ -18781,11 +18848,11 @@ function parseFrontmatter(content) {
     activeArrayKey = "";
     const separatorIndex = trimmed.indexOf(":");
     if (separatorIndex === -1) continue;
-    const key = trimmed.slice(0, separatorIndex).trim();
+    const key2 = trimmed.slice(0, separatorIndex).trim();
     const value = trimmed.slice(separatorIndex + 1).trim();
-    if (key === "title" && value) {
+    if (key2 === "title" && value) {
       result.title = value.replace(/^["']|["']$/g, "");
-    } else if (key === "tags") {
+    } else if (key2 === "tags") {
       activeArrayKey = "tags";
       if (value.startsWith("[") && value.endsWith("]")) {
         const inline = value.slice(1, -1).split(",").map((item) => item.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
@@ -18971,9 +19038,9 @@ function capturePageToVault({
   if (page.excerpt.trim()) {
     bodyLines.push("## Excerpt", "", page.excerpt.trim(), "");
   }
-  const snapshot = trimContent(page.content);
-  if (snapshot) {
-    bodyLines.push("## Page Snapshot", "", snapshot, "");
+  const snapshot2 = trimContent(page.content);
+  if (snapshot2) {
+    bodyLines.push("## Page Snapshot", "", snapshot2, "");
   }
   return writeMemoryNote({
     title: noteTitle,
@@ -19371,15 +19438,15 @@ Exception: ${result.exceptionDetails}`);
         value: zod.z.string().nullable().describe("Value to set, or null to remove the key")
       }
     },
-    async ({ type, key, value }) => {
+    async ({ type, key: key2, value }) => {
       return withDevToolsAction(
         runtime2,
         tabManager,
         "devtools_set_storage",
-        { type, key, value: value ? value.slice(0, 100) : null },
+        { type, key: key2, value: value ? value.slice(0, 100) : null },
         async () => {
           const session = getOrCreateSession(tabManager);
-          return session.setStorage(type, key, value);
+          return session.setStorage(type, key2, value);
         }
       );
     }
@@ -19398,8 +19465,8 @@ Exception: ${result.exceptionDetails}`);
         {},
         async () => {
           const session = getOrCreateSession(tabManager);
-          const snapshot = await session.getPerformanceSnapshot();
-          return JSON.stringify(snapshot, null, 2);
+          const snapshot2 = await session.getPerformanceSnapshot();
+          return JSON.stringify(snapshot2, null, 2);
         }
       );
     }
@@ -19471,11 +19538,12 @@ function getOrCreateEncryptionKey(keyFilename) {
     const encryptedKey = fs$1.readFileSync(keyPath);
     return Buffer.from(electron.safeStorage.decryptString(encryptedKey), "utf-8");
   }
-  const key = crypto$2.randomBytes(32);
+  const key2 = crypto$2.randomBytes(32);
   fs$1.mkdirSync(path$1.dirname(keyPath), { recursive: true });
-  const encrypted = electron.safeStorage.encryptString(key.toString("utf-8"));
+  const encrypted = electron.safeStorage.encryptString(key2.toString("utf-8"));
   fs$1.writeFileSync(keyPath, encrypted, { mode: 384 });
-  return key;
+  fs$1.chmodSync(keyPath, 384);
+  return key2;
 }
 function createEncryptDecrypt(keyFilename) {
   let cachedKey = null;
@@ -19484,9 +19552,9 @@ function createEncryptDecrypt(keyFilename) {
     return cachedKey;
   }
   function encrypt2(plaintext) {
-    const key = getKey();
+    const key2 = getKey();
     const iv = crypto$2.randomBytes(IV_LENGTH);
-    const cipher = crypto$2.createCipheriv(ALGORITHM, key, iv, {
+    const cipher = crypto$2.createCipheriv(ALGORITHM, key2, iv, {
       authTagLength: AUTH_TAG_LENGTH
     });
     const encrypted = Buffer.concat([
@@ -19497,11 +19565,11 @@ function createEncryptDecrypt(keyFilename) {
     return Buffer.concat([iv, authTag, encrypted]);
   }
   function decrypt2(data) {
-    const key = getKey();
+    const key2 = getKey();
     const iv = data.subarray(0, IV_LENGTH);
     const authTag = data.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
     const ciphertext = data.subarray(IV_LENGTH + AUTH_TAG_LENGTH);
-    const decipher = crypto$2.createDecipheriv(ALGORITHM, key, iv, {
+    const decipher = crypto$2.createDecipheriv(ALGORITHM, key2, iv, {
       authTagLength: AUTH_TAG_LENGTH
     });
     decipher.setAuthTag(authTag);
@@ -19548,15 +19616,21 @@ function createVaultIO(vaultFilename, encrypt2, decrypt2) {
   }
   return { loadVault: loadVault2, saveVault: saveVault2, resetCache };
 }
-function domainMatches(pattern, hostname) {
-  const p = pattern.toLowerCase().trim();
-  const h = hostname.toLowerCase().trim();
-  if (p === h) return true;
-  if (p.startsWith("*.")) {
-    const suffix = p.slice(2);
-    return h === suffix || h.endsWith("." + suffix);
+function normalizeCredentialHost(value) {
+  try {
+    const parsed = new URL(value.includes("://") ? value : `https://${value}`);
+    return parsed.hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    const normalized = value.toLowerCase().trim().replace(/^(https?:\/\/)?(www\.)?/, "").replace(/\/.*$/, "");
+    return normalized && !normalized.includes(" ") ? normalized : null;
   }
-  return false;
+}
+function domainMatches(pattern, hostname) {
+  const isWildcard = pattern.trim().startsWith("*.");
+  const p = normalizeCredentialHost(isWildcard ? pattern.slice(2) : pattern);
+  const h = normalizeCredentialHost(hostname);
+  if (!p || !h) return false;
+  return isWildcard ? h.endsWith("." + p) : p === h;
 }
 function generateTotpCode(secret) {
   const epoch = Math.floor(Date.now() / 1e3);
@@ -19627,12 +19701,8 @@ function listEntries$1() {
   return loadVault$1().map(({ password, totpSecret, ...rest }) => rest);
 }
 function findEntriesForDomain(url) {
-  let hostname;
-  try {
-    hostname = new URL(url).hostname;
-  } catch {
-    return [];
-  }
+  const hostname = normalizeCredentialHost(url);
+  if (!hostname) return [];
   return loadVault$1().filter((e) => domainMatches(e.domainPattern, hostname)).map(({ password, totpSecret, ...rest }) => rest);
 }
 function addEntry(entry) {
@@ -19755,12 +19825,7 @@ const auditLog = createAuditLog(
   AUDIT_MAX_ENTRIES
 );
 function extractDomain(url) {
-  try {
-    const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
-    return parsed.hostname.toLowerCase();
-  } catch {
-    return url.toLowerCase().replace(/^(https?:\/\/)?(www\.)?/, "").replace(/\/.*$/, "");
-  }
+  return normalizeCredentialHost(url) ?? "";
 }
 function listEntries() {
   return loadVault().map(({ password, totpSecret, ...rest }) => rest);
@@ -19938,13 +20003,14 @@ function getPersistentMcpAuthToken() {
 }
 function writeMcpAuthFile(endpoint, token) {
   try {
-    const filePath = getMcpAuthFilePath();
-    fs$1.mkdirSync(path$1.dirname(filePath), { recursive: true });
+    const filePath2 = getMcpAuthFilePath();
+    fs$1.mkdirSync(path$1.dirname(filePath2), { recursive: true });
     fs$1.writeFileSync(
-      filePath,
+      filePath2,
       JSON.stringify({ endpoint, token, pid: process.pid }, null, 2) + "\n",
       { mode: 384 }
     );
+    fs$1.chmodSync(filePath2, 384);
   } catch (err) {
     logger$9.warn("Failed to write auth file:", err);
   }
@@ -19959,10 +20025,10 @@ function clearMcpAuthFile() {
     return;
   }
   try {
-    const filePath = getMcpAuthFilePath();
-    fs$1.mkdirSync(path$1.dirname(filePath), { recursive: true });
+    const filePath2 = getMcpAuthFilePath();
+    fs$1.mkdirSync(path$1.dirname(filePath2), { recursive: true });
     fs$1.writeFileSync(
-      filePath,
+      filePath2,
       JSON.stringify(
         { endpoint: "", token: existingToken, pid: null },
         null,
@@ -19970,10 +20036,18 @@ function clearMcpAuthFile() {
       ) + "\n",
       { mode: 384 }
     );
+    fs$1.chmodSync(filePath2, 384);
   } catch (err) {
     logger$9.warn("Failed to clear auth file:", err);
   }
 }
+function regenerateMcpAuthToken() {
+  const endpoint = getRuntimeHealth().mcp.endpoint;
+  if (!httpServer || !endpoint) return null;
+  mcpAuthToken = crypto$2.randomBytes(32).toString("hex");
+  writeMcpAuthFile(endpoint, mcpAuthToken);
+  return { endpoint };
+}
 function asTextResponse(text) {
   return { content: [{ type: "text", text }] };
 }
@@ -19999,6 +20073,11 @@ function asPromptResponse(text) {
 function isDangerousMcpAction(name) {
   return name === "close_tab" || isDangerousAction(name);
 }
+function requiresExplicitMcpApproval(name, args) {
+  if (name === "delete_session" || name === "close_tab" || name === "load_session") return true;
+  if (name === "remove_folder" && args.delete_contents === true) return true;
+  return false;
+}
 function getActiveTabSummary(tabManager) {
   const activeTab = tabManager.getActiveTab();
   const activeTabId = tabManager.getActiveTabId();
@@ -20087,6 +20166,7 @@ async function withAction(runtime2, tabManager, name, args, executor) {
       args,
       tabId: tabManager.getActiveTabId(),
       dangerous: isDangerousMcpAction(name),
+      requiresApproval: requiresExplicitMcpApproval(name, args),
       executor
     });
     const stateInfo = await getPostActionState(tabManager, name);
@@ -20978,19 +21058,19 @@ ${buildScopedContext(pageContent, mode)}`;
         selector: zod.z.string().optional().describe("CSS selector to focus first")
       }
     },
-    async ({ key, index, selector }) => {
+    async ({ key: key2, index, selector }) => {
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       return withAction(
         runtime2,
         tabManager,
         "press_key",
-        { key, index, selector },
+        { key: key2, index, selector },
         async () => {
           const wc = tab.view.webContents;
           const beforeUrl = wc.getURL();
-          const result = await pressKeyDirect(wc, key, index, selector);
-          if (key === "Enter") {
+          const result = await pressKeyDirect(wc, key2, index, selector);
+          if (key2 === "Enter") {
             await waitForPotentialNavigation$1(wc, beforeUrl, 3e3);
             const afterUrl = wc.getURL();
             if (afterUrl !== beforeUrl) {
@@ -21456,7 +21536,7 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
         )
       }
     },
-    async ({ index, selector, text, label, durationMs, persist, color }) => {
+    async ({ index, selector, text, label, durationMs, persist: persist2, color }) => {
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       const normalizedText = normalizeLooseString(text);
@@ -21470,7 +21550,7 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
           text: normalizedText,
           label,
           durationMs,
-          persist,
+          persist: persist2,
           color
         },
         async () => {
@@ -21484,7 +21564,7 @@ To analyze visually, call vision_analyze with image_url="${screenshotPath}"`
             durationMs,
             color
           );
-          if (persist && !durationMs && !result.startsWith("Error") && !result.includes("not found")) {
+          if (persist2 && !durationMs && !result.startsWith("Error") && !result.includes("not found")) {
             const url = normalizeUrl$1(wc.getURL());
             addHighlight(
               url,
@@ -24110,6 +24190,16 @@ function registerScheduleHandlers(windowState, runtime2, sendToAll) {
     return true;
   });
 }
+const trustedIpcSenderIds = /* @__PURE__ */ new Set();
+function registerTrustedIpcSender(wc) {
+  trustedIpcSenderIds.add(wc.id);
+  wc.once("destroyed", () => trustedIpcSenderIds.delete(wc.id));
+}
+function assertTrustedIpcSender(event) {
+  if (!trustedIpcSenderIds.has(event.sender.id)) {
+    throw new Error("Blocked IPC from untrusted renderer");
+  }
+}
 function assertString(value, name) {
   if (typeof value !== "string") throw new Error(`${name} must be a string`);
 }
@@ -24149,7 +24239,7 @@ const PROFILE_FIELDS = [
   "postalCode",
   "country"
 ];
-let state = null;
+let state$1 = null;
 function getFilePath() {
   return path.join(electron.app.getPath("userData"), "vessel-autofill.json");
 }
@@ -24174,8 +24264,8 @@ function normalizeStoredProfile(value) {
   return profile;
 }
 function load() {
-  if (state) return state;
-  state = loadJsonFile({
+  if (state$1) return state$1;
+  state$1 = loadJsonFile({
     filePath: getFilePath(),
     fallback: getDefaultState(),
     secure: true,
@@ -24186,12 +24276,12 @@ function load() {
       };
     }
   });
-  return state;
+  return state$1;
 }
-const persistence = createDebouncedJsonPersistence({
+const persistence$2 = createDebouncedJsonPersistence({
   debounceMs: SAVE_DEBOUNCE_MS,
   filePath: getFilePath(),
-  getValue: () => state,
+  getValue: () => state$1,
   logLabel: "autofill",
   secure: true
 });
@@ -24211,7 +24301,7 @@ function addProfile(input) {
     updatedAt: now
   };
   s.profiles.push(profile);
-  persistence.schedule();
+  persistence$2.schedule();
   return profile;
 }
 function updateProfile(id, updates) {
@@ -24223,7 +24313,7 @@ function updateProfile(id, updates) {
     ...updates,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  persistence.schedule();
+  persistence$2.schedule();
   return s.profiles[idx];
 }
 function deleteProfile(id) {
@@ -24231,11 +24321,11 @@ function deleteProfile(id) {
   const len = s.profiles.length;
   s.profiles = s.profiles.filter((p) => p.id !== id);
   if (s.profiles.length === len) return false;
-  persistence.schedule();
+  persistence$2.schedule();
   return true;
 }
 function flushPersist() {
-  return persistence.flush();
+  return persistence$2.flush();
 }
 const AUTOCOMPLETE_MAP = {
   "given-name": "firstName",
@@ -24364,12 +24454,12 @@ function matchField(el, profile) {
   if (inputType === "hidden" || inputType === "submit" || inputType === "button" || inputType === "file" || inputType === "image") return null;
   if (inputType === "password" || inputType === "checkbox" || inputType === "radio") return null;
   if (el.autocomplete) {
-    const key = el.autocomplete.replace(/section-\w+\s+/, "").replace(/^shipping\s+|^billing\s+/, "");
-    if (key === "name" || key === "additional-name") {
+    const key2 = el.autocomplete.replace(/section-\w+\s+/, "").replace(/^shipping\s+|^billing\s+/, "");
+    if (key2 === "name" || key2 === "additional-name") {
       const fullName = getFullName(profile);
       if (fullName) return mk(fullName, 100, "autocomplete", "fullName");
     }
-    const pk = AUTOCOMPLETE_MAP[key];
+    const pk = AUTOCOMPLETE_MAP[key2];
     if (pk && profile[pk]) return mk(profile[pk], 100, "autocomplete", pk);
   }
   if (INPUT_TYPE_MAP[inputType]) {
@@ -24525,13 +24615,26 @@ function registerAutofillHandlers(windowState) {
   });
 }
 function registerPageDiffHandlers(windowState, sendToRendererViews) {
-  electron.ipcMain.handle(Channels.PAGE_DIFF_GET, () => {
+  const pageEventBuckets = /* @__PURE__ */ new Map();
+  const allowPageEvent = (webContentsId) => {
+    const now = Date.now();
+    const bucket = pageEventBuckets.get(webContentsId);
+    if (!bucket || bucket.resetAt <= now) {
+      pageEventBuckets.set(webContentsId, { count: 1, resetAt: now + 1e3 });
+      return true;
+    }
+    bucket.count += 1;
+    return bucket.count <= 20;
+  };
+  electron.ipcMain.handle(Channels.PAGE_DIFF_GET, (event) => {
+    assertTrustedIpcSender(event);
     const activeTab = windowState.tabManager.getActiveTab();
     const wc = activeTab?.view.webContents;
     if (!wc) return null;
     return getLatestPageDiff(wc.getURL());
   });
-  electron.ipcMain.handle(Channels.PAGE_DIFF_HISTORY, () => {
+  electron.ipcMain.handle(Channels.PAGE_DIFF_HISTORY, (event) => {
+    assertTrustedIpcSender(event);
     try {
       if (!isPremiumActiveState(getPremiumState())) {
         return { error: "Premium required" };
@@ -24547,21 +24650,25 @@ function registerPageDiffHandlers(windowState, sendToRendererViews) {
   electron.ipcMain.on(Channels.PAGE_DIFF_ACTIVITY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
+    if (!allowPageEvent(wc.id)) return;
     notePageMutationActivity(wc, sendToRendererViews);
   });
   electron.ipcMain.on(Channels.PAGE_DIFF_DIRTY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
+    if (!allowPageEvent(wc.id)) return;
     schedulePageSnapshotCapture(wc, sendToRendererViews);
   });
 }
 function registerVaultHandlers() {
-  electron.ipcMain.handle(Channels.VAULT_LIST, () => {
+  electron.ipcMain.handle(Channels.VAULT_LIST, (event) => {
+    assertTrustedIpcSender(event);
     return listEntries$1();
   });
   electron.ipcMain.handle(
     Channels.VAULT_ADD,
-    (_, entry) => {
+    (event, entry) => {
+      assertTrustedIpcSender(event);
       if (!entry || typeof entry !== "object") {
         throw new Error("Invalid vault entry");
       }
@@ -24586,7 +24693,8 @@ function registerVaultHandlers() {
   );
   electron.ipcMain.handle(
     Channels.VAULT_UPDATE,
-    (_, id, updates) => {
+    (event, id, updates) => {
+      assertTrustedIpcSender(event);
       assertString(id, "id");
       if (!updates || typeof updates !== "object") {
         throw new Error("Invalid updates");
@@ -24594,12 +24702,14 @@ function registerVaultHandlers() {
       return updateEntry$1(id, updates) !== null;
     }
   );
-  electron.ipcMain.handle(Channels.VAULT_REMOVE, (_, id) => {
+  electron.ipcMain.handle(Channels.VAULT_REMOVE, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     trackVaultAction("credential_removed");
     return removeEntry$1(id);
   });
-  electron.ipcMain.handle(Channels.VAULT_AUDIT_LOG, (_, limit) => {
+  electron.ipcMain.handle(Channels.VAULT_AUDIT_LOG, (event, limit) => {
+    assertTrustedIpcSender(event);
     return readAuditLog$1(limit);
   });
 }
@@ -24618,17 +24728,20 @@ function normalizeTags(value) {
   return tags.length > 0 ? tags : void 0;
 }
 function registerHumanVaultHandlers() {
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_LIST, (_, domain) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_LIST, (event, domain) => {
+    assertTrustedIpcSender(event);
     if (domain !== void 0) assertString(domain, "domain");
     return domain ? findForDomain(domain) : listEntries();
   });
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_GET, (_, id) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_GET, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     return getEntrySafe(id);
   });
   electron.ipcMain.handle(
     Channels.HUMAN_VAULT_SAVE,
-    (_, input) => {
+    (event, input) => {
+      assertTrustedIpcSender(event);
       if (!input || typeof input !== "object") {
         throw new Error("Invalid credential entry");
       }
@@ -24658,7 +24771,8 @@ function registerHumanVaultHandlers() {
   );
   electron.ipcMain.handle(
     Channels.HUMAN_VAULT_UPDATE,
-    (_, id, updates) => {
+    (event, id, updates) => {
+      assertTrustedIpcSender(event);
       assertString(id, "id");
       if (!updates || typeof updates !== "object") {
         throw new Error("Invalid updates");
@@ -24700,26 +24814,31 @@ function registerHumanVaultHandlers() {
       return safe;
     }
   );
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_REMOVE, (_, id) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_REMOVE, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     return removeEntry(id);
   });
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_AUDIT_LOG, (_, limit) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_AUDIT_LOG, (event, limit) => {
+    assertTrustedIpcSender(event);
     return readAuditLog(limit);
   });
 }
 function registerWindowControlHandlers(mainWindow) {
-  electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, () => {
+  electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, (event) => {
+    assertTrustedIpcSender(event);
     mainWindow.minimize();
   });
-  electron.ipcMain.handle(Channels.WINDOW_MAXIMIZE, () => {
+  electron.ipcMain.handle(Channels.WINDOW_MAXIMIZE, (event) => {
+    assertTrustedIpcSender(event);
     if (mainWindow.isMaximized()) {
       mainWindow.unmaximize();
     } else {
       mainWindow.maximize();
     }
   });
-  electron.ipcMain.handle(Channels.WINDOW_CLOSE, () => {
+  electron.ipcMain.handle(Channels.WINDOW_CLOSE, (event) => {
+    assertTrustedIpcSender(event);
     mainWindow.close();
   });
 }
@@ -24857,6 +24976,102 @@ function installAdBlockingForSession(ses, tabManager) {
     callback(getAdBlockDecision(details));
   });
 }
+const filePath$1 = () => path$1.join(electron.app.getPath("userData"), "vessel-downloads.json");
+const EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".appimage",
+  ".bat",
+  ".cmd",
+  ".command",
+  ".desktop",
+  ".exe",
+  ".msi",
+  ".ps1",
+  ".scr",
+  ".sh"
+]);
+function hasMisleadingDoubleExtension(filename) {
+  return /\.(pdf|docx?|xlsx?|pptx?|png|jpe?g|gif|txt|zip)\.(exe|msi|bat|cmd|ps1|sh|scr|appimage)$/i.test(filename);
+}
+function isExecutableDownload(savePath) {
+  return EXECUTABLE_EXTENSIONS.has(path$1.extname(savePath).toLowerCase());
+}
+function executableWarningDetail(item) {
+  return [
+    "This file can run code on your computer. Only open it if you trust the source.",
+    item.url ? `Source: ${item.url}` : null,
+    item.mimeType ? `Type: ${item.mimeType}` : null,
+    hasMisleadingDoubleExtension(item.filename) ? "Warning: this filename uses a misleading double extension." : null
+  ].filter(Boolean).join("\n");
+}
+function parse(raw) {
+  if (!raw || typeof raw !== "object") return { items: [] };
+  const items = Array.isArray(raw.items) ? raw.items : [];
+  return { items };
+}
+let state = loadJsonFile({ filePath: filePath$1(), fallback: { items: [] }, parse });
+const persistence$1 = createDebouncedJsonPersistence({
+  debounceMs: 250,
+  filePath: filePath$1(),
+  getValue: () => state,
+  logLabel: "downloads"
+});
+let broadcaster$1 = null;
+function persist() {
+  state.items = state.items.slice(0, 200);
+  persistence$1.schedule();
+}
+function emit$1() {
+  broadcaster$1?.(Channels.DOWNLOADS_UPDATE, listDownloads());
+}
+function setDownloadBroadcaster(fn) {
+  broadcaster$1 = fn;
+}
+function listDownloads() {
+  return state.items.map((item) => ({ ...item }));
+}
+function upsertDownload(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = state.items.find((item) => item.savePath === input.savePath);
+  if (existing) {
+    Object.assign(existing, input, { updatedAt: now });
+    persist();
+    emit$1();
+    return existing;
+  }
+  const record = { id: crypto$2.randomUUID(), ...input, startedAt: now, updatedAt: now };
+  state.items = [record, ...state.items];
+  persist();
+  emit$1();
+  return record;
+}
+function clearDownloads() {
+  state.items = [];
+  persist();
+  emit$1();
+}
+async function openDownload(id) {
+  const item = state.items.find((d) => d.id === id);
+  if (!item || item.state !== "completed" || !fs$1.existsSync(item.savePath)) return false;
+  if (isExecutableDownload(item.savePath)) {
+    const result = electron.dialog.showMessageBoxSync({
+      type: "warning",
+      buttons: ["Cancel", "Open Anyway"],
+      defaultId: 0,
+      cancelId: 0,
+      title: "Open executable download?",
+      message: `Open ${item.filename}?`,
+      detail: executableWarningDetail(item)
+    });
+    if (result !== 1) return false;
+  }
+  return await electron.shell.openPath(item.savePath) === "";
+}
+async function showDownloadInFolder(id) {
+  const item = state.items.find((d) => d.id === id);
+  if (!item || !fs$1.existsSync(item.savePath)) return false;
+  electron.shell.showItemInFolder(item.savePath);
+  return true;
+}
 const defaultDownloadViews = /* @__PURE__ */ new Set();
 let defaultDownloadHandlerInstalled = false;
 function resolveDownloadPath(downloadDir, filename) {
@@ -24899,21 +25114,26 @@ function installDownloadHandlerForSession(targetSession, chromeView) {
     const info = {
       filename,
       savePath,
+      url: item.getURL(),
+      mimeType: typeof item.getMimeType === "function" ? item.getMimeType() : void 0,
       totalBytes: item.getTotalBytes(),
       receivedBytes: 0,
       state: "progressing"
     };
-    send(Channels.DOWNLOAD_STARTED, info);
+    const record = upsertDownload(info);
+    send(Channels.DOWNLOAD_STARTED, { ...info, id: record.id, startedAt: record.startedAt, updatedAt: record.updatedAt });
     item.on("updated", (_event2, state2) => {
       info.receivedBytes = item.getReceivedBytes();
       info.totalBytes = item.getTotalBytes();
       info.state = state2 === "progressing" ? "progressing" : "interrupted";
-      send(Channels.DOWNLOAD_PROGRESS, info);
+      const record2 = upsertDownload(info);
+      send(Channels.DOWNLOAD_PROGRESS, { ...info, id: record2.id, startedAt: record2.startedAt, updatedAt: record2.updatedAt });
     });
     item.once("done", (_event2, state2) => {
       info.receivedBytes = item.getReceivedBytes();
       info.state = state2 === "completed" ? "completed" : "cancelled";
-      send(Channels.DOWNLOAD_DONE, info);
+      const record2 = upsertDownload(info);
+      send(Channels.DOWNLOAD_DONE, { ...info, id: record2.id, startedAt: record2.startedAt, updatedAt: record2.updatedAt });
     });
   });
 }
@@ -24943,9 +25163,9 @@ function loadRenderers(chromeView, sidebarView, devtoolsPanelView) {
   const sidebarUrl = rendererUrlFor("sidebar");
   const devtoolsUrl = rendererUrlFor("devtools");
   if (chromeUrl && sidebarUrl && devtoolsUrl) {
-    chromeView.webContents.loadURL(chromeUrl);
-    sidebarView.webContents.loadURL(sidebarUrl);
-    devtoolsPanelView.webContents.loadURL(devtoolsUrl);
+    void loadTrustedAppURL(chromeView.webContents, chromeUrl);
+    void loadTrustedAppURL(sidebarView.webContents, sidebarUrl);
+    void loadTrustedAppURL(devtoolsPanelView.webContents, devtoolsUrl);
   } else {
     const rendererFile = resolveRendererFile();
     chromeView.webContents.loadFile(rendererFile, {
@@ -25171,7 +25391,7 @@ function loadPrivateRenderer(chromeView) {
     const url = new URL(devUrl);
     url.searchParams.set("view", "chrome");
     url.searchParams.set("private", "1");
-    chromeView.webContents.loadURL(url.toString());
+    void loadTrustedAppURL(chromeView.webContents, url.toString());
   } else {
     chromeView.webContents.loadFile(resolveRendererFile(), {
       query: { view: "chrome", private: "1" }
@@ -25406,7 +25626,7 @@ function loadSecondaryRenderer(chromeView) {
     const url = new URL(devUrl);
     url.searchParams.set("view", "chrome");
     url.searchParams.set("secondary", "1");
-    chromeView.webContents.loadURL(url.toString());
+    void loadTrustedAppURL(chromeView.webContents, url.toString());
   } else {
     chromeView.webContents.loadFile(resolveRendererFile(), {
       query: { view: "chrome", secondary: "1" }
@@ -25626,63 +25846,67 @@ function registerBookmarkHandlers() {
   });
   electron.ipcMain.handle(
     Channels.BOOKMARKS_EXPORT_HTML,
-    async (_, options) => {
-      const { canceled, filePath } = await electron.dialog.showSaveDialog({
+    async (event, options) => {
+      assertTrustedIpcSender(event);
+      const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
         title: "Export Bookmarks",
         defaultPath: "vessel-bookmarks.html",
         filters: [{ name: "HTML Bookmarks", extensions: ["html"] }]
       });
-      if (canceled || !filePath) return null;
+      if (canceled || !filePath2) return null;
       const content = exportBookmarksHtml({
         includeNotes: options?.includeNotes ?? false
       });
-      await fs.promises.writeFile(filePath, content, "utf-8");
+      await fs.promises.writeFile(filePath2, content, "utf-8");
       trackBookmarkAction("export");
       return {
-        filePath,
+        filePath: filePath2,
         count: getState().bookmarks.length
       };
     }
   );
-  electron.ipcMain.handle(Channels.BOOKMARKS_EXPORT_JSON, async () => {
-    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+  electron.ipcMain.handle(Channels.BOOKMARKS_EXPORT_JSON, async (event) => {
+    assertTrustedIpcSender(event);
+    const { canceled, filePath: filePath2 } = 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;
+    if (canceled || !filePath2) return null;
     const content = exportBookmarksJson();
-    await fs.promises.writeFile(filePath, content, "utf-8");
+    await fs.promises.writeFile(filePath2, content, "utf-8");
     trackBookmarkAction("export");
     return {
-      filePath,
+      filePath: filePath2,
       count: getState().bookmarks.length
     };
   });
   electron.ipcMain.handle(
     Channels.FOLDER_EXPORT_HTML,
-    async (_, folderId, options) => {
+    async (event, folderId, options) => {
+      assertTrustedIpcSender(event);
       const folder = getFolder(folderId);
       if (!folder) return null;
-      const { canceled, filePath } = await electron.dialog.showSaveDialog({
+      const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
         title: `Export ${folder.name}`,
         defaultPath: `vessel-bookmarks-${getSafeBookmarkExportName(folder.name)}.html`,
         filters: [{ name: "HTML Bookmarks", extensions: ["html"] }]
       });
-      if (canceled || !filePath) return null;
+      if (canceled || !filePath2) return null;
       const result = exportBookmarkFolderHtml(folderId, {
         includeNotes: options?.includeNotes ?? true
       });
       if (!result) return null;
-      await fs.promises.writeFile(filePath, result.content, "utf-8");
+      await fs.promises.writeFile(filePath2, result.content, "utf-8");
       trackBookmarkAction("export");
       return {
-        filePath,
+        filePath: filePath2,
         count: result.count
       };
     }
   );
-  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_HTML, async () => {
+  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_HTML, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePaths } = await electron.dialog.showOpenDialog({
       title: "Import Bookmarks",
       filters: [
@@ -25695,7 +25919,8 @@ function registerBookmarkHandlers() {
     trackBookmarkAction("import");
     return importBookmarksFromHtml(content);
   });
-  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_JSON, async () => {
+  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_JSON, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePaths } = await electron.dialog.showOpenDialog({
       title: "Import Bookmarks",
       filters: [
@@ -25726,32 +25951,36 @@ function registerHistoryHandlers() {
   electron.ipcMain.handle(Channels.HISTORY_SEARCH, (_, query) => {
     return search(query);
   });
-  electron.ipcMain.handle(Channels.HISTORY_CLEAR, () => {
+  electron.ipcMain.handle(Channels.HISTORY_CLEAR, (event) => {
+    assertTrustedIpcSender(event);
     clearAll$1();
   });
-  electron.ipcMain.handle(Channels.HISTORY_EXPORT_HTML, async () => {
-    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+  electron.ipcMain.handle(Channels.HISTORY_EXPORT_HTML, async (event) => {
+    assertTrustedIpcSender(event);
+    const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
       title: "Export History",
       defaultPath: "vessel-history.html",
       filters: [{ name: "HTML", extensions: ["html"] }]
     });
-    if (canceled || !filePath) return null;
+    if (canceled || !filePath2) return null;
     const content = exportHistoryHtml();
-    await fs.promises.writeFile(filePath, content, "utf-8");
-    return { filePath, count: getState$1().entries.length };
+    await fs.promises.writeFile(filePath2, content, "utf-8");
+    return { filePath: filePath2, count: getState$1().entries.length };
   });
-  electron.ipcMain.handle(Channels.HISTORY_EXPORT_JSON, async () => {
-    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+  electron.ipcMain.handle(Channels.HISTORY_EXPORT_JSON, async (event) => {
+    assertTrustedIpcSender(event);
+    const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
       title: "Export History",
       defaultPath: "vessel-history.json",
       filters: [{ name: "JSON", extensions: ["json"] }]
     });
-    if (canceled || !filePath) return null;
+    if (canceled || !filePath2) return null;
     const content = exportHistoryJson();
-    await fs.promises.writeFile(filePath, content, "utf-8");
-    return { filePath, count: getState$1().entries.length };
+    await fs.promises.writeFile(filePath2, content, "utf-8");
+    return { filePath: filePath2, count: getState$1().entries.length };
   });
-  electron.ipcMain.handle(Channels.HISTORY_IMPORT, async () => {
+  electron.ipcMain.handle(Channels.HISTORY_IMPORT, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePaths } = await electron.dialog.showOpenDialog({
       title: "Import History",
       filters: [
@@ -25760,9 +25989,9 @@ function registerHistoryHandlers() {
       properties: ["openFile"]
     });
     if (canceled || filePaths.length === 0) return null;
-    const filePath = filePaths[0];
-    const content = await fs.promises.readFile(filePath, "utf-8");
-    const result = filePath.endsWith(".json") ? importHistoryFromJson(content) : importHistoryFromHtml(content);
+    const filePath2 = filePaths[0];
+    const content = await fs.promises.readFile(filePath2, "utf-8");
+    const result = filePath2.endsWith(".json") ? importHistoryFromJson(content) : importHistoryFromHtml(content);
     return result;
   });
 }
@@ -25962,7 +26191,8 @@ function buildCertificateDetailsHtml(state2) {
 </html>`;
 }
 function registerSecurityHandlers(tabManager) {
-  electron.ipcMain.handle(Channels.SECURITY_SHOW_DETAILS, async (_, state2) => {
+  electron.ipcMain.handle(Channels.SECURITY_SHOW_DETAILS, async (event, state2) => {
+    assertTrustedIpcSender(event);
     const domain = (() => {
       try {
         return new URL(state2.url).hostname || state2.url;
@@ -25983,13 +26213,15 @@ function registerSecurityHandlers(tabManager) {
         spellcheck: false
       }
     });
-    void win.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(content)}`);
+    void loadInternalDataURL(win.webContents, `data:text/html;charset=utf-8,${encodeURIComponent(content)}`);
   });
-  electron.ipcMain.handle(Channels.SECURITY_PROCEED_ANYWAY, (_, tabId) => {
+  electron.ipcMain.handle(Channels.SECURITY_PROCEED_ANYWAY, (event, tabId) => {
+    assertTrustedIpcSender(event);
     assertString(tabId, "tabId");
     tabManager.proceedAnyway(tabId);
   });
-  electron.ipcMain.handle(Channels.SECURITY_GO_BACK_TO_SAFETY, (_, tabId) => {
+  electron.ipcMain.handle(Channels.SECURITY_GO_BACK_TO_SAFETY, (event, tabId) => {
+    assertTrustedIpcSender(event);
     assertString(tabId, "tabId");
     tabManager.goBackToSafety(tabId);
   });
@@ -25997,6 +26229,7 @@ function registerSecurityHandlers(tabManager) {
 const logger$5 = createLogger("CodexIPC");
 function registerCodexHandlers() {
   electron.ipcMain.handle(Channels.CODEX_START_AUTH, async (event) => {
+    assertTrustedIpcSender(event);
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) {
       return {
@@ -26027,15 +26260,190 @@ function registerCodexHandlers() {
       };
     }
   });
-  electron.ipcMain.handle(Channels.CODEX_CANCEL_AUTH, () => {
+  electron.ipcMain.handle(Channels.CODEX_CANCEL_AUTH, (event) => {
+    assertTrustedIpcSender(event);
     cancelCodexOAuth();
     return { ok: true };
   });
-  electron.ipcMain.handle(Channels.CODEX_DISCONNECT, () => {
+  electron.ipcMain.handle(Channels.CODEX_DISCONNECT, (event) => {
+    assertTrustedIpcSender(event);
     clearStoredCodexTokens();
     return { ok: true };
   });
 }
+const filePath = () => path$1.join(electron.app.getPath("userData"), "vessel-permissions.json");
+const ALLOWED_PERMISSION_TYPES = /* @__PURE__ */ new Set([
+  "clipboard-read",
+  "fullscreen",
+  "geolocation",
+  "media",
+  "midiSysex",
+  "notifications",
+  "pointerLock"
+]);
+function parseOrigin(value) {
+  try {
+    const origin = new URL(value).origin;
+    return origin === "null" ? null : origin;
+  } catch {
+    return null;
+  }
+}
+function isPermissionRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.origin === "string" && parseOrigin(record.origin) === record.origin && typeof record.permission === "string" && ALLOWED_PERMISSION_TYPES.has(record.permission) && (record.decision === "allow" || record.decision === "deny") && typeof record.updatedAt === "string";
+}
+let records = loadJsonFile({
+  filePath: filePath(),
+  fallback: [],
+  parse: (raw) => Array.isArray(raw) ? raw.filter(isPermissionRecord) : []
+});
+const persistence = createDebouncedJsonPersistence({ debounceMs: 250, filePath: filePath(), getValue: () => records, logLabel: "permissions" });
+const sessionDecisions = /* @__PURE__ */ new Map();
+let broadcaster = null;
+function key(origin, permission) {
+  return `${origin}
+${permission}`;
+}
+function snapshot() {
+  return records.map((record) => ({ ...record }));
+}
+function emit() {
+  broadcaster?.(Channels.PERMISSIONS_GET, snapshot());
+}
+function save(origin, permission, decision) {
+  const k = key(origin, permission);
+  const existing = records.find((r) => key(r.origin, r.permission) === k);
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing) Object.assign(existing, { decision, updatedAt });
+  else records.unshift({ origin, permission, decision, updatedAt });
+  persistence.schedule();
+  emit();
+}
+function listPermissions() {
+  return snapshot();
+}
+function clearPermissions() {
+  records = [];
+  sessionDecisions.clear();
+  persistence.schedule();
+  emit();
+}
+function clearPermissionsForOrigin(origin) {
+  if (!parseOrigin(origin)) return;
+  records = records.filter((record) => record.origin !== origin);
+  for (const storedKey of sessionDecisions.keys()) {
+    if (storedKey.startsWith(`${origin}
+`)) sessionDecisions.delete(storedKey);
+  }
+  persistence.schedule();
+  emit();
+}
+function setPermissionBroadcaster(fn) {
+  broadcaster = fn;
+}
+function installPermissionHandler() {
+  electron.session.defaultSession.setPermissionRequestHandler((webContents, permission, callback, details) => {
+    if (!ALLOWED_PERMISSION_TYPES.has(permission)) {
+      callback(false);
+      return;
+    }
+    const origin = parseOrigin(details.requestingUrl || webContents.getURL());
+    if (!origin) {
+      callback(false);
+      return;
+    }
+    const k = key(origin, permission);
+    const existing = records.find((r) => r.origin === origin && r.permission === permission);
+    if (existing) {
+      callback(existing.decision === "allow");
+      return;
+    }
+    const sessionDecision = sessionDecisions.get(k);
+    if (sessionDecision) {
+      callback(sessionDecision === "allow");
+      return;
+    }
+    const result = electron.dialog.showMessageBoxSync({
+      type: "question",
+      buttons: ["Deny", "Allow Once", "Allow Until Quit", "Always Allow"],
+      defaultId: 0,
+      cancelId: 0,
+      title: "Site permission request",
+      message: `${origin} wants to use ${permission}`,
+      detail: "Temporary choices are safer for camera, microphone, location, and clipboard access. Persistent choices can be cleared in Settings > Privacy."
+    });
+    if (result === 1) {
+      callback(true);
+      return;
+    }
+    if (result === 2) {
+      sessionDecisions.set(k, "allow");
+      callback(true);
+      return;
+    }
+    if (result === 3) {
+      save(origin, permission, "allow");
+      callback(true);
+      return;
+    }
+    save(origin, permission, "deny");
+    callback(false);
+  });
+}
+const GITHUB_LATEST_RELEASE_API_URL = "https://api.github.com/repos/unmodeled-tyler/quanta-vessel-browser/releases/latest";
+const RELEASES_URL = "https://github.com/unmodeled-tyler/quanta-vessel-browser/releases/latest";
+function normalizeVersion(version) {
+  return version.replace(/^v/i, "").split(/[.-]/).slice(0, 3).map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function compareVersions(a, b) {
+  const av = normalizeVersion(a);
+  const bv = normalizeVersion(b);
+  for (let i = 0; i < 3; i += 1) {
+    if ((av[i] ?? 0) > (bv[i] ?? 0)) return 1;
+    if ((av[i] ?? 0) < (bv[i] ?? 0)) return -1;
+  }
+  return 0;
+}
+async function checkForUpdates() {
+  const currentVersion = electron.app.getVersion();
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const response = await fetch(GITHUB_LATEST_RELEASE_API_URL, {
+      headers: { accept: "application/vnd.github+json", "user-agent": `Vessel/${currentVersion}` }
+    });
+    if (!response.ok) {
+      throw new Error(`GitHub Releases responded with ${response.status}`);
+    }
+    const body = await response.json();
+    const latestVersion = typeof body.tag_name === "string" ? body.tag_name : null;
+    if (!latestVersion) throw new Error("GitHub release response did not include a tag name");
+    const releaseUrl = typeof body.html_url === "string" && body.html_url.startsWith("https://github.com/") ? body.html_url : RELEASES_URL;
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: compareVersions(latestVersion, currentVersion) > 0,
+      checkedAt,
+      releaseUrl
+    };
+  } catch (error) {
+    return {
+      currentVersion,
+      latestVersion: null,
+      updateAvailable: false,
+      checkedAt,
+      releaseUrl: RELEASES_URL,
+      error: error instanceof Error ? error.message : "Update check failed"
+    };
+  }
+}
+async function openUpdateDownload() {
+  await openExternalAllowlisted(RELEASES_URL, { hosts: ["github.com"] });
+}
 let activeChatProvider = null;
 const logger$4 = createLogger("IPC");
 const VALID_APPROVAL_MODES = ["auto", "confirm-dangerous", "manual"];
@@ -26069,10 +26477,18 @@ async function togglePictureInPicture(tabManager) {
 }
 function registerIpcHandlers(windowState, runtime2) {
   const { tabManager, chromeView, sidebarView, devtoolsPanelView, mainWindow } = windowState;
-  electron.ipcMain.handle(Channels.OPEN_PRIVATE_WINDOW, () => {
+  registerTrustedIpcSender(chromeView.webContents);
+  registerTrustedIpcSender(sidebarView.webContents);
+  registerTrustedIpcSender(devtoolsPanelView.webContents);
+  const requireTrusted = (event) => {
+    assertTrustedIpcSender(event);
+  };
+  electron.ipcMain.handle(Channels.OPEN_PRIVATE_WINDOW, (event) => {
+    requireTrusted(event);
     createPrivateWindow();
   });
-  electron.ipcMain.handle(Channels.OPEN_NEW_WINDOW, () => {
+  electron.ipcMain.handle(Channels.OPEN_NEW_WINDOW, (event) => {
+    requireTrusted(event);
     createSecondaryWindow();
   });
   electron.ipcMain.handle(Channels.IS_PRIVATE_MODE, () => false);
@@ -26344,14 +26760,15 @@ function registerIpcHandlers(windowState, runtime2) {
       const originalUrl = activeTab.readerOriginalUrl;
       activeTab.setReaderMode(false);
       if (originalUrl) {
-        activeTab.view.webContents.loadURL(originalUrl);
+        void loadPermittedNavigationURL(activeTab.view.webContents, originalUrl);
       }
     } else {
       const originalUrl = activeTab.state.url;
       const content = await extractContent(activeTab.view.webContents);
       const html = generateReaderHTML(content);
       activeTab.setReaderMode(true, originalUrl);
-      activeTab.view.webContents.loadURL(
+      void loadInternalDataURL(
+        activeTab.view.webContents,
         `data:text/html;charset=utf-8,${encodeURIComponent(html)}`
       );
     }
@@ -26433,18 +26850,23 @@ function registerIpcHandlers(windowState, runtime2) {
     return getRendererSettings();
   });
   electron.ipcMain.handle(Channels.SETTINGS_HEALTH_GET, () => getRuntimeHealth());
-  electron.ipcMain.handle(Channels.SETTINGS_SET, async (_, key, value) => {
-    assertString(key, "key");
-    if (!SETTABLE_KEYS.has(key)) {
-      throw new Error(`Unknown setting key: ${key}`);
+  electron.ipcMain.handle(Channels.MCP_REGENERATE_TOKEN, (event) => {
+    requireTrusted(event);
+    return regenerateMcpAuthToken();
+  });
+  electron.ipcMain.handle(Channels.SETTINGS_SET, async (event, key2, value) => {
+    requireTrusted(event);
+    assertString(key2, "key");
+    if (!SETTABLE_KEYS.has(key2)) {
+      throw new Error(`Unknown setting key: ${key2}`);
     }
-    const settingsKey = key;
+    const settingsKey = key2;
     const updatedSettings = setSetting(settingsKey, value);
-    trackSettingChanged(key);
-    if (key === "approvalMode") {
+    trackSettingChanged(key2);
+    if (key2 === "approvalMode") {
       runtime2.setApprovalMode(value);
     }
-    if (key === "mcpPort") {
+    if (key2 === "mcpPort") {
       await stopMcpServer();
       await startMcpServer(tabManager, runtime2, updatedSettings.mcpPort);
     }
@@ -26453,11 +26875,18 @@ function registerIpcHandlers(windowState, runtime2) {
     return rendererSettings;
   });
   electron.ipcMain.handle(Channels.AGENT_RUNTIME_GET, () => runtime2.getState());
-  electron.ipcMain.handle(Channels.AGENT_PAUSE, () => runtime2.pause());
-  electron.ipcMain.handle(Channels.AGENT_RESUME, () => runtime2.resume());
+  electron.ipcMain.handle(Channels.AGENT_PAUSE, (event) => {
+    requireTrusted(event);
+    return runtime2.pause();
+  });
+  electron.ipcMain.handle(Channels.AGENT_RESUME, (event) => {
+    requireTrusted(event);
+    return runtime2.resume();
+  });
   electron.ipcMain.handle(
     Channels.AGENT_SET_APPROVAL_MODE,
-    (_, mode) => {
+    (event, mode) => {
+      requireTrusted(event);
       assertString(mode, "mode");
       if (!VALID_APPROVAL_MODES.includes(mode)) {
         throw new Error(`Invalid approval mode: ${mode}`);
@@ -26469,7 +26898,10 @@ function registerIpcHandlers(windowState, runtime2) {
   );
   electron.ipcMain.handle(
     Channels.AGENT_APPROVAL_RESOLVE,
-    (_, approvalId, approved) => runtime2.resolveApproval(approvalId, approved)
+    (event, approvalId, approved) => {
+      requireTrusted(event);
+      return runtime2.resolveApproval(approvalId, approved);
+    }
   );
   electron.ipcMain.handle(
     Channels.AGENT_CHECKPOINT_CREATE,
@@ -26493,7 +26925,10 @@ function registerIpcHandlers(windowState, runtime2) {
   );
   electron.ipcMain.handle(
     Channels.AGENT_SESSION_RESTORE,
-    (_, snapshot) => runtime2.restoreSession(snapshot)
+    (event, snapshot2) => {
+      requireTrusted(event);
+      return runtime2.restoreSession(snapshot2);
+    }
   );
   registerBookmarkHandlers();
   electron.ipcMain.handle(Channels.HIGHLIGHT_CAPTURE, async () => {
@@ -26613,17 +27048,20 @@ function registerIpcHandlers(windowState, runtime2) {
   electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, () => {
     return getInstalledKits();
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async () => {
+  electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async (event) => {
+    requireTrusted(event);
     return await installKitFromFile();
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (_event, id) => {
+  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     return uninstallKit(id, getScheduledKitIds());
   });
   registerScheduleHandlers(windowState, runtime2, sendToRendererViews);
   registerAutofillHandlers(windowState);
   registerPageDiffHandlers(windowState, sendToRendererViews);
-  electron.ipcMain.handle(Channels.CLEAR_BROWSING_DATA, async (_, options) => {
+  electron.ipcMain.handle(Channels.CLEAR_BROWSING_DATA, async (event, options) => {
+    requireTrusted(event);
     const { cache, cookies, history, localStorage: clearLs, timeRange } = options;
     if (cache) {
       await electron.session.defaultSession.clearCache();
@@ -26638,6 +27076,38 @@ function registerIpcHandlers(windowState, runtime2) {
       clearByTimeRange(timeRange);
     }
   });
+  setDownloadBroadcaster(sendToRendererViews);
+  setPermissionBroadcaster(sendToRendererViews);
+  electron.ipcMain.handle(Channels.DOWNLOADS_GET, () => listDownloads());
+  electron.ipcMain.handle(Channels.DOWNLOADS_CLEAR, (event) => {
+    requireTrusted(event);
+    clearDownloads();
+    return true;
+  });
+  electron.ipcMain.handle(Channels.DOWNLOADS_OPEN, (event, id) => {
+    requireTrusted(event);
+    return openDownload(id);
+  });
+  electron.ipcMain.handle(Channels.DOWNLOADS_SHOW_IN_FOLDER, (event, id) => {
+    requireTrusted(event);
+    return showDownloadInFolder(id);
+  });
+  electron.ipcMain.handle(Channels.PERMISSIONS_GET, () => listPermissions());
+  electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR, (event) => {
+    requireTrusted(event);
+    clearPermissions();
+    return true;
+  });
+  electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR_ORIGIN, (event, origin) => {
+    requireTrusted(event);
+    clearPermissionsForOrigin(origin);
+    return true;
+  });
+  electron.ipcMain.handle(Channels.UPDATES_CHECK, () => checkForUpdates());
+  electron.ipcMain.handle(Channels.UPDATES_OPEN_DOWNLOAD, (event) => {
+    requireTrusted(event);
+    return openUpdateDownload();
+  });
   electron.ipcMain.handle(Channels.TAB_TOGGLE_PIP, async () => {
     return togglePictureInPicture(tabManager);
   });
@@ -27033,9 +27503,9 @@ function clone(value) {
 function summarizeArgs(args) {
   const entries = Object.entries(args).filter(([, value]) => value != null);
   if (entries.length === 0) return "No arguments";
-  return entries.map(([key, value]) => {
+  return entries.map(([key2, value]) => {
     const rendered = typeof value === "string" ? value : JSON.stringify(value);
-    return `${key}=${String(rendered).slice(0, 120)}`;
+    return `${key2}=${String(rendered).slice(0, 120)}`;
   }).join(", ");
 }
 function summarizeText(value) {
@@ -27070,6 +27540,7 @@ class AgentRuntime {
     this.state = this.loadPersistedState();
     onMcpStatusChange(() => this.emit());
   }
+  tabManager;
   state;
   updateListener = null;
   pendingResolvers = /* @__PURE__ */ new Map();
@@ -27081,11 +27552,11 @@ class AgentRuntime {
     }
   }
   getState() {
-    const snapshot = clone(this.state);
-    snapshot.mcpStatus = getMcpStatus();
-    snapshot.canUndo = this.canUndo();
-    snapshot.undoInfo = this.getUndoInfo();
-    return snapshot;
+    const snapshot2 = clone(this.state);
+    snapshot2.mcpStatus = getMcpStatus();
+    snapshot2.canUndo = this.canUndo();
+    snapshot2.undoInfo = this.getUndoInfo();
+    return snapshot2;
   }
   onTabStateChanged() {
     this.captureSession();
@@ -27121,13 +27592,13 @@ class AgentRuntime {
     return this.getState();
   }
   createCheckpoint(name, note) {
-    const snapshot = this.captureSession(note);
+    const snapshot2 = this.captureSession(note);
     const checkpoint = {
       id: crypto$2.randomUUID(),
       name: name?.trim() || `Checkpoint ${this.state.checkpoints.length + 1}`,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       note: note?.trim() || void 0,
-      snapshot
+      snapshot: snapshot2
     };
     this.state.checkpoints = [...this.state.checkpoints, checkpoint].slice(
       -20
@@ -27161,26 +27632,26 @@ class AgentRuntime {
     return { actionName: latest.actionName, capturedAt: latest.capturedAt };
   }
   undoLastAction() {
-    const snapshot = this.undoSnapshots.at(-1);
-    if (!snapshot) return null;
+    const snapshot2 = this.undoSnapshots.at(-1);
+    if (!snapshot2) return null;
     try {
-      this.tabManager.restoreSession(snapshot.snapshot);
+      this.tabManager.restoreSession(snapshot2.snapshot);
       this.undoSnapshots.pop();
     } catch (error) {
       logger$3.error("Failed to restore undo snapshot", error);
       return null;
     }
-    this.captureSession(`Undid ${snapshot.actionName}`);
-    return snapshot.actionName;
+    this.captureSession(`Undid ${snapshot2.actionName}`);
+    return snapshot2.actionName;
   }
   captureSession(note) {
-    const snapshot = this.tabManager.snapshotSession(note);
-    this.state.session = snapshot;
+    const snapshot2 = this.tabManager.snapshotSession(note);
+    this.state.session = snapshot2;
     this.emit();
-    return clone(snapshot);
+    return clone(snapshot2);
   }
-  restoreSession(snapshot) {
-    const target = snapshot || this.state.session;
+  restoreSession(snapshot2) {
+    const target = snapshot2 || this.state.session;
     if (!target) {
       return this.captureSession("No saved session to restore");
     }
@@ -27322,6 +27793,7 @@ ${progress}
     args = {},
     tabId = null,
     dangerous = false,
+    requiresApproval = false,
     undoable,
     executor
   }) {
@@ -27341,7 +27813,7 @@ ${progress}
       streamId: transcriptStreamId,
       mode: "replace"
     });
-    const approvalReason = this.getApprovalReason(dangerous);
+    const approvalReason = this.getApprovalReason(dangerous, requiresApproval);
     if (approvalReason) {
       this.publishTranscript({
         source,
@@ -27419,8 +27891,8 @@ ${progress}
       capturedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  pushUndoSnapshot(snapshot) {
-    this.undoSnapshots = [...this.undoSnapshots, snapshot].slice(
+  pushUndoSnapshot(snapshot2) {
+    this.undoSnapshots = [...this.undoSnapshots, snapshot2].slice(
       -10
     );
   }
@@ -27564,10 +28036,13 @@ ${progress}
       )
     };
   }
-  getApprovalReason(dangerous) {
+  getApprovalReason(dangerous, requiresApproval) {
     if (this.state.supervisor.paused) {
       return "Agent execution is paused";
     }
+    if (requiresApproval) {
+      return "Approval required: high-risk action";
+    }
     if (this.state.supervisor.approvalMode === "manual") {
       return "Approval required: ask every time mode";
     }
@@ -28061,6 +28536,7 @@ async function bootstrap() {
     sidebarView.webContents.send(Channels.HISTORY_UPDATE, state2);
   });
   installDownloadHandler(chromeView);
+  installPermissionHandler();
   startBackgroundRevalidation();
   startTelemetry();
   const initializeChromeRenderer = () => {