@dsh-sup/dsh-core-linux-x64 0.1.6-BETA.11 → 0.1.6-BETA.13

package/core.cjs

@@ -947,7 +947,7 @@ var require_version = __commonJS({
     var fs2 = require("node:fs");
     var path2 = require("node:path");
     function guardVersion() {
-      if (true) return String("0.1.6-BETA.11");
+      if (true) return String("0.1.6-BETA.13");
       try {
         return JSON.parse(fs2.readFileSync(path2.join(__dirname, "..", "..", "package.json"), "utf8")).version || "unknown";
       } catch {
@@ -4639,23 +4639,66 @@ var require_desktop = __commonJS({
   "src/platform/os/desktop.js"(exports2, module2) {
     "use strict";
     var fs2 = require("node:fs");
+    var os2 = require("node:os");
+    var path2 = require("node:path");
     var PLATFORM = process.platform;
-    function hasX11Socket() {
+    var X11_DIR = "/tmp/.X11-unix";
+    function deps(o) {
+      const ov = o || {};
+      return {
+        env: ov.env || process.env,
+        readdir: ov.readdir || ((p) => fs2.readdirSync(p)),
+        exists: ov.exists || ((p) => fs2.existsSync(p)),
+        home: ov.home || os2.homedir(),
+        uid: typeof process.getuid === "function" ? process.getuid() : 0
+      };
+    }
+    function runtimeDir(env, uid) {
+      return env.XDG_RUNTIME_DIR || "/run/user/" + uid;
+    }
+    function x11Displays(o) {
+      const d = deps(o);
       try {
-        return fs2.readdirSync("/tmp/.X11-unix").some((f) => /^X\d+$/.test(f));
+        return d.readdir(X11_DIR).filter((f) => /^X\d+$/.test(f)).map((f) => Number(f.slice(1))).sort((a, b) => a - b);
       } catch {
-        return false;
+        return [];
       }
     }
-    function hasWaylandSocket() {
-      const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-      const rt = process.env.XDG_RUNTIME_DIR || "/run/user/" + uid;
+    function waylandSockets(o) {
+      const d = deps(o);
       try {
-        return fs2.readdirSync(rt).some((f) => /^wayland-\d+$/.test(f));
+        return d.readdir(runtimeDir(d.env, d.uid)).filter((f) => /^wayland-\d+$/.test(f)).sort();
       } catch {
-        return false;
+        return [];
       }
     }
+    function hasX11Socket(o) {
+      return x11Displays(o).length > 0;
+    }
+    function hasWaylandSocket(o) {
+      return waylandSockets(o).length > 0;
+    }
+    function sessionEnv(o) {
+      const d = deps(o);
+      const out = {};
+      if (PLATFORM !== "linux") return out;
+      if (!d.env.DISPLAY && !d.env.WAYLAND_DISPLAY) {
+        const xs = x11Displays(d);
+        if (xs.length) {
+          out.DISPLAY = ":" + xs[0];
+          const xauth = path2.join(d.home, ".Xauthority");
+          if (d.exists(xauth)) out.XAUTHORITY = xauth;
+        } else {
+          const wl = waylandSockets(d);
+          if (wl.length) out.WAYLAND_DISPLAY = wl[0];
+        }
+      }
+      if (!d.env.DBUS_SESSION_BUS_ADDRESS) {
+        const bus = path2.join(runtimeDir(d.env, d.uid), "bus");
+        if (d.exists(bus)) out.DBUS_SESSION_BUS_ADDRESS = "unix:path=" + bus;
+      }
+      return out;
+    }
     function sessionAvailable() {
       if (PLATFORM === "linux") {
         if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) return true;
@@ -4682,7 +4725,7 @@ var require_desktop = __commonJS({
         reason: "session-scoped-by-launcher"
       };
     }
-    module2.exports = { sessionAvailable, describe, PLATFORM };
+    module2.exports = { sessionAvailable, sessionEnv, describe, x11Displays, waylandSockets, PLATFORM };
   }
 });
 
@@ -4755,8 +4798,9 @@ var require_capability_profile = __commonJS({
       autostart: true,
       // 期望 schtasks（实测覆写）
       frpExpose: true,
-      // 可打开，但只有注册表解析到默认浏览器时才有退出证据；退到 explorer.exe 调度器即恒返 0，
-      // 每次调用的证据档位由 openBrowser 的 confirmed/handedOff 如实回报，不在此处宣称。
+      // 可打开，但 Windows 没有可信调度器（系统调度器只有 darwin 的 open 与 linux 的 xdg-open），
+      // 只能直启探测层解析出的浏览器本体；浏览器已在运行时本次进程只转交地址，退出码与窗口出现与否无关，
+      // 故该平台每次调用最多到 handedOff（判据见 browser.js#ownsItsWindow）。能力位只声明「能交出去」。
       openBrowser: true,
       hostService: "windows-service",
       guardAutostart: true,
@@ -5452,18 +5496,567 @@ var require_notify = __commonJS({
   }
 });
 
+// src/platform/os/browser-inventory.js
+var require_browser_inventory = __commonJS({
+  "src/platform/os/browser-inventory.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require("node:fs");
+    var path2 = require("node:path");
+    var os2 = require("node:os");
+    var exec = require_exec();
+    var { isExecutableFile } = require_exec_path();
+    var PROBE_TIMEOUT_MS = 1500;
+    function engineOf(bin) {
+      const base = String(bin || "").toLowerCase().split(/[\\/]/).pop();
+      if (/(chrome|chromium|msedge|edge|brave|vivaldi|opera|thorium)/.test(base)) return "chromium";
+      if (/(firefox|librewolf|waterfox)/.test(base)) return "firefox";
+      return "other";
+    }
+    function tokenizeExec(line) {
+      const toks = [];
+      let cur = "";
+      let q = null;
+      let esc = false;
+      let has = false;
+      for (const ch of String(line)) {
+        if (esc) {
+          cur += ch;
+          esc = false;
+          continue;
+        }
+        if (ch === "\\") {
+          esc = true;
+          has = true;
+          continue;
+        }
+        if (q) {
+          if (ch === q) q = null;
+          else cur += ch;
+          continue;
+        }
+        if (ch === "'" || ch === '"') {
+          q = ch;
+          has = true;
+          continue;
+        }
+        if (/\s/.test(ch)) {
+          if (has) {
+            toks.push(cur);
+            cur = "";
+            has = false;
+          }
+          continue;
+        }
+        cur += ch;
+        has = true;
+      }
+      if (has) toks.push(cur);
+      return toks;
+    }
+    function parseExecLine(line) {
+      let toks = tokenizeExec(line).filter((t) => t !== "%%" && !/^%[a-zA-Z]$/.test(t));
+      if (toks[0] === "env") {
+        let i = 1;
+        while (i < toks.length && /=/.test(toks[i])) i++;
+        toks = toks.slice(i);
+      }
+      if (!toks.length) return null;
+      return { bin: toks[0], baseArgs: toks.slice(1) };
+    }
+    function regValueOf(out) {
+      const m = String(out || "").match(/REG_(?:EXPAND_SZ|SZ)\s+(.*)/);
+      if (!m) return null;
+      return m[1].trim() || null;
+    }
+    function expandEnvVars(value, env) {
+      const e = env || process.env;
+      return String(value).replace(/%([^%]+)%/g, (all, name) => e[name] === void 0 ? all : e[name]);
+    }
+    function exeFromCmdLine(cmdLine) {
+      const s = String(cmdLine || "");
+      let m = s.match(/^\s*"([^"]+\.exe)"/i);
+      if (m) return m[1];
+      m = s.match(/^\s*(.*?\.exe)/i);
+      return m ? m[1] : null;
+    }
+    function safeRegKeyPart(s) {
+      return typeof s === "string" && s.length > 0 && s.length <= 200 && /^[\x20-\x7e]+$/.test(s) && !/[;|&`$()<>^"'\r\n]/.test(s);
+    }
+    function regValue(runner, note, key, name) {
+      const args = name ? ["query", key, "/v", name] : ["query", key, "/ve"];
+      const out = runner("reg.exe", args);
+      const v = regValueOf(out);
+      note(name ? key + " /v " + name : key, v ? "ok" : "empty");
+      return v;
+    }
+    var REG_HIVE_ALIAS = { HKLM: "HKEY_LOCAL_MACHINE", HKCU: "HKEY_CURRENT_USER", HKCR: "HKEY_CLASSES_ROOT", HKU: "HKEY_USERS", HKCC: "HKEY_CURRENT_CONFIG" };
+    function regKeyFull(key) {
+      const s = String(key || "");
+      const i = s.indexOf("\\");
+      const root = i < 0 ? s : s.slice(0, i);
+      return (REG_HIVE_ALIAS[root.toUpperCase()] || root) + (i < 0 ? "" : s.slice(i));
+    }
+    function regSubkeys(runner, note, key) {
+      const out = runner("reg.exe", ["query", key]);
+      if (!out) {
+        note(key, "unreadable");
+        return [];
+      }
+      const prefix = regKeyFull(key) + "\\";
+      const names = [];
+      for (const line of String(out).split(/\r?\n/)) {
+        const l = line.trim();
+        if (!/^HKEY_/i.test(l) || l.length <= prefix.length) continue;
+        if (l.slice(0, prefix.length).toUpperCase() !== prefix.toUpperCase()) continue;
+        const rest = l.slice(prefix.length);
+        if (rest && !rest.includes("\\") && safeRegKeyPart(rest)) names.push(rest);
+      }
+      note(key, names.length ? names.length + " \u9879" : "\u65E0\u5B50\u952E");
+      return names;
+    }
+    var WIN_APP_PATHS = ["msedge.exe", "chrome.exe", "firefox.exe", "brave.exe", "opera.exe", "vivaldi.exe", "chromium.exe", "thorium.exe", "librewolf.exe"];
+    function winExeOfProgId(runner, note, progId, env) {
+      if (!safeRegKeyPart(progId)) return null;
+      for (const root of ["HKCU\\Software\\Classes", "HKLM\\Software\\Classes"]) {
+        const cmd2 = regValue(runner, note, root + "\\" + progId + "\\shell\\open\\command");
+        const exe = cmd2 ? exeFromCmdLine(expandEnvVars(cmd2, env)) : null;
+        if (exe) return exe;
+      }
+      return null;
+    }
+    function probeWin(d) {
+      const { runOut, env, canExec } = d;
+      const notes = [];
+      const note = (source, detail) => {
+        notes.push({ source, detail });
+      };
+      const found = /* @__PURE__ */ new Map();
+      const keyOf = (exe) => String(exe || "").toLowerCase().replace(/[\\/]/g, "\\");
+      const push = (exe, how) => {
+        const full = expandEnvVars(exe, env).trim();
+        if (!/\.exe$/i.test(full)) {
+          note(how, "\u6765\u6E90\u7ED9\u51FA\u7684\u4E0D\u662F exe \u8DEF\u5F84: " + full);
+          return null;
+        }
+        const k = keyOf(full);
+        const hit = found.get(k);
+        if (hit) {
+          if (!hit.sources.includes(how)) hit.sources.push(how);
+          return hit;
+        }
+        if (!canExec(full)) {
+          note(how, "\u6307\u5411\u7684\u6587\u4EF6\u4E0D\u53EF\u6267\u884C: " + full);
+          return null;
+        }
+        const item = { id: k, name: path2.basename(full).replace(/\.exe$/i, ""), engine: engineOf(full), bin: full, source: how, sources: [how] };
+        found.set(k, item);
+        note(how, item.name);
+        return item;
+      };
+      const progIds = /* @__PURE__ */ new Map();
+      const addProgId = (pid, how) => {
+        const s = String(pid || "").trim();
+        if (!safeRegKeyPart(s)) return;
+        if (progIds.get(s) === "userchoice") return;
+        progIds.set(s, how);
+      };
+      let defaultId = null;
+      let defaultSource = null;
+      const DEF_RANK = { userchoice: 1, "scheme-association": 2, "only-installed": 9 };
+      let defRank = 99;
+      const setDefault = (item, how) => {
+        const r = DEF_RANK[how] === void 0 ? 99 : DEF_RANK[how];
+        if (item && r < defRank) {
+          defRank = r;
+          defaultId = item.id;
+          defaultSource = how;
+        }
+      };
+      const cmdToExe = (raw) => raw ? exeFromCmdLine(expandEnvVars(raw, env)) : null;
+      const uc = regValue(runOut, note, "HKCU\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\https\\UserChoice", "ProgId");
+      if (uc) addProgId(uc, "userchoice");
+      for (const root of ["HKCU\\Software\\Classes", "HKLM\\Software\\Classes"]) {
+        const pid = regValue(runOut, note, root + "\\https");
+        if (pid) addProgId(pid, "scheme-association");
+        const exe = cmdToExe(regValue(runOut, note, root + "\\https\\shell\\open\\command"));
+        if (exe) setDefault(push(exe, "scheme-association"), "scheme-association");
+      }
+      for (const name of regSubkeys(runOut, note, "HKLM\\SOFTWARE\\Clients\\StartMenuInternet")) {
+        addProgId(name, "startmenu-catalog");
+        const exe = cmdToExe(regValue(runOut, note, "HKLM\\SOFTWARE\\Clients\\StartMenuInternet\\" + name + "\\shell\\open\\command")) || winExeOfProgId(runOut, note, name, env);
+        if (exe) push(exe, "startmenu-catalog");
+      }
+      for (const root of ["HKLM\\SOFTWARE", "HKCU\\SOFTWARE"]) {
+        for (const capPath of regValueTargets(runOut, note, root + "\\RegisteredApplications")) {
+          const https = regValue(runOut, note, capPath + "\\UrlAssociations\\https");
+          const sid = regValue(runOut, note, capPath, "StartMenuInternet");
+          const pid = https || sid;
+          if (pid) addProgId(pid, "registered-apps");
+        }
+      }
+      for (const exe of WIN_APP_PATHS) {
+        for (const root of ["HKCU", "HKLM"]) {
+          const v = regValue(runOut, note, root + "\\Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" + exe);
+          if (v && push(v, "app-paths")) break;
+        }
+      }
+      for (const [pid, how] of progIds) {
+        const exe = winExeOfProgId(runOut, note, pid, env);
+        if (!exe) continue;
+        const item = push(exe, how);
+        if (how === "userchoice") setDefault(item, "userchoice");
+      }
+      if (found.size === 1) setDefault([...found.values()][0], "only-installed");
+      return { browsers: [...found.values()], defaultId, defaultSource, probed: notes };
+    }
+    function regValueTargets(runOut, note, key) {
+      const out = runOut("reg.exe", ["query", key]);
+      if (!out) {
+        note(key, "unreadable");
+        return [];
+      }
+      const paths = [];
+      for (const line of String(out).split(/\r?\n/)) {
+        const m = line.trim().match(/REG_SZ\s+(.*)/);
+        if (!m) continue;
+        const rel = m[1].trim();
+        if (!safeRegKeyPart(rel)) continue;
+        const root = key.slice(0, key.indexOf("\\"));
+        paths.push(root + "\\" + rel);
+      }
+      note(key, paths.length ? paths.length + " \u4E2A\u80FD\u529B\u8DEF\u5F84" : "\u65E0\u503C");
+      return paths;
+    }
+    var MAC_JXA_LIST = [
+      "ObjC.import('Foundation');",
+      "var ws=$.NSWorkspace.sharedWorkspace;",
+      "var u=$.NSURL.URLWithString('https://dsh.local/probe');",
+      "var out=[];var def='';",
+      "try{var d=ws.URLForApplicationToOpenURL(u); if(!d.isNil()) def=ObjC.unwrap(d.path)||'';}catch(e){}",
+      "var list=null;",
+      "try{list=ws.urlsForApplicationsToOpenURL(u);}catch(e){}",
+      "if(list===null||typeof list.count!=='number'){if(def){out.push(def+'\\t\\t1');}}else{",
+      "var n=Number(list.count);",
+      "for(var i=0;i<n;i++){",
+      "var p=ObjC.unwrap(list.objectAtIndex(i).path)||''; if(!p) continue;",
+      "var exe='';var bid='';",
+      "var b=$.NSBundle.bundleWithPath(p);",
+      "if(!b.isNil()){exe=ObjC.unwrap(b.executablePath)||'';bid=ObjC.unwrap(b.bundleIdentifier)||'';}",
+      "out.push((exe||p)+'\\t'+bid+'\\t'+(p&&def&&p===def?1:0));}",
+      "}",
+      // 末句必须是裸表达式：osascript 取的是最后一条**语句**的值，if/else 语句不产结果，
+      //   写在分支里会让整段查询输出空字符串（表现为「系统未报任何可用应用」）。
+      "out.join('\\n');"
+    ].join("");
+    function probeMac(d) {
+      const { runOut, canExec } = d;
+      const notes = [];
+      const note = (source, detail) => {
+        notes.push({ source, detail });
+      };
+      const out = runOut("osascript", ["-l", "JavaScript", "-e", MAC_JXA_LIST]);
+      if (!out || !out.trim()) {
+        note("launchservices", "\u67E5\u8BE2\u65E0\u8F93\u51FA\uFF08\u65E7\u7CFB\u7EDF\u6216\u88AB\u6743\u9650\u62E6\u622A\uFF09");
+        return { browsers: [], defaultId: null, defaultSource: null, probed: notes };
+      }
+      const keyOf = (exe) => String(exe || "").toLowerCase();
+      const found = /* @__PURE__ */ new Map();
+      let defaultId = null;
+      let defaultSource = null;
+      for (const line of out.trim().split("\n")) {
+        const parts = line.split("	");
+        const bin = (parts[0] || "").trim();
+        if (!bin) continue;
+        if (!canExec(bin)) {
+          note("launchservices", "\u4E0D\u53EF\u6267\u884C: " + bin);
+          continue;
+        }
+        const k = keyOf(bin);
+        if (!found.has(k)) found.set(k, { id: k, name: path2.basename(bin), engine: engineOf(bin), bin, source: "launchservices", sources: ["launchservices"], isDefault: false });
+        if (parts[2] === "1") {
+          found.get(k).isDefault = true;
+          if (!defaultId) {
+            defaultId = k;
+            defaultSource = "launchservices";
+          }
+        }
+      }
+      note("launchservices", found.size ? found.size + " \u4E2A\u53EF\u6253\u5F00 https \u7684\u5E94\u7528" : "\u7CFB\u7EDF\u672A\u62A5\u4EFB\u4F55\u53EF\u7528\u5E94\u7528");
+      if (!defaultId && found.size === 1) {
+        defaultId = [...found.keys()][0];
+        defaultSource = "only-installed";
+      }
+      return { browsers: [...found.values()], defaultId, defaultSource, probed: notes };
+    }
+    var PJ = path2.posix.join;
+    function desktopDirs(env, home) {
+      const dataHome = env.XDG_DATA_HOME || PJ(home, ".local", "share");
+      const dataDirs = String(env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":").filter(Boolean);
+      const dirs = [[dataHome, "xdg"], ...dataDirs.map((p) => [p, "xdg"])];
+      dirs.push([PJ(home, ".local", "share"), "xdg"]);
+      dirs.push(["/var/lib/flatpak/exports/share", "flatpak"]);
+      dirs.push([PJ(home, ".local", "share", "flatpak", "exports", "share"), "flatpak"]);
+      dirs.push(["/var/lib/snapd/desktop", "snap"]);
+      const seen = [];
+      return dirs.map(([root, kind]) => ({ dir: PJ(root, "applications"), kind })).filter((x) => {
+        if (seen.includes(x.dir)) return false;
+        seen.push(x.dir);
+        return true;
+      });
+    }
+    function browserFromDesktop(text, kind, file) {
+      let inMain = false;
+      const got = {};
+      for (const line of String(text).split(/\r?\n/)) {
+        if (/^\[Desktop Entry\]\s*$/.test(line)) {
+          inMain = true;
+          continue;
+        }
+        if (/^\[/.test(line)) break;
+        if (!inMain) continue;
+        const m = line.match(/^(Exec|Name|TryExec|Categories)=(.*)$/);
+        if (!m) continue;
+        if (m[1] === "Name" && got.Name) continue;
+        got[m[1]] = m[2].trim();
+      }
+      if (!got.Exec) return null;
+      const categories = String(got.Categories || "");
+      const parsed = parseExecLine(got.Exec);
+      if (!parsed) return null;
+      const engine = engineOf(parsed.bin);
+      const claimsBrowser = /(^|;)WebBrowser(;|$)/.test(categories);
+      if (!claimsBrowser && engine === "other") return null;
+      if (engine === "other") return null;
+      return {
+        // id 恒为归一后的可执行文件路径：defaultId 靠它在清单里定位条目，三平台同一契约
+        id: parsed.bin.toLowerCase(),
+        name: got.Name || path2.basename(file, ".desktop"),
+        engine,
+        bin: parsed.bin,
+        baseArgs: parsed.baseArgs,
+        source: kind,
+        desktopFile: file
+      };
+    }
+    function resolveLinuxBin(bin, canExec, env) {
+      const b = String(bin || "").trim();
+      if (!b) return null;
+      if (b.startsWith("/")) return canExec(b) ? b : null;
+      if (b.includes("/")) return null;
+      for (const dir of String(env.PATH || "").split(":")) {
+        if (!dir) continue;
+        const p = PJ(dir.replace(/\/+$/, ""), b);
+        if (canExec(p)) return p;
+      }
+      return null;
+    }
+    function probeLinux(d) {
+      const { runOut, readFile, exists, listDir, canExec, env, home } = d;
+      const notes = [];
+      const note = (source, detail) => {
+        notes.push({ source, detail });
+      };
+      const found = /* @__PURE__ */ new Map();
+      const usable = (item) => {
+        const resolved = resolveLinuxBin(item.bin, canExec, env);
+        if (!resolved) {
+          note(item.source, "\u4E0D\u53EF\u6267\u884C: " + item.bin);
+          return null;
+        }
+        const k = resolved.toLowerCase();
+        const hit = found.get(k);
+        if (hit) {
+          if (!hit.sources.includes(item.source)) hit.sources.push(item.source);
+          return hit;
+        }
+        const v = Object.assign({}, item, { id: k, bin: resolved, sources: [item.source] });
+        found.set(k, v);
+        return v;
+      };
+      for (const { dir, kind } of desktopDirs(env, home)) {
+        let names = [];
+        try {
+          names = listDir(dir).filter((f) => f.endsWith(".desktop"));
+        } catch {
+          continue;
+        }
+        for (const f of names) {
+          let text = null;
+          try {
+            text = readFile(PJ(dir, f));
+          } catch {
+            continue;
+          }
+          const item = browserFromDesktop(text, kind, f);
+          if (item) usable(item);
+        }
+      }
+      let defaultId = null;
+      let defaultSource = null;
+      const fromMime = linuxDefaultFromMimeApps(readFile, exists, env, home, note);
+      if (fromMime) {
+        const item = usable(fromMime);
+        if (item) {
+          defaultId = item.id;
+          defaultSource = "mimeapps";
+        }
+      }
+      const id = runOut("xdg-settings", ["get", "default-web-browser"]);
+      const desktopId = id && String(id).trim();
+      if (!defaultId && desktopId && /^[A-Za-z0-9._-]+\.desktop$/.test(desktopId)) {
+        for (const { dir } of desktopDirs(env, home)) {
+          const p = PJ(dir, desktopId);
+          let text = null;
+          try {
+            if (exists(p)) text = readFile(p);
+          } catch {
+            continue;
+          }
+          if (text === null) continue;
+          const item = browserFromDesktop(text, "xdg-settings", desktopId);
+          const used = item && usable(item);
+          if (used) {
+            defaultId = used.id;
+            defaultSource = "xdg-settings";
+            break;
+          }
+        }
+      }
+      if (!desktopId) note("xdg-settings", "\u65E0\u8F93\u51FA");
+      else if (defaultSource === "xdg-settings") note("xdg-settings", "\u9ED8\u8BA4=" + defaultId);
+      else note("xdg-settings", "\u62A5\u51FA " + desktopId + (defaultId ? "\uFF08\u9ED8\u8BA4\u5DF2\u7531 " + defaultSource + " \u5B9A\u51FA\uFF09" : " \u4F46\u4E0D\u53EF\u7528"));
+      if (!defaultId && found.size === 1) {
+        defaultId = [...found.keys()][0];
+        defaultSource = "only-installed";
+      }
+      return { browsers: [...found.values()], defaultId, defaultSource, probed: notes };
+    }
+    function linuxDefaultFromMimeApps(readFile, exists, env, home, note) {
+      const cfgHome = env.XDG_CONFIG_HOME || PJ(home, ".config");
+      const cfgDirs = String(env.XDG_CONFIG_DIRS || "/etc/xdg").split(":").filter(Boolean);
+      const dataDirs = String(env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":").filter(Boolean);
+      const files = [
+        PJ(cfgHome, "mimeapps.list"),
+        ...cfgDirs.map((d) => PJ(d, "mimeapps.list")),
+        ...dataDirs.map((d) => PJ(d, "applications", "mimeapps.list"))
+      ];
+      for (const f of files) {
+        if (!exists(f)) continue;
+        let text = null;
+        try {
+          text = readFile(f);
+        } catch {
+          continue;
+        }
+        const id = mimeAppsDefault(text);
+        if (!id) continue;
+        note("mimeapps", path2.basename(f) + " -> " + id);
+        for (const { dir, kind } of desktopDirs(env, home)) {
+          const p = PJ(dir, id);
+          if (!exists(p)) continue;
+          let dt = null;
+          try {
+            dt = readFile(p);
+          } catch {
+            continue;
+          }
+          const item = browserFromDesktop(dt, kind, id);
+          if (item) return item;
+        }
+        return null;
+      }
+      note("mimeapps", "\u65E0\u9ED8\u8BA4\u9879");
+      return null;
+    }
+    function mimeAppsDefault(text) {
+      let inDefault = false;
+      for (const line of String(text || "").split(/\r?\n/)) {
+        if (/^\s*\[/.test(line)) {
+          inDefault = /^\s*\[Default Applications\]\s*$/.test(line);
+          continue;
+        }
+        if (!inDefault) continue;
+        const m = line.match(/^\s*x-scheme-handler\/https?\s*=\s*(.*)$/i);
+        if (!m) continue;
+        const ids = m[1].split(";").map((s) => s.trim()).filter((s) => /^[A-Za-z0-9._-]+\.desktop$/.test(s));
+        if (ids.length) return ids[0];
+      }
+      return null;
+    }
+    function probe(platform, d) {
+      const pl = platform || process.platform;
+      const dd = Object.assign({}, d, { canExec: d.canExec || ((p) => isExecutableFile(p, pl)) });
+      if (pl === "win32") return probeWin(dd);
+      if (pl === "darwin") return probeMac(dd);
+      return probeLinux(dd);
+    }
+    var CACHE = /* @__PURE__ */ Object.create(null);
+    function inventory(platform, o) {
+      const ov = o || {};
+      const pl = platform || process.platform;
+      const now = ov.now || (() => Date.now());
+      const ttl = ov.ttlMs === void 0 ? 6e4 : ov.ttlMs;
+      const cached = CACHE[pl];
+      if (!ov.force && cached && now() - cached.at < ttl) return Object.assign({ cached: true }, cached.value);
+      const runOut = ov.runOut || ((bin, args) => exec.runOut(bin, args, { timeoutMs: PROBE_TIMEOUT_MS }));
+      const readFile = ov.readFile || ((p) => fs2.readFileSync(p, "utf8"));
+      const exists = ov.exists || ((p) => fs2.existsSync(p));
+      const listDir = ov.listDir || ((p) => fs2.readdirSync(p));
+      let value;
+      try {
+        value = probe(pl, { runOut, readFile, exists, listDir, canExec: ov.canExec, env: ov.env || process.env, home: ov.home || os2.homedir() });
+      } catch (e) {
+        value = { browsers: [], defaultId: null, defaultSource: null, probed: [{ source: "probe-error", detail: String(e && e.message || e) }] };
+      }
+      value.at = now();
+      value.platform = pl;
+      value.browsers.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+      CACHE[pl] = { at: now(), value };
+      return Object.assign({ cached: false }, value);
+    }
+    function invalidate(platform) {
+      if (platform) delete CACHE[platform];
+      else for (const k of Object.keys(CACHE)) delete CACHE[k];
+    }
+    module2.exports = {
+      inventory,
+      invalidate,
+      probe,
+      probeWin,
+      probeMac,
+      probeLinux,
+      engineOf,
+      tokenizeExec,
+      parseExecLine,
+      regValueOf,
+      expandEnvVars,
+      exeFromCmdLine,
+      regSubkeys,
+      regKeyFull,
+      regValueTargets,
+      safeRegKeyPart,
+      browserFromDesktop,
+      desktopDirs,
+      resolveLinuxBin,
+      mimeAppsDefault,
+      linuxDefaultFromMimeApps,
+      WIN_APP_PATHS,
+      PROBE_TIMEOUT_MS
+    };
+  }
+});
+
 // src/platform/os/browser.js
 var require_browser = __commonJS({
   "src/platform/os/browser.js"(exports2, module2) {
     "use strict";
-    var fs2 = require("node:fs");
     var path2 = require("node:path");
-    var os2 = require("node:os");
     var spawnOS = require_spawn();
     var desktop = require_desktop();
     var CAPABILITY_PROFILES = require_capability_profile();
     var { resolveExecutable, isExecutableFile } = require_exec_path();
-    var exec = require_exec();
+    var detector = require_browser_inventory();
+    var { engineOf } = detector;
     function isSafeHttpUrl(url) {
       try {
         const u = new URL(String(url));
@@ -5475,7 +6068,7 @@ var require_browser = __commonJS({
     function openCommand(platform, url) {
       const pl = platform || process.platform;
       if (pl === "darwin") return { cmd: "open", args: [url] };
-      if (pl === "win32") return { cmd: "explorer.exe", args: [url] };
+      if (pl === "win32") return null;
       return { cmd: "xdg-open", args: [url] };
     }
     var SUPPORTED_OPEN_PLATFORMS = Object.keys(CAPABILITY_PROFILES).filter((k) => CAPABILITY_PROFILES[k].openBrowser === true);
@@ -5496,26 +6089,58 @@ var require_browser = __commonJS({
       };
     }
     var CONFIRMED_TEXT = "\u5DF2\u5728\u7CFB\u7EDF\u6D4F\u89C8\u5668\u6253\u5F00";
-    var HANDEDOFF_TEXT = "\u5DF2\u628A\u5730\u5740\u4EA4\u7ED9\u7CFB\u7EDF\uFF0C\u4F46\u65E0\u6CD5\u786E\u8BA4\u6D4F\u89C8\u5668\u7A97\u53E3\u662F\u5426\u51FA\u73B0";
+    var HANDEDOFF_TEXT = "\u5DF2\u628A\u5730\u5740\u4EA4\u7ED9\u7CFB\u7EDF\uFF0C\u4F46\u8FD9\u6B21\u542F\u52A8\u62FF\u4E0D\u5230\u7A97\u53E3\u662F\u5426\u51FA\u73B0\u7684\u8BC1\u636E";
     var FAILURE_TEXT = {
       "unsafe-url": "\u5730\u5740\u4E0D\u662F http(s) \u7EDD\u5BF9 URL\uFF0C\u5DF2\u62D2\u7EDD\u4EA4\u7ED9\u6D4F\u89C8\u5668",
-      "no-launcher": "\u672A\u627E\u5230\u53EF\u7528\u7684\u6D4F\u89C8\u5668\u542F\u52A8\u547D\u4EE4\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u8BE5\u5730\u5740",
+      "no-launcher": "\u672A\u80FD\u786E\u5B9A\u8BE5\u7528\u54EA\u4E2A\u6D4F\u89C8\u5668\u6253\u5F00\uFF08\u7CFB\u7EDF\u91CC\u8BFB\u4E0D\u5230\u9ED8\u8BA4\u6D4F\u89C8\u5668\u8BBE\u7F6E\uFF09\uFF0C\u8BF7\u5728\u7CFB\u7EDF\u8BBE\u7F6E\u91CC\u6307\u5B9A\u9ED8\u8BA4\u6D4F\u89C8\u5668\u6216\u624B\u52A8\u6253\u5F00\u8BE5\u5730\u5740",
       "spawn-failed": "\u6D4F\u89C8\u5668\u542F\u52A8\u5931\u8D25\uFF08\u7CFB\u7EDF\u62D2\u7EDD\u4E86\u8BE5\u547D\u4EE4\uFF09",
-      "exit-nonzero": "\u6D4F\u89C8\u5668\u542F\u52A8\u547D\u4EE4\u4EE5\u975E 0 \u9000\u51FA\uFF0C\u7A97\u53E3\u672A\u51FA\u73B0",
-      "killed-by-signal": "\u6D4F\u89C8\u5668\u542F\u52A8\u547D\u4EE4\u88AB\u7CFB\u7EDF\u7EC8\u6B62",
+      "exit-nonzero": "\u7CFB\u7EDF\u62D2\u7EDD\u4E86\u8FD9\u4E2A\u5730\u5740\uFF08\u542F\u52A8\u547D\u4EE4\u975E 0 \u9000\u51FA\uFF09\uFF0C\u7A97\u53E3\u672A\u51FA\u73B0",
+      "killed-by-signal": "\u6D4F\u89C8\u5668\u542F\u52A8\u547D\u4EE4\u88AB\u7CFB\u7EDF\u7EC8\u6B62\uFF0C\u7A97\u53E3\u672A\u51FA\u73B0",
       "no-desktop-session": "\u5F53\u524D\u6CA1\u6709\u56FE\u5F62\u4F1A\u8BDD\uFF0C\u65E0\u6CD5\u8C03\u8D77\u6D4F\u89C8\u5668",
       "unsupported-platform": "\u5F53\u524D\u5E73\u53F0\u4E0D\u5728\u4EA7\u54C1\u652F\u6301\u7684\u684C\u9762\u5E73\u53F0\u5185\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u8BE5\u5730\u5740"
     };
+    function ownsItsWindow(via, platform) {
+      if (via !== "dispatcher") return false;
+      return platform !== "win32";
+    }
+    function pickLauncher(platform, inv) {
+      const list = inv && Array.isArray(inv.browsers) ? inv.browsers : [];
+      const id = inv && inv.defaultId;
+      const hit = id ? list.find((b) => b.id === id) : null;
+      if (hit) return { browser: hit, how: inv && inv.defaultSource || "default" };
+      if (list.length === 1) return { browser: list[0], how: "only-installed" };
+      return { browser: null, how: list.length ? "no-default" : "none-found" };
+    }
+    function formOfBin(pl, b) {
+      const engine = b && b.bin ? engineOf(b.bin) : "other";
+      return { engine, direct: !!b && (engine !== "other" || pl === "win32") };
+    }
     function openPlan(platform, url, opts) {
       const o = opts || {};
       const pl = platform || process.platform;
-      const db = o.defaultBrowser;
-      const engine = db && db.bin ? engineOf(db.bin) : "other";
-      if (engine === "chromium" || engine === "firefox") {
-        return { bin: db.bin, engine, via: "browser", baseArgs: (db.baseArgs || []).concat([url]), trustExit: true };
+      const picked = o.pick || pickLauncher(pl, o.inventory);
+      const b = picked.browser;
+      const form = formOfBin(pl, b);
+      if (form.direct) {
+        return {
+          bin: b.bin,
+          engine: form.engine,
+          via: "browser",
+          pick: picked.how,
+          baseArgs: (b.baseArgs || []).concat([url]),
+          exitIsEvidence: ownsItsWindow("browser", pl)
+        };
       }
       const c = openCommand(pl, url);
-      return { bin: c.cmd, engine: "other", via: "dispatcher", baseArgs: c.args, trustExit: pl !== "win32" };
+      if (!c) return { bin: null, engine: form.engine, via: "none", pick: picked.how, baseArgs: [], exitIsEvidence: false };
+      return {
+        bin: c.cmd,
+        engine: "other",
+        via: "dispatcher",
+        pick: picked.how,
+        baseArgs: c.args,
+        exitIsEvidence: ownsItsWindow("dispatcher", pl)
+      };
     }
     function observeSpawn(child, windowMs, setTimeoutFn) {
       return new Promise((resolve) => {
@@ -5534,6 +6159,21 @@ var require_browser = __commonJS({
       });
     }
     var OPEN_OBSERVE_MS = 1500;
+    function launchDiagnostics(inv, plan, how) {
+      const found = (inv && inv.browsers || []).map((b) => ({
+        name: b.name,
+        engine: b.engine || engineOf(b.bin),
+        via: (b.sources && b.sources.length ? b.sources : [b.source || "unknown"]).join("+")
+      }));
+      return {
+        platform: inv && inv.platform || null,
+        pick: how || plan && plan.pick || "none",
+        bin: plan && plan.bin || null,
+        default: inv && inv.defaultId ? { id: inv.defaultId, source: inv.defaultSource || null } : null,
+        found,
+        probed: inv && inv.probed || []
+      };
+    }
     async function openBrowser(url, o) {
       const opts = o || {};
       const pl = opts.platform || process.platform;
@@ -5547,16 +6187,27 @@ var require_browser = __commonJS({
       const spawnWith = typeof opts.spawn === "function" ? opts.spawn : _spawnDetachedIgnored;
       const avail = typeof opts.binAvailable === "function" ? opts.binAvailable : binAvailable;
       const observe = typeof opts.observe === "function" ? opts.observe : observeSpawn;
-      let db;
-      if ("defaultBrowser" in opts) db = opts.defaultBrowser;
-      else if (typeof opts.resolveDefault === "function") db = opts.resolveDefault(pl, opts.resolveDeps || {});
-      else db = resolveDefaultBrowser(pl, opts.resolveDeps || {});
-      const plan = openPlan(pl, url, { defaultBrowser: db });
-      const evidence = { bin: plan.bin, engine: plan.engine, via: plan.via, exitCode: null, exitSignal: null, error: null };
+      const resolveInv = typeof opts.resolveInventory === "function" ? opts.resolveInventory : ((platform, deps) => detector.inventory(platform, deps));
+      const inv = "inventory" in opts ? opts.inventory : resolveInv(pl, opts.resolveDeps || {});
+      const plan = openPlan(pl, url, { inventory: inv, pick: opts.pick });
+      const diagnostics = launchDiagnostics(inv, plan, plan.pick);
+      const evidence = {
+        bin: plan.bin,
+        engine: plan.engine,
+        via: plan.via,
+        ownsWindow: plan.exitIsEvidence === true,
+        exitCode: null,
+        exitSignal: null,
+        error: null,
+        diagnostics
+      };
       const desktopAvailable = typeof opts.desktopAvailable === "function" ? opts.desktopAvailable : desktop.sessionAvailable;
       if (pl === "linux" && !desktopAvailable()) {
         return outcome({ ok: false, reason: "no-desktop-session", url, evidence });
       }
+      if (!plan.bin) {
+        return outcome({ ok: false, reason: "no-launcher", url, evidence });
+      }
       if (!avail(plan.bin)) {
         return outcome({ ok: false, reason: "no-launcher", url, evidence });
       }
@@ -5573,7 +6224,8 @@ var require_browser = __commonJS({
       evidence.exitCode = seen.code === void 0 ? null : seen.code;
       evidence.exitSignal = seen.signal === void 0 ? null : seen.signal;
       if (seen.stage === "error") return outcome({ ok: false, reason: "spawn-failed", url, evidence });
-      if (seen.stage === "exit" && (seen.code !== 0 || seen.signal)) {
+      const exitDecides = seen.stage === "exit" && plan.exitIsEvidence === true;
+      if (exitDecides && (seen.code !== 0 || seen.signal)) {
         return outcome({
           ok: false,
           reason: seen.signal ? "killed-by-signal" : "exit-nonzero",
@@ -5582,8 +6234,29 @@ var require_browser = __commonJS({
           error: FAILURE_TEXT[seen.signal ? "killed-by-signal" : "exit-nonzero"] + "\uFF08" + (seen.signal || seen.code) + "\uFF09"
         });
       }
-      const exitEvidence = seen.stage === "exit" && plan.trustExit;
-      return outcome({ ok: true, confirmed: exitEvidence, handedOff: !exitEvidence, url, evidence });
+      return outcome({ ok: true, confirmed: exitDecides, handedOff: !exitDecides, url, evidence });
+    }
+    function listBrowsers(o) {
+      const ov = o || {};
+      const inv = detector.inventory(ov.platform, { force: ov.force === true });
+      return {
+        ok: true,
+        platform: inv.platform,
+        cached: inv.cached === true,
+        default: inv.defaultId ? { id: inv.defaultId, source: inv.defaultSource || null } : null,
+        browsers: (inv.browsers || []).map((b) => ({
+          id: b.id,
+          name: b.name,
+          engine: b.engine || engineOf(b.bin),
+          bin: b.bin,
+          sources: b.sources && b.sources.length ? b.sources : [b.source],
+          isDefault: b.id === inv.defaultId
+        })),
+        probed: inv.probed || []
+      };
+    }
+    function invalidateBrowsers(platform) {
+      return detector.invalidate(platform);
     }
     function _spawnDetachedIgnored(bin, args) {
       try {
@@ -5614,178 +6287,37 @@ var require_browser = __commonJS({
       child.unref();
       return child;
     }
-    function engineOf(bin) {
-      const base = String(bin || "").toLowerCase().split(/[\\/]/).pop();
-      if (/(chrome|chromium|msedge|edge|brave|vivaldi|opera|thorium)/.test(base)) return "chromium";
-      if (/(firefox|librewolf|waterfox)/.test(base)) return "firefox";
-      return "other";
-    }
-    function tokenizeExec(line) {
-      const toks = [];
-      let cur = "";
-      let q = null;
-      let esc = false;
-      let has = false;
-      for (const ch of String(line)) {
-        if (esc) {
-          cur += ch;
-          esc = false;
-          continue;
-        }
-        if (ch === "\\") {
-          esc = true;
-          has = true;
-          continue;
-        }
-        if (q) {
-          if (ch === q) q = null;
-          else cur += ch;
-          continue;
-        }
-        if (ch === "'" || ch === '"') {
-          q = ch;
-          has = true;
-          continue;
-        }
-        if (/\s/.test(ch)) {
-          if (has) {
-            toks.push(cur);
-            cur = "";
-            has = false;
-          }
-          continue;
-        }
-        cur += ch;
-        has = true;
-      }
-      if (has) toks.push(cur);
-      return toks;
-    }
-    function parseExecLine(line) {
-      let toks = tokenizeExec(line).filter((t) => t !== "%%" && !/^%[a-zA-Z]$/.test(t));
-      if (toks[0] === "env") {
-        let i = 1;
-        while (i < toks.length && /=/.test(toks[i])) i++;
-        toks = toks.slice(i);
-      }
-      if (!toks.length) return null;
-      return { bin: toks[0], baseArgs: toks.slice(1) };
-    }
-    function regValueOf(out) {
-      const m = String(out || "").match(/REG_SZ\s+(.*)/);
-      return m ? m[1].trim() : null;
-    }
-    function exeFromCmdLine(cmdLine) {
-      const s = String(cmdLine || "");
-      let m = s.match(/^\s*"([^"]+\.exe)"/i);
-      if (m) return m[1];
-      m = s.match(/^\s*(\S+\.exe)/i);
-      return m ? m[1] : null;
-    }
-    function resolveDefaultWin(runOut) {
-      const roots = ["HKCU\\Software\\Clients\\StartMenuInternet", "HKLM\\Software\\Clients\\StartMenuInternet"];
-      for (const root of roots) {
-        const progId = regValueOf(runOut("reg.exe", ["query", root, "/ve"]));
-        if (!progId || !/^[\x20-\x7e]+$/.test(progId)) continue;
-        for (const r2 of roots) {
-          const cmd2 = regValueOf(runOut("reg.exe", ["query", r2 + "\\" + progId + "\\shell\\open\\command", "/ve"]));
-          const bin = exeFromCmdLine(cmd2);
-          if (bin) return { bin, baseArgs: [] };
-        }
-      }
-      return null;
-    }
-    var MAC_JXA = [
-      "ObjC.import('CoreServices');ObjC.import('Foundation');",
-      "var b=ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme(null,'https'))||ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme(null,'http'));",
-      "if(!b){'EMPTY';}else{",
-      "var u=$.NSWorkspace.workspace.URLForApplicationWithBundleIdentifier(b);",
-      "if(u.isNil()){'EMPTY';}else{",
-      "var e=ObjC.unwrap($.NSBundle.bundleWithURL(u).objectForInfoDictionaryKey('CFBundleExecutable'));",
-      "b+'\\t'+ObjC.unwrap(u.path)+'\\t'+e;}}"
-    ].join("");
-    function resolveDefaultMac(runOut) {
-      const out = runOut("osascript", ["-l", "JavaScript", "-e", MAC_JXA]);
-      if (!out) return null;
-      const parts = out.trim().split("	");
-      if (parts.length < 3 || parts[0] === "EMPTY" || !parts[2]) return null;
-      return { bin: path2.posix.join(parts[1], "Contents", "MacOS", parts[2]), baseArgs: [], bundleId: parts[0] };
-    }
-    function resolveDefaultLinux(runOut, readFile, exists, env, home) {
-      const id = runOut("xdg-settings", ["get", "default-web-browser"]);
-      const desktop2 = id && id.trim();
-      if (!desktop2 || !/^[A-Za-z0-9._-]+\.desktop$/.test(desktop2)) return null;
-      const dirs = [
-        env.XDG_DATA_HOME || path2.join(home, ".local", "share"),
-        "/usr/local/share",
-        "/usr/share",
-        "/var/lib/snapd/desktop"
-      ].map((d) => path2.join(d, "applications"));
-      for (const dir of dirs) {
-        const p = path2.join(dir, desktop2);
-        let text = null;
-        try {
-          if (exists(p)) text = readFile(p);
-        } catch {
-          continue;
-        }
-        if (text === null) continue;
-        let inMain = false;
-        for (const line of text.split(/\r?\n/)) {
-          if (/^\[Desktop Entry\]\s*$/.test(line)) {
-            inMain = true;
-            continue;
-          }
-          if (/^\[/.test(line)) break;
-          if (inMain) {
-            const m = line.match(/^Exec=(.+)/);
-            if (m) return parseExecLine(m[1]);
-          }
-        }
-      }
-      return null;
-    }
-    function resolveDefaultBrowser(platform, o) {
-      const ov = o || {};
-      const pl = platform || process.platform;
-      const runOut = ov.runOut || ((bin, args) => exec.runOut(bin, args, { timeoutMs: 5e3 }));
-      const readFile = ov.readFile || ((p) => fs2.readFileSync(p, "utf8"));
-      const exists = ov.exists || ((p) => fs2.existsSync(p));
-      const env = ov.env || process.env;
-      const home = ov.home || os2.homedir();
-      try {
-        if (pl === "win32") return resolveDefaultWin(runOut);
-        if (pl === "darwin") return resolveDefaultMac(runOut);
-        return resolveDefaultLinux(runOut, readFile, exists, env, home);
-      } catch {
-        return null;
-      }
-    }
     function isolatedPlan(platform, url, opts) {
       const o = opts || {};
       const pl = platform || process.platform;
-      const db = o.defaultBrowser;
-      const engine = db && db.bin ? engineOf(db.bin) : "other";
-      const baseArgs = db && db.baseArgs || [];
-      if (engine === "chromium" && o.profileDir) {
+      const picked = o.pick || pickLauncher(pl, o.inventory);
+      const b = picked.browser;
+      const form = formOfBin(pl, b);
+      const baseArgs = b && b.baseArgs || [];
+      if (form.direct && form.engine === "chromium" && o.profileDir) {
         const args = ["--incognito", "--user-data-dir=" + o.profileDir];
         if (Array.isArray(o.size) && o.size.length === 2) args.push("--window-size=" + o.size[0] + "," + o.size[1]);
         if (o.lang) args.push("--lang=" + o.lang);
         args.push("--no-first-run", "--no-default-browser-check", "--disable-session-crashed-bubble");
-        return { bin: db.bin, args: [...baseArgs, ...args, url], isolated: true, watch: true, envKind: "anti", label: "chromium" };
+        return { bin: b.bin, args: [...baseArgs, ...args, url], isolated: true, watch: true, envKind: "anti", label: "chromium", pick: picked.how };
       }
-      if (engine === "firefox" && o.profileDir) {
+      if (form.direct && form.engine === "firefox" && o.profileDir) {
         return {
-          bin: db.bin,
+          bin: b.bin,
           args: [...baseArgs, "--no-remote", "--profile", o.profileDir, "-private-window", url],
           isolated: true,
           watch: true,
           envKind: "anti",
-          label: "firefox"
+          label: "firefox",
+          pick: picked.how
         };
       }
+      if (form.direct) {
+        return { bin: b.bin, args: baseArgs.concat([url]), isolated: false, watch: false, envKind: "sys", label: path2.basename(b.bin), pick: picked.how };
+      }
       const c = openCommand(pl, url);
-      return { bin: c.cmd, args: c.args, isolated: false, watch: false, envKind: "sys", label: c.cmd };
+      if (!c) return { bin: null, args: [url], isolated: false, watch: false, envKind: "sys", label: null, pick: picked.how };
+      return { bin: c.cmd, args: c.args, isolated: false, watch: false, envKind: "sys", label: c.cmd, pick: picked.how };
     }
     function binAvailable(bin) {
       if (!bin) return false;
@@ -5802,21 +6334,21 @@ var require_browser = __commonJS({
       const spawnWith = typeof opts.spawn === "function" ? opts.spawn : _spawnDetached;
       const fail = (reason, extra) => Object.assign(outcome(Object.assign({ ok: false, reason, url }, extra)), { bin: null, isolated: false });
       try {
-        let db;
-        if ("defaultBrowser" in opts) db = opts.defaultBrowser;
-        else if (typeof opts.resolveDefault === "function") db = opts.resolveDefault(process.platform, opts.resolveDeps || {});
-        else db = resolveDefaultBrowser(process.platform, opts.resolveDeps || {});
+        const resolveInv = typeof opts.resolveInventory === "function" ? opts.resolveInventory : ((platform, deps) => detector.inventory(platform, deps));
+        const inv = "inventory" in opts ? opts.inventory : resolveInv(process.platform, opts.resolveDeps || {});
         const plan = isolatedPlan(process.platform, url, {
-          defaultBrowser: db,
+          inventory: inv,
+          pick: opts.pick,
           profileDir: opts.profileDir,
           size: opts.size,
           lang: opts.lang
         });
-        if (!avail(plan.bin)) return fail("no-launcher", { evidence: { bin: plan.bin, engine: plan.label, via: plan.isolated ? "browser" : "dispatcher" } });
+        const evidence = { bin: plan.bin, engine: plan.label, via: plan.isolated ? "browser" : "dispatcher", diagnostics: launchDiagnostics(inv, plan, plan.pick) };
+        if (!avail(plan.bin)) return fail("no-launcher", { evidence });
         const env = plan.envKind === "anti" ? antiEnv : sysEnv;
         const p = spawnWith(plan.bin, plan.args, env, plan.watch ? onExit : void 0);
-        if (!p) return fail("spawn-failed");
-        return Object.assign(outcome({ ok: true, confirmed: false, handedOff: true, url }), { bin: plan.label, isolated: plan.isolated });
+        if (!p) return fail("spawn-failed", { evidence });
+        return Object.assign(outcome({ ok: true, confirmed: false, handedOff: true, url, evidence }), { bin: plan.label, isolated: plan.isolated });
       } catch (e) {
         return fail("spawn-failed", { error: FAILURE_TEXT["spawn-failed"] + "\uFF08" + (e && e.code || e) + "\uFF09" });
       }
@@ -5827,18 +6359,18 @@ var require_browser = __commonJS({
       openCommand,
       openPlan,
       isolatedPlan,
+      pickLauncher,
+      ownsItsWindow,
       observeSpawn,
       isSafeHttpUrl,
-      resolveDefaultBrowser,
-      resolveDefaultWin,
-      resolveDefaultMac,
-      resolveDefaultLinux,
+      binAvailable,
+      listBrowsers,
+      invalidateBrowsers,
+      launchDiagnostics,
+      // 探测层的解析原语经此转出（唯一实现处在 ./browser-inventory.js）：门禁与消费方按同一出口取用，
+      //   不在别处再写第二份平台解析。
       engineOf,
-      parseExecLine,
-      tokenizeExec,
-      regValueOf,
-      exeFromCmdLine,
-      binAvailable
+      detector
     };
   }
 });
@@ -17684,44 +18216,13 @@ var require_browser2 = __commonJS({
   "src/domains/router/ops/browser.js"(exports2, module2) {
     "use strict";
     var platform = require_os();
+    var desktop = require_desktop();
     var fs2 = require("node:fs");
     var os2 = require("node:os");
     var path2 = require("node:path");
     var crypto = require("node:crypto");
     function graphicalEnv() {
-      const out = {};
-      try {
-        const uid = process.getuid ? String(process.getuid()) : "";
-        const xdgRun = process.env.XDG_RUNTIME_DIR || "/run/user/" + uid;
-        if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
-          const x11 = "/tmp/.X11-unix";
-          try {
-            if (fs2.existsSync(x11)) {
-              const socks = fs2.readdirSync(x11).filter((f) => /^X\d+$/.test(f)).map((f) => parseInt(f.slice(1), 10)).sort((a, b) => a - b);
-              if (socks.length > 0) {
-                out.DISPLAY = ":" + socks[0];
-                const xauth = path2.join(os2.homedir(), ".Xauthority");
-                if (fs2.existsSync(xauth)) out.XAUTHORITY = xauth;
-              }
-            }
-          } catch {
-          }
-          if (!out.DISPLAY) {
-            try {
-              if (fs2.existsSync(xdgRun)) {
-                const wl = fs2.readdirSync(xdgRun).filter((f) => f.startsWith("wayland-")).sort();
-                if (wl.length > 0) out.WAYLAND_DISPLAY = wl[0];
-              }
-            } catch {
-            }
-          }
-        }
-        if (!process.env.DBUS_SESSION_BUS_ADDRESS && fs2.existsSync(path2.join(xdgRun, "bus"))) {
-          out.DBUS_SESSION_BUS_ADDRESS = "unix:path=" + path2.join(xdgRun, "bus");
-        }
-      } catch {
-      }
-      return out;
+      return desktop.sessionEnv();
     }
     function openInBrowser(url, onExit) {
       try {
@@ -17960,6 +18461,7 @@ var require_oauth = __commonJS({
             confirmed: false,
             handedOff: false,
             reason: evidence.reason || "no-launcher",
+            evidence: evidence.evidence || null,
             error: (evidence.error || "\u65E0\u6CD5\u8C03\u8D77\u7CFB\u7EDF\u6D4F\u89C8\u5668") + "\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u4E0B\u65B9\u5730\u5740\u5B8C\u6210\u6388\u6743"
           };
         }
@@ -25507,7 +26009,7 @@ var require_guard = __commonJS({
     var fs2 = require("node:fs");
     var path2 = require("node:path");
     function owns(pathname) {
-      return pathname === "/changelog" || pathname.startsWith("/guard/") || pathname === "/autostart" || pathname.startsWith("/settings/") || pathname.startsWith("/self-update/") || pathname === "/env/dsh" || pathname === "/env/status" || pathname === "/env/node-lts" || pathname === "/env/open-url" || pathname === "/ports" || pathname === "/shutdown";
+      return pathname === "/changelog" || pathname.startsWith("/guard/") || pathname === "/autostart" || pathname.startsWith("/settings/") || pathname.startsWith("/self-update/") || pathname === "/env/dsh" || pathname === "/env/status" || pathname === "/env/node-lts" || pathname === "/env/open-url" || pathname === "/env/browsers" || pathname === "/ports" || pathname === "/shutdown";
     }
     function fetchDshChangelog(res, sup) {
       const v = sup && sup.nativeManager ? sup.nativeManager.versionInfo() : {};
@@ -25683,6 +26185,14 @@ var require_guard = __commonJS({
       if (req.method === "GET" && pathname === "/env/node-lts") {
         return sup.nodeLtsStatus().then((r) => send(200, r)).catch((e) => send(500, { ok: false, error: e.message }));
       }
+      if (req.method === "GET" && pathname === "/env/browsers") {
+        if (!originAllowed(req, sup.config.apiPort)) {
+          req.resume();
+          return send(403, { ok: false, error: "cross-origin request rejected" });
+        }
+        const force = /[?&]force=1/.test(req.url || "");
+        return Promise.resolve(browser.listBrowsers({ force })).then((r) => send(200, r)).catch((e) => send(500, { ok: false, error: "\u6D4F\u89C8\u5668\u63A2\u6D4B\u5931\u8D25\uFF1A" + (e && e.message || e) }));
+      }
       if (req.method === "POST" && pathname === "/env/open-url") {
         if (!identity.loopback) {
           req.resume();