opensteer 0.6.11 → 0.6.13

package/dist/{chunk-JZF2WC7U.js → chunk-HBTSQ2V4.js}

@@ -25,284 +25,2655 @@ import {
 } from "./chunk-3H5RRIMZ.js";
 
 // src/browser/persistent-profile.ts
-import { createHash } from "crypto";
-import { existsSync } from "fs";
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { createReadStream, existsSync as existsSync3 } from "fs";
 import {
   cp,
   copyFile,
-  mkdir,
+  mkdir as mkdir3,
   mkdtemp,
-  readdir,
-  rename,
-  rm,
+  readdir as readdir2,
+  readFile as readFile4,
+  rename as rename3,
+  rm as rm3,
   stat,
-  writeFile
+  writeFile as writeFile3
 } from "fs/promises";
-import { homedir } from "os";
-import { basename, dirname, join } from "path";
-var OPENSTEER_META_FILE = ".opensteer-meta.json";
+import { homedir, tmpdir } from "os";
+import { basename as basename3, dirname as dirname4, join as join4, relative, sep } from "path";
+import { promisify as promisify2 } from "util";
+
+// src/browser/persistent-profile-coordination.ts
+import { basename, dirname as dirname2, join as join2 } from "path";
+
+// src/browser/dir-lock.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+
+// src/browser/process-owner.ts
+import { execFile } from "child_process";
+import { readFile } from "fs/promises";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 var PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
 var PROCESS_START_TIME_TOLERANCE_MS = 1e3;
-var CHROME_SINGLETON_ENTRIES = /* @__PURE__ */ new Set([
-  "SingletonCookie",
-  "SingletonLock",
-  "SingletonSocket",
-  "DevToolsActivePort",
-  "lockfile"
-]);
-var COPY_SKIP_ENTRIES = /* @__PURE__ */ new Set([
-  ...CHROME_SINGLETON_ENTRIES,
-  OPENSTEER_META_FILE
-]);
-var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
-  "Crash Reports",
-  "Crashpad",
-  "BrowserMetrics",
-  "GrShaderCache",
-  "ShaderCache",
-  "GraphiteDawnCache",
-  "component_crx_cache",
-  "Crowd Deny",
-  "hyphen-data",
-  "OnDeviceHeadSuggestModel",
-  "OptimizationGuidePredictionModels",
-  "Segmentation Platform",
-  "SmartCardDeviceNames",
-  "WidevineCdm",
-  "pnacl"
-]);
-async function getOrCreatePersistentProfile(sourceUserDataDir, profileDirectory, profilesRootDir = defaultPersistentProfilesRootDir()) {
-  const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
-  const targetUserDataDir = join(
-    expandHome(profilesRootDir),
-    buildPersistentProfileKey(resolvedSourceUserDataDir, profileDirectory)
-  );
-  const sourceProfileDir = join(resolvedSourceUserDataDir, profileDirectory);
-  const metadata = buildPersistentProfileMetadata(
-    resolvedSourceUserDataDir,
-    profileDirectory
-  );
-  await mkdir(dirname(targetUserDataDir), { recursive: true });
-  await cleanOrphanedTempDirs(
-    dirname(targetUserDataDir),
-    basename(targetUserDataDir)
-  );
-  if (!existsSync(sourceProfileDir)) {
-    throw new Error(
-      `Chrome profile "${profileDirectory}" was not found in "${resolvedSourceUserDataDir}".`
-    );
+var PROCESS_LIST_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+var PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+var LINUX_STAT_START_TIME_FIELD_INDEX = 19;
+var CURRENT_PROCESS_OWNER = {
+  pid: process.pid,
+  processStartedAtMs: PROCESS_STARTED_AT_MS
+};
+var linuxClockTicksPerSecondPromise = null;
+function parseProcessOwner(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const pid = Number(parsed.pid);
+  const processStartedAtMs = Number(parsed.processStartedAtMs);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
   }
-  const created = await createPersistentProfileClone(
-    resolvedSourceUserDataDir,
-    sourceProfileDir,
-    targetUserDataDir,
-    profileDirectory,
-    metadata
-  );
-  await ensurePersistentProfileMetadata(targetUserDataDir, metadata);
   return {
-    created,
-    userDataDir: targetUserDataDir
+    pid,
+    processStartedAtMs
   };
 }
-async function clearPersistentProfileSingletons(userDataDir) {
-  await Promise.all(
-    [...CHROME_SINGLETON_ENTRIES].map(
-      (entry) => rm(join(userDataDir, entry), {
-        force: true,
-        recursive: true
-      }).catch(() => void 0)
-    )
-  );
+function processOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
 }
-function buildPersistentProfileKey(sourceUserDataDir, profileDirectory) {
-  const hash = createHash("sha256").update(`${sourceUserDataDir}\0${profileDirectory}`).digest("hex").slice(0, 16);
-  const sourceLabel = sanitizePathSegment(basename(sourceUserDataDir) || "user-data");
-  const profileLabel = sanitizePathSegment(profileDirectory || "Default");
-  return `${sourceLabel}-${profileLabel}-${hash}`;
+async function getProcessLiveness(owner) {
+  if (owner.pid === process.pid && hasMatchingProcessStartTime(
+    owner.processStartedAtMs,
+    PROCESS_STARTED_AT_MS
+  )) {
+    return "live";
+  }
+  const startedAtMs = await readProcessStartedAtMs(owner.pid);
+  if (typeof startedAtMs === "number") {
+    return hasMatchingProcessStartTime(
+      owner.processStartedAtMs,
+      startedAtMs
+    ) ? "live" : "dead";
+  }
+  return isProcessRunning(owner.pid) ? "unknown" : "dead";
 }
-function defaultPersistentProfilesRootDir() {
-  return join(homedir(), ".opensteer", "real-browser-profiles");
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+    return code !== "ESRCH";
+  }
 }
-function sanitizePathSegment(value) {
-  const sanitized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-");
-  return sanitized.replace(/^-|-$/g, "") || "profile";
+async function readProcessOwner(pid) {
+  const processStartedAtMs = await readProcessStartedAtMs(pid);
+  if (processStartedAtMs === null) {
+    return null;
+  }
+  return {
+    pid,
+    processStartedAtMs
+  };
 }
-function isProfileDirectory(userDataDir, entry) {
-  return existsSync(join(userDataDir, entry, "Preferences"));
+function hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
 }
-async function copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, targetProfileDirectory) {
-  let entries;
+async function readProcessStartedAtMs(pid) {
+  if (pid <= 0) {
+    return null;
+  }
+  if (process.platform === "linux") {
+    return await readLinuxProcessStartedAtMs(pid);
+  }
+  if (process.platform === "win32") {
+    return await readWindowsProcessStartedAtMs(pid);
+  }
+  return await readPsProcessStartedAtMs(pid);
+}
+async function readLinuxProcessStartedAtMs(pid) {
+  let statRaw;
   try {
-    entries = await readdir(sourceUserDataDir);
+    statRaw = await readFile(`/proc/${pid}/stat`, "utf8");
   } catch {
-    return;
+    return null;
   }
-  const copyTasks = [];
-  for (const entry of entries) {
-    if (COPY_SKIP_ENTRIES.has(entry)) continue;
-    if (entry === targetProfileDirectory) continue;
-    const sourcePath = join(sourceUserDataDir, entry);
-    const targetPath = join(targetUserDataDir, entry);
-    if (existsSync(targetPath)) continue;
-    let entryStat;
-    try {
-      entryStat = await stat(sourcePath);
-    } catch {
-      continue;
-    }
-    if (entryStat.isFile()) {
-      copyTasks.push(copyFile(sourcePath, targetPath).catch(() => void 0));
-    } else if (entryStat.isDirectory()) {
-      if (isProfileDirectory(sourceUserDataDir, entry)) continue;
-      if (SKIPPED_ROOT_DIRECTORIES.has(entry)) continue;
-      copyTasks.push(
-        cp(sourcePath, targetPath, { recursive: true }).catch(
-          () => void 0
-        )
-      );
-    }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
   }
-  await Promise.all(copyTasks);
-}
-async function writePersistentProfileMetadata(userDataDir, metadata) {
-  await writeFile(
-    join(userDataDir, OPENSTEER_META_FILE),
-    JSON.stringify(metadata, null, 2)
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(
+    bootTimeMs + startTicks * 1e3 / clockTicksPerSecond
   );
 }
-function buildPersistentProfileMetadata(sourceUserDataDir, profileDirectory) {
-  return {
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    profileDirectory,
-    source: sourceUserDataDir
-  };
+function parseLinuxProcessStartTicks(statRaw) {
+  const closingParenIndex = statRaw.lastIndexOf(")");
+  if (closingParenIndex === -1) {
+    return null;
+  }
+  const fields = statRaw.slice(closingParenIndex + 2).trim().split(/\s+/);
+  const startTicks = Number(fields[LINUX_STAT_START_TIME_FIELD_INDEX]);
+  return Number.isFinite(startTicks) && startTicks >= 0 ? startTicks : null;
 }
-async function createPersistentProfileClone(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
-  if (existsSync(targetUserDataDir)) {
-    return false;
+async function readLinuxBootTimeMs() {
+  try {
+    const statRaw = await readFile("/proc/stat", "utf8");
+    const bootTimeLine = statRaw.split("\n").find((line) => line.startsWith("btime "));
+    if (!bootTimeLine) {
+      return null;
+    }
+    const bootTimeSeconds = Number.parseInt(
+      bootTimeLine.slice("btime ".length),
+      10
+    );
+    return Number.isFinite(bootTimeSeconds) ? bootTimeSeconds * 1e3 : null;
+  } catch {
+    return null;
   }
-  const tempUserDataDir = await mkdtemp(
-    buildPersistentProfileTempDirPrefix(targetUserDataDir)
-  );
-  let published = false;
+}
+async function readLinuxClockTicksPerSecond() {
+  if (!linuxClockTicksPerSecondPromise) {
+    linuxClockTicksPerSecondPromise = execFileAsync("getconf", ["CLK_TCK"], {
+      encoding: "utf8",
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    }).then(({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    }).catch(() => null);
+  }
+  return await linuxClockTicksPerSecondPromise;
+}
+async function readWindowsProcessStartedAtMs(pid) {
   try {
-    await cp(sourceProfileDir, join(tempUserDataDir, profileDirectory), {
-      recursive: true
-    });
-    await copyRootLevelEntries(
-      sourceUserDataDir,
-      tempUserDataDir,
-      profileDirectory
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${pid}).StartTime.ToUniversalTime().ToString("o")`
+      ],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+      }
     );
-    await writePersistentProfileMetadata(tempUserDataDir, metadata);
-    try {
-      await rename(tempUserDataDir, targetUserDataDir);
-    } catch (error) {
-      if (wasProfilePublishedByAnotherProcess(error, targetUserDataDir)) {
-        return false;
+    const isoTimestamp = stdout.trim();
+    if (!isoTimestamp) {
+      return null;
+    }
+    const startedAtMs = Date.parse(isoTimestamp);
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+async function readPsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ps",
+      ["-o", "lstart=", "-p", String(pid)],
+      {
+        encoding: "utf8",
+        env: PS_COMMAND_ENV,
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
       }
-      throw error;
+    );
+    const startedAt = stdout.trim();
+    if (!startedAt) {
+      return null;
     }
-    published = true;
-    return true;
+    const startedAtMs = Date.parse(startedAt.replace(/\s+/g, " "));
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/browser/dir-lock.ts
+var LOCK_OWNER_FILE = "owner.json";
+var LOCK_RECLAIMER_DIR = "reclaimer";
+var LOCK_RETRY_DELAY_MS = 50;
+async function withDirLock(lockDirPath, action) {
+  const releaseLock = await acquireDirLock(lockDirPath);
+  try {
+    return await action();
   } finally {
-    if (!published) {
-      await rm(tempUserDataDir, {
+    await releaseLock();
+  }
+}
+async function acquireDirLock(lockDirPath) {
+  while (true) {
+    const releaseLock = await tryAcquireDirLock(lockDirPath);
+    if (releaseLock) {
+      return releaseLock;
+    }
+    await sleep(LOCK_RETRY_DELAY_MS);
+  }
+}
+async function tryAcquireDirLock(lockDirPath) {
+  await mkdir(dirname(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-${randomUUID()}`;
+    try {
+      await mkdir(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await rename(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await rm(tempLockDirPath, {
         recursive: true,
         force: true
       }).catch(() => void 0);
     }
+    const owner = await readLockOwner(lockDirPath);
+    if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+      continue;
+    }
+    return null;
   }
+  return async () => {
+    await rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  };
 }
-async function ensurePersistentProfileMetadata(userDataDir, metadata) {
-  if (existsSync(join(userDataDir, OPENSTEER_META_FILE))) {
-    return;
+async function isDirLockHeld(lockDirPath) {
+  if (!existsSync(lockDirPath)) {
+    return false;
   }
-  await writePersistentProfileMetadata(userDataDir, metadata);
+  const owner = await readLockOwner(lockDirPath);
+  if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+    return false;
+  }
+  return existsSync(lockDirPath);
 }
-function wasProfilePublishedByAnotherProcess(error, targetUserDataDir) {
-  const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
-  return existsSync(targetUserDataDir) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
 }
-function buildPersistentProfileTempDirPrefix(targetUserDataDir) {
-  return join(
-    dirname(targetUserDataDir),
-    `${basename(targetUserDataDir)}-tmp-${process.pid}-${PROCESS_STARTED_AT_MS}-`
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
+  const code = getErrorCode(error);
+  return existsSync(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function writeLockOwner(lockDirPath, owner) {
+  await writeFile(join(lockDirPath, LOCK_OWNER_FILE), JSON.stringify(owner));
+}
+async function readLockOwner(lockDirPath) {
+  return await readLockParticipant(join(lockDirPath, LOCK_OWNER_FILE));
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockParticipantRecord(filePath) {
+  try {
+    const raw = await readFile2(filePath, "utf8");
+    const owner = parseProcessOwner(JSON.parse(raw));
+    return {
+      exists: true,
+      owner
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
+  }
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return await readLockParticipantRecord(
+    join(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE)
   );
 }
-async function cleanOrphanedTempDirs(profilesDir, targetBaseName) {
-  let entries;
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
+    return false;
+  }
+  let reclaimed = false;
   try {
-    entries = await readdir(profilesDir, {
-      encoding: "utf8",
-      withFileTypes: true
-    });
-  } catch {
-    return;
+    const owner = await readLockOwner(lockDirPath);
+    if (!processOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !existsSync(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await rm(buildLockReclaimerDirPath(lockDirPath), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
   }
-  const tempDirPrefix = `${targetBaseName}-tmp-`;
-  await Promise.all(
-    entries.map(async (entry) => {
-      if (!entry.isDirectory() || !entry.name.startsWith(tempDirPrefix)) {
-        return;
+}
+async function tryAcquireLockReclaimer(lockDirPath) {
+  const reclaimerDirPath = buildLockReclaimerDirPath(lockDirPath);
+  while (true) {
+    const tempReclaimerDirPath = `${reclaimerDirPath}-${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-${randomUUID()}`;
+    try {
+      await mkdir(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await rename(tempReclaimerDirPath, reclaimerDirPath);
+        return true;
+      } catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+          return false;
+        }
+        if (!wasDirPublishedByAnotherProcess(error, reclaimerDirPath)) {
+          throw error;
+        }
       }
-      if (isTempDirOwnedByLiveProcess(entry.name, tempDirPrefix)) {
-        return;
+    } catch (error) {
+      const code = getErrorCode(error);
+      if (code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    } finally {
+      await rm(tempReclaimerDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const reclaimerRecord = await readLockReclaimerRecord(lockDirPath);
+    if (!reclaimerRecord.exists || !reclaimerRecord.owner) {
+      return false;
+    }
+    if (await getProcessLiveness(reclaimerRecord.owner) !== "dead") {
+      return false;
+    }
+    await rm(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return join(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/persistent-profile-coordination.ts
+var PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS = 50;
+async function withPersistentProfileControlLock(targetUserDataDir, action) {
+  return await withDirLock(
+    buildPersistentProfileControlLockDirPath(targetUserDataDir),
+    action
+  );
+}
+async function acquirePersistentProfileWriteLock(targetUserDataDir) {
+  const controlLockDirPath = buildPersistentProfileControlLockDirPath(targetUserDataDir);
+  const writeLockDirPath = buildPersistentProfileWriteLockDirPath(
+    targetUserDataDir
+  );
+  while (true) {
+    let releaseWriteLock = null;
+    const releaseControlLock = await acquireDirLock(controlLockDirPath);
+    try {
+      releaseWriteLock = await tryAcquireDirLock(writeLockDirPath);
+    } finally {
+      await releaseControlLock();
+    }
+    if (releaseWriteLock) {
+      return releaseWriteLock;
+    }
+    await sleep2(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+async function isPersistentProfileWriteLocked(targetUserDataDir) {
+  return await isDirLockHeld(
+    buildPersistentProfileWriteLockDirPath(targetUserDataDir)
+  );
+}
+function buildPersistentProfileWriteLockDirPath(targetUserDataDir) {
+  return join2(dirname2(targetUserDataDir), `${basename(targetUserDataDir)}.lock`);
+}
+function buildPersistentProfileControlLockDirPath(targetUserDataDir) {
+  return join2(
+    dirname2(targetUserDataDir),
+    `${basename(targetUserDataDir)}.control.lock`
+  );
+}
+async function sleep2(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/shared-real-browser-session-state.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, readdir, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, join as join3 } from "path";
+var SHARED_SESSION_METADATA_FILE = "session.json";
+var SHARED_SESSION_CLIENTS_DIR = "clients";
+var SHARED_SESSION_RETRY_DELAY_MS = 50;
+var SHARED_SESSION_METADATA_TEMP_FILE_PREFIX = `${SHARED_SESSION_METADATA_FILE}.`;
+var SHARED_SESSION_METADATA_TEMP_FILE_SUFFIX = ".tmp";
+function buildSharedSessionDirPath(persistentUserDataDir) {
+  return join3(
+    dirname3(persistentUserDataDir),
+    `${basename2(persistentUserDataDir)}.session`
+  );
+}
+function buildSharedSessionLockPath(persistentUserDataDir) {
+  return `${buildSharedSessionDirPath(persistentUserDataDir)}.lock`;
+}
+function buildSharedSessionClientsDirPath(persistentUserDataDir) {
+  return join3(
+    buildSharedSessionDirPath(persistentUserDataDir),
+    SHARED_SESSION_CLIENTS_DIR
+  );
+}
+function buildSharedSessionClientPath(persistentUserDataDir, clientId) {
+  return join3(
+    buildSharedSessionClientsDirPath(persistentUserDataDir),
+    `${clientId}.json`
+  );
+}
+async function readSharedSessionMetadata(persistentUserDataDir) {
+  return (await readSharedSessionMetadataRecord(persistentUserDataDir)).metadata;
+}
+async function writeSharedSessionMetadata(persistentUserDataDir, metadata) {
+  const sessionDirPath = buildSharedSessionDirPath(persistentUserDataDir);
+  const metadataPath = buildSharedSessionMetadataPath(persistentUserDataDir);
+  const tempPath = buildSharedSessionMetadataTempPath(sessionDirPath);
+  await mkdir2(sessionDirPath, { recursive: true });
+  try {
+    await writeFile2(tempPath, JSON.stringify(metadata, null, 2));
+    await rename2(tempPath, metadataPath);
+  } finally {
+    await rm2(tempPath, { force: true }).catch(() => void 0);
+  }
+}
+async function hasLiveSharedRealBrowserSession(persistentUserDataDir) {
+  const sessionDirPath = buildSharedSessionDirPath(persistentUserDataDir);
+  const metadataRecord = await readSharedSessionMetadataRecord(
+    persistentUserDataDir
+  );
+  if (!metadataRecord.exists) {
+    return await hasLiveSharedSessionPublisherOrClients(sessionDirPath);
+  }
+  if (!metadataRecord.metadata) {
+    return true;
+  }
+  if (await getProcessLiveness(metadataRecord.metadata.browserOwner) === "dead") {
+    await rm2(sessionDirPath, {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    return false;
+  }
+  return true;
+}
+async function waitForSharedRealBrowserSessionToDrain(persistentUserDataDir) {
+  while (true) {
+    if (!await hasLiveSharedRealBrowserSession(persistentUserDataDir)) {
+      return;
+    }
+    await sleep3(SHARED_SESSION_RETRY_DELAY_MS);
+  }
+}
+async function readSharedSessionMetadataRecord(persistentUserDataDir) {
+  try {
+    const raw = await readFile3(
+      buildSharedSessionMetadataPath(persistentUserDataDir),
+      "utf8"
+    );
+    return {
+      exists: true,
+      metadata: parseSharedSessionMetadata(JSON.parse(raw))
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode2(error) !== "ENOENT",
+      metadata: null
+    };
+  }
+}
+async function hasLiveSharedSessionPublisherOrClients(sessionDirPath) {
+  if (!existsSync2(sessionDirPath)) {
+    return false;
+  }
+  let entries;
+  try {
+    entries = await readDirNames(sessionDirPath);
+  } catch (error) {
+    return getErrorCode2(error) !== "ENOENT";
+  }
+  let hasUnknownEntries = false;
+  for (const entry of entries) {
+    if (entry === SHARED_SESSION_METADATA_FILE) {
+      return true;
+    }
+    if (entry === SHARED_SESSION_CLIENTS_DIR) {
+      if (await hasDirectoryEntries(join3(sessionDirPath, entry))) {
+        return true;
+      }
+      continue;
+    }
+    const owner = parseSharedSessionMetadataTempOwner(entry);
+    if (!owner) {
+      if (isSharedSessionMetadataTempFile(entry)) {
+        continue;
+      }
+      hasUnknownEntries = true;
+      continue;
+    }
+    if (await getProcessLiveness(owner) !== "dead") {
+      return true;
+    }
+  }
+  if (hasUnknownEntries) {
+    return true;
+  }
+  await rm2(sessionDirPath, {
+    force: true,
+    recursive: true
+  }).catch(() => void 0);
+  return false;
+}
+function buildSharedSessionMetadataPath(persistentUserDataDir) {
+  return join3(
+    buildSharedSessionDirPath(persistentUserDataDir),
+    SHARED_SESSION_METADATA_FILE
+  );
+}
+function buildSharedSessionMetadataTempPath(sessionDirPath) {
+  return join3(
+    sessionDirPath,
+    [
+      SHARED_SESSION_METADATA_FILE,
+      CURRENT_PROCESS_OWNER.pid,
+      CURRENT_PROCESS_OWNER.processStartedAtMs,
+      randomUUID2(),
+      "tmp"
+    ].join(".")
+  );
+}
+function parseSharedSessionMetadata(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const browserOwner = parseProcessOwner(parsed.browserOwner);
+  const stateOwner = parseProcessOwner(parsed.stateOwner);
+  const state = parsed.state === "launching" || parsed.state === "ready" || parsed.state === "closing" ? parsed.state : null;
+  if (!browserOwner || !stateOwner || typeof parsed.createdAt !== "string" || typeof parsed.debugPort !== "number" || typeof parsed.executablePath !== "string" || typeof parsed.headless !== "boolean" || typeof parsed.persistentUserDataDir !== "string" || typeof parsed.profileDirectory !== "string" || typeof parsed.sessionId !== "string" || !state) {
+    return null;
+  }
+  return {
+    browserOwner,
+    createdAt: parsed.createdAt,
+    debugPort: parsed.debugPort,
+    executablePath: parsed.executablePath,
+    headless: parsed.headless,
+    persistentUserDataDir: parsed.persistentUserDataDir,
+    profileDirectory: parsed.profileDirectory,
+    sessionId: parsed.sessionId,
+    state,
+    stateOwner
+  };
+}
+function parseSharedSessionMetadataTempOwner(entryName) {
+  if (!isSharedSessionMetadataTempFile(entryName)) {
+    return null;
+  }
+  const segments = entryName.split(".");
+  if (segments.length < 5) {
+    return null;
+  }
+  return parseProcessOwner({
+    pid: Number.parseInt(segments[2] ?? "", 10),
+    processStartedAtMs: Number.parseInt(segments[3] ?? "", 10)
+  });
+}
+function isSharedSessionMetadataTempFile(entryName) {
+  return entryName.startsWith(SHARED_SESSION_METADATA_TEMP_FILE_PREFIX) && entryName.endsWith(SHARED_SESSION_METADATA_TEMP_FILE_SUFFIX);
+}
+function getErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+async function hasDirectoryEntries(dirPath) {
+  try {
+    return (await readDirNames(dirPath)).length > 0;
+  } catch (error) {
+    return getErrorCode2(error) !== "ENOENT";
+  }
+}
+async function readDirNames(dirPath) {
+  return await readdir(dirPath, { encoding: "utf8" });
+}
+async function sleep3(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/persistent-profile.ts
+var execFileAsync2 = promisify2(execFile2);
+var OPENSTEER_META_FILE = ".opensteer-meta.json";
+var OPENSTEER_RUNTIME_META_FILE = ".opensteer-runtime.json";
+var OPENSTEER_RUNTIME_CREATING_FILE = ".opensteer-runtime-creating.json";
+var PROCESS_LIST_MAX_BUFFER_BYTES2 = 16 * 1024 * 1024;
+var PS_COMMAND_ENV2 = { ...process.env, LC_ALL: "C" };
+var CHROME_SINGLETON_ENTRIES = /* @__PURE__ */ new Set([
+  "SingletonCookie",
+  "SingletonLock",
+  "SingletonSocket",
+  "DevToolsActivePort",
+  "lockfile"
+]);
+var COPY_SKIP_ENTRIES = /* @__PURE__ */ new Set([
+  ...CHROME_SINGLETON_ENTRIES,
+  OPENSTEER_META_FILE,
+  OPENSTEER_RUNTIME_META_FILE,
+  OPENSTEER_RUNTIME_CREATING_FILE
+]);
+var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
+  "Crash Reports",
+  "Crashpad",
+  "BrowserMetrics",
+  "GrShaderCache",
+  "ShaderCache",
+  "GraphiteDawnCache",
+  "component_crx_cache",
+  "Crowd Deny",
+  "hyphen-data",
+  "OnDeviceHeadSuggestModel",
+  "OptimizationGuidePredictionModels",
+  "Segmentation Platform",
+  "SmartCardDeviceNames",
+  "WidevineCdm",
+  "pnacl"
+]);
+async function getOrCreatePersistentProfile(sourceUserDataDir, profileDirectory, profilesRootDir = defaultPersistentProfilesRootDir()) {
+  const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
+  const targetUserDataDir = join4(
+    expandHome(profilesRootDir),
+    buildPersistentProfileKey(resolvedSourceUserDataDir, profileDirectory)
+  );
+  const sourceProfileDir = join4(resolvedSourceUserDataDir, profileDirectory);
+  const metadata = buildPersistentProfileMetadata(
+    resolvedSourceUserDataDir,
+    profileDirectory
+  );
+  await mkdir3(dirname4(targetUserDataDir), { recursive: true });
+  if (await isHealthyPersistentProfile(
+    targetUserDataDir,
+    resolvedSourceUserDataDir,
+    profileDirectory
+  ) && !await isPersistentProfileWriteLocked(targetUserDataDir)) {
+    return {
+      created: false,
+      userDataDir: targetUserDataDir
+    };
+  }
+  return await withPersistentProfileWriteAccess(targetUserDataDir, async () => {
+    await recoverPersistentProfileBackup(targetUserDataDir);
+    await cleanOrphanedOwnedDirs(
+      dirname4(targetUserDataDir),
+      buildPersistentProfileTempDirNamePrefix(targetUserDataDir)
+    );
+    if (!existsSync3(sourceProfileDir)) {
+      throw new Error(
+        `Chrome profile "${profileDirectory}" was not found in "${resolvedSourceUserDataDir}".`
+      );
+    }
+    const created = await createPersistentProfileClone(
+      resolvedSourceUserDataDir,
+      sourceProfileDir,
+      targetUserDataDir,
+      profileDirectory,
+      metadata
+    );
+    await ensurePersistentProfileMetadata(targetUserDataDir, metadata);
+    return {
+      created,
+      userDataDir: targetUserDataDir
+    };
+  });
+}
+async function clearPersistentProfileSingletons(userDataDir) {
+  await Promise.all(
+    [...CHROME_SINGLETON_ENTRIES].map(
+      (entry) => rm3(join4(userDataDir, entry), {
+        force: true,
+        recursive: true
+      }).catch(() => void 0)
+    )
+  );
+}
+async function createIsolatedRuntimeProfile(sourceUserDataDir, runtimesRootDir = defaultRuntimeProfilesRootDir()) {
+  const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
+  const runtimeRootDir = expandHome(runtimesRootDir);
+  await mkdir3(runtimeRootDir, { recursive: true });
+  const sourceMetadata = await requirePersistentProfileMetadata(
+    resolvedSourceUserDataDir
+  );
+  const runtimeProfile = await reserveRuntimeProfileCreation(
+    resolvedSourceUserDataDir,
+    runtimeRootDir,
+    sourceMetadata.profileDirectory
+  );
+  try {
+    await cleanOrphanedRuntimeProfileDirs(
+      runtimeRootDir,
+      buildRuntimeProfileDirNamePrefix(resolvedSourceUserDataDir)
+    );
+    await copyUserDataDirSnapshot(
+      resolvedSourceUserDataDir,
+      runtimeProfile.userDataDir
+    );
+    const currentSourceMetadata = await readPersistentProfileMetadata(
+      resolvedSourceUserDataDir
+    );
+    await writeRuntimeProfileMetadata(
+      runtimeProfile.userDataDir,
+      await buildRuntimeProfileMetadata(
+        runtimeProfile.userDataDir,
+        resolvedSourceUserDataDir,
+        currentSourceMetadata?.profileDirectory ?? sourceMetadata.profileDirectory
+      )
+    );
+    await clearRuntimeProfileCreationState(
+      runtimeProfile.userDataDir,
+      resolvedSourceUserDataDir
+    );
+    return {
+      persistentUserDataDir: resolvedSourceUserDataDir,
+      userDataDir: runtimeProfile.userDataDir
+    };
+  } catch (error) {
+    await clearRuntimeProfileCreationState(
+      runtimeProfile.userDataDir,
+      resolvedSourceUserDataDir
+    );
+    await rm3(runtimeProfile.userDataDir, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    throw error;
+  }
+}
+async function persistIsolatedRuntimeProfile(runtimeUserDataDir, persistentUserDataDir) {
+  const resolvedRuntimeUserDataDir = expandHome(runtimeUserDataDir);
+  const resolvedPersistentUserDataDir = expandHome(persistentUserDataDir);
+  let claimedRuntimeUserDataDir = null;
+  try {
+    await withPersistentProfileWriteAccess(
+      resolvedPersistentUserDataDir,
+      async () => {
+        await mkdir3(dirname4(resolvedPersistentUserDataDir), {
+          recursive: true
+        });
+        await recoverPersistentProfileBackup(resolvedPersistentUserDataDir);
+        await cleanOrphanedOwnedDirs(
+          dirname4(resolvedPersistentUserDataDir),
+          buildPersistentProfileTempDirNamePrefix(
+            resolvedPersistentUserDataDir
+          )
+        );
+        const metadata = await requirePersistentProfileMetadata(
+          resolvedPersistentUserDataDir
+        );
+        claimedRuntimeUserDataDir = await claimRuntimeProfileForPersist(
+          resolvedRuntimeUserDataDir
+        );
+        const runtimeMetadata = await requireRuntimeProfileMetadata(
+          claimedRuntimeUserDataDir,
+          resolvedPersistentUserDataDir,
+          metadata.profileDirectory,
+          resolvedRuntimeUserDataDir
+        );
+        await mergePersistentProfileSnapshot(
+          claimedRuntimeUserDataDir,
+          resolvedPersistentUserDataDir,
+          metadata,
+          runtimeMetadata
+        );
+      }
+    );
+  } catch (error) {
+    if (claimedRuntimeUserDataDir) {
+      try {
+        await restoreClaimedRuntimeProfile(
+          claimedRuntimeUserDataDir,
+          resolvedRuntimeUserDataDir
+        );
+      } catch (restoreError) {
+        throw new AggregateError(
+          [error, restoreError],
+          `Failed to restore runtime profile "${resolvedRuntimeUserDataDir}" after persistence failed.`
+        );
+      }
+    }
+    throw error;
+  }
+  if (claimedRuntimeUserDataDir) {
+    await rm3(claimedRuntimeUserDataDir, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildPersistentProfileKey(sourceUserDataDir, profileDirectory) {
+  const hash = createHash("sha256").update(`${sourceUserDataDir}\0${profileDirectory}`).digest("hex").slice(0, 16);
+  const sourceLabel = sanitizePathSegment(basename3(sourceUserDataDir) || "user-data");
+  const profileLabel = sanitizePathSegment(profileDirectory || "Default");
+  return `${sourceLabel}-${profileLabel}-${hash}`;
+}
+function defaultPersistentProfilesRootDir() {
+  return join4(homedir(), ".opensteer", "real-browser-profiles");
+}
+function defaultRuntimeProfilesRootDir() {
+  return join4(tmpdir(), "opensteer-real-browser-runtimes");
+}
+function sanitizePathSegment(value) {
+  const sanitized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-");
+  return sanitized.replace(/^-|-$/g, "") || "profile";
+}
+function isProfileDirectory(userDataDir, entry) {
+  return existsSync3(join4(userDataDir, entry, "Preferences"));
+}
+async function copyUserDataDirSnapshot(sourceUserDataDir, targetUserDataDir) {
+  await cp(sourceUserDataDir, targetUserDataDir, {
+    recursive: true,
+    filter: (candidatePath) => shouldCopyRuntimeSnapshotEntry(sourceUserDataDir, candidatePath)
+  });
+}
+function shouldCopyRuntimeSnapshotEntry(userDataDir, candidatePath) {
+  const candidateRelativePath = relative(userDataDir, candidatePath);
+  if (!candidateRelativePath) {
+    return true;
+  }
+  const segments = candidateRelativePath.split(sep).filter(Boolean);
+  if (segments.length !== 1) {
+    return true;
+  }
+  return !COPY_SKIP_ENTRIES.has(segments[0]);
+}
+async function copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, targetProfileDirectory) {
+  let entries;
+  try {
+    entries = await readdir2(sourceUserDataDir);
+  } catch {
+    return;
+  }
+  const copyTasks = [];
+  for (const entry of entries) {
+    if (COPY_SKIP_ENTRIES.has(entry)) continue;
+    if (entry === targetProfileDirectory) continue;
+    const sourcePath = join4(sourceUserDataDir, entry);
+    const targetPath = join4(targetUserDataDir, entry);
+    if (existsSync3(targetPath)) continue;
+    let entryStat;
+    try {
+      entryStat = await stat(sourcePath);
+    } catch {
+      continue;
+    }
+    if (entryStat.isFile()) {
+      copyTasks.push(copyFile(sourcePath, targetPath).catch(() => void 0));
+    } else if (entryStat.isDirectory()) {
+      if (isProfileDirectory(sourceUserDataDir, entry)) continue;
+      if (SKIPPED_ROOT_DIRECTORIES.has(entry)) continue;
+      copyTasks.push(
+        cp(sourcePath, targetPath, { recursive: true }).catch(
+          () => void 0
+        )
+      );
+    }
+  }
+  await Promise.all(copyTasks);
+}
+async function writePersistentProfileMetadata(userDataDir, metadata) {
+  await writeFile3(
+    join4(userDataDir, OPENSTEER_META_FILE),
+    JSON.stringify(metadata, null, 2)
+  );
+}
+function buildPersistentProfileMetadata(sourceUserDataDir, profileDirectory) {
+  return {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profileDirectory,
+    source: sourceUserDataDir
+  };
+}
+async function createPersistentProfileClone(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
+  if (existsSync3(targetUserDataDir)) {
+    return false;
+  }
+  const tempUserDataDir = await mkdtemp(
+    buildPersistentProfileTempDirPrefix(targetUserDataDir)
+  );
+  let published = false;
+  try {
+    await materializePersistentProfileSnapshot(
+      sourceUserDataDir,
+      sourceProfileDir,
+      tempUserDataDir,
+      profileDirectory,
+      metadata
+    );
+    try {
+      await rename3(tempUserDataDir, targetUserDataDir);
+    } catch (error) {
+      if (wasDirPublishedByAnotherProcess2(error, targetUserDataDir)) {
+        return false;
+      }
+      throw error;
+    }
+    published = true;
+    return true;
+  } finally {
+    if (!published) {
+      await rm3(tempUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function materializePersistentProfileSnapshot(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
+  if (!existsSync3(sourceProfileDir)) {
+    throw new Error(
+      `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
+    );
+  }
+  await cp(sourceProfileDir, join4(targetUserDataDir, profileDirectory), {
+    recursive: true
+  });
+  await copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, profileDirectory);
+  await writePersistentProfileMetadata(targetUserDataDir, metadata);
+}
+async function mergePersistentProfileSnapshot(runtimeUserDataDir, persistentUserDataDir, metadata, runtimeMetadata) {
+  const tempUserDataDir = await mkdtemp(
+    buildPersistentProfileTempDirPrefix(persistentUserDataDir)
+  );
+  let published = false;
+  try {
+    const baseEntries = deserializeSnapshotManifestEntries(
+      runtimeMetadata.baseEntries
+    );
+    const currentEntries = await collectPersistentSnapshotEntries(
+      persistentUserDataDir,
+      metadata.profileDirectory
+    );
+    const runtimeEntries = await collectPersistentSnapshotEntries(
+      runtimeUserDataDir,
+      metadata.profileDirectory
+    );
+    const mergedEntries = resolveMergedSnapshotEntries(
+      baseEntries,
+      currentEntries,
+      runtimeEntries
+    );
+    await materializeMergedPersistentProfileSnapshot(
+      tempUserDataDir,
+      currentEntries,
+      runtimeEntries,
+      mergedEntries
+    );
+    await writePersistentProfileMetadata(tempUserDataDir, metadata);
+    await replaceProfileDirectory(persistentUserDataDir, tempUserDataDir);
+    published = true;
+  } finally {
+    if (!published) {
+      await rm3(tempUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function buildRuntimeProfileMetadata(runtimeUserDataDir, persistentUserDataDir, profileDirectory) {
+  const baseEntries = profileDirectory ? serializeSnapshotManifestEntries(
+    await collectPersistentSnapshotEntries(
+      runtimeUserDataDir,
+      profileDirectory
+    )
+  ) : {};
+  return {
+    baseEntries,
+    creator: CURRENT_PROCESS_OWNER,
+    persistentUserDataDir,
+    profileDirectory
+  };
+}
+async function writeRuntimeProfileMetadata(userDataDir, metadata) {
+  await writeFile3(
+    join4(userDataDir, OPENSTEER_RUNTIME_META_FILE),
+    JSON.stringify(metadata, null, 2)
+  );
+}
+async function writeRuntimeProfileCreationMarker(userDataDir, marker) {
+  await writeFile3(
+    join4(userDataDir, OPENSTEER_RUNTIME_CREATING_FILE),
+    JSON.stringify(marker, null, 2)
+  );
+}
+async function readRuntimeProfileMetadata(userDataDir) {
+  try {
+    const raw = await readFile4(
+      join4(userDataDir, OPENSTEER_RUNTIME_META_FILE),
+      "utf8"
+    );
+    const parsed = JSON.parse(raw);
+    const creator = parseProcessOwner(parsed.creator);
+    const persistentUserDataDir = typeof parsed.persistentUserDataDir === "string" ? parsed.persistentUserDataDir : void 0;
+    const profileDirectory = parsed.profileDirectory === null ? null : typeof parsed.profileDirectory === "string" ? parsed.profileDirectory : void 0;
+    if (!creator || persistentUserDataDir === void 0 || profileDirectory === void 0 || typeof parsed.baseEntries !== "object" || parsed.baseEntries === null || Array.isArray(parsed.baseEntries)) {
+      return null;
+    }
+    const baseEntries = deserializeSnapshotManifestEntries(
+      parsed.baseEntries
+    );
+    return {
+      baseEntries: Object.fromEntries(baseEntries),
+      creator,
+      persistentUserDataDir,
+      profileDirectory
+    };
+  } catch {
+    return null;
+  }
+}
+async function readRuntimeProfileCreationMarker(userDataDir) {
+  try {
+    const raw = await readFile4(
+      join4(userDataDir, OPENSTEER_RUNTIME_CREATING_FILE),
+      "utf8"
+    );
+    return parseRuntimeProfileCreationMarker(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function requireRuntimeProfileMetadata(userDataDir, expectedPersistentUserDataDir, expectedProfileDirectory, displayUserDataDir = userDataDir) {
+  const metadata = await readRuntimeProfileMetadata(userDataDir);
+  if (!metadata) {
+    throw new Error(
+      `Runtime profile metadata was not found for "${displayUserDataDir}".`
+    );
+  }
+  if (metadata.profileDirectory !== expectedProfileDirectory) {
+    throw new Error(
+      `Runtime profile "${displayUserDataDir}" was created for profile "${metadata.profileDirectory ?? "unknown"}", expected "${expectedProfileDirectory}".`
+    );
+  }
+  if (metadata.persistentUserDataDir !== expectedPersistentUserDataDir) {
+    throw new Error(
+      `Runtime profile "${displayUserDataDir}" does not belong to persistent profile "${expectedPersistentUserDataDir}".`
+    );
+  }
+  return metadata;
+}
+async function collectPersistentSnapshotEntries(userDataDir, profileDirectory) {
+  let rootEntries;
+  try {
+    rootEntries = await readdir2(userDataDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  rootEntries.sort((left, right) => left.name.localeCompare(right.name));
+  const collected = /* @__PURE__ */ new Map();
+  for (const entry of rootEntries) {
+    if (!shouldIncludePersistentRootEntry(
+      userDataDir,
+      profileDirectory,
+      entry.name
+    )) {
+      continue;
+    }
+    await collectSnapshotEntry(
+      join4(userDataDir, entry.name),
+      entry.name,
+      collected
+    );
+  }
+  return collected;
+}
+function shouldIncludePersistentRootEntry(userDataDir, profileDirectory, entry) {
+  if (entry === profileDirectory) {
+    return true;
+  }
+  if (COPY_SKIP_ENTRIES.has(entry)) {
+    return false;
+  }
+  if (SKIPPED_ROOT_DIRECTORIES.has(entry)) {
+    return false;
+  }
+  return !isProfileDirectory(userDataDir, entry);
+}
+async function collectSnapshotEntry(sourcePath, relativePath, collected) {
+  let entryStat;
+  try {
+    entryStat = await stat(sourcePath);
+  } catch {
+    return;
+  }
+  if (entryStat.isDirectory()) {
+    collected.set(relativePath, {
+      kind: "directory",
+      hash: null,
+      sourcePath
+    });
+    let children;
+    try {
+      children = await readdir2(sourcePath, {
+        encoding: "utf8",
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    children.sort((left, right) => left.name.localeCompare(right.name));
+    for (const child of children) {
+      await collectSnapshotEntry(
+        join4(sourcePath, child.name),
+        join4(relativePath, child.name),
+        collected
+      );
+    }
+    return;
+  }
+  if (entryStat.isFile()) {
+    collected.set(relativePath, {
+      kind: "file",
+      hash: await hashSnapshotFile(sourcePath, relativePath),
+      sourcePath
+    });
+  }
+}
+function serializeSnapshotManifestEntries(entries) {
+  return Object.fromEntries(
+    [...entries.entries()].sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath)).map(([relativePath, entry]) => [
+      relativePath,
+      {
+        kind: entry.kind,
+        hash: entry.hash
+      }
+    ])
+  );
+}
+function deserializeSnapshotManifestEntries(entries) {
+  const manifestEntries = /* @__PURE__ */ new Map();
+  for (const [relativePath, entry] of Object.entries(entries)) {
+    if (!entry || entry.kind !== "directory" && entry.kind !== "file" || !(entry.hash === null || typeof entry.hash === "string")) {
+      throw new Error(
+        `Runtime profile metadata for "${relativePath}" is invalid.`
+      );
+    }
+    manifestEntries.set(relativePath, {
+      kind: entry.kind,
+      hash: entry.hash
+    });
+  }
+  return manifestEntries;
+}
+function resolveMergedSnapshotEntries(baseEntries, currentEntries, runtimeEntries) {
+  const mergedEntries = /* @__PURE__ */ new Map();
+  const relativePaths = /* @__PURE__ */ new Set([
+    ...baseEntries.keys(),
+    ...currentEntries.keys(),
+    ...runtimeEntries.keys()
+  ]);
+  for (const relativePath of [...relativePaths].sort(compareSnapshotPaths)) {
+    mergedEntries.set(
+      relativePath,
+      resolveMergedSnapshotEntrySelection(
+        relativePath,
+        baseEntries.get(relativePath) ?? null,
+        currentEntries.get(relativePath) ?? null,
+        runtimeEntries.get(relativePath) ?? null
+      )
+    );
+  }
+  return mergedEntries;
+}
+function resolveMergedSnapshotEntrySelection(relativePath, baseEntry, currentEntry, runtimeEntry) {
+  if (snapshotEntriesEqual(runtimeEntry, baseEntry)) {
+    return currentEntry ? "current" : null;
+  }
+  if (snapshotEntriesEqual(currentEntry, baseEntry)) {
+    return runtimeEntry ? "runtime" : null;
+  }
+  if (!baseEntry) {
+    if (!currentEntry) {
+      return runtimeEntry ? "runtime" : null;
+    }
+    if (!runtimeEntry) {
+      return "current";
+    }
+    if (snapshotEntriesEqual(currentEntry, runtimeEntry)) {
+      return "current";
+    }
+    throw new Error(
+      `Concurrent runtime updates changed "${relativePath}" differently; refusing to overwrite the persistent profile.`
+    );
+  }
+  if (!currentEntry && !runtimeEntry) {
+    return null;
+  }
+  if (snapshotEntriesEqual(currentEntry, runtimeEntry)) {
+    return currentEntry ? "current" : null;
+  }
+  throw new Error(
+    `Concurrent runtime updates changed "${relativePath}" differently; refusing to overwrite the persistent profile.`
+  );
+}
+function snapshotEntriesEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.kind === right.kind && left.hash === right.hash;
+}
+async function materializeMergedPersistentProfileSnapshot(targetUserDataDir, currentEntries, runtimeEntries, mergedEntries) {
+  const selectedEntries = [...mergedEntries.entries()].filter(([, selection]) => selection !== null).sort(
+    ([leftPath], [rightPath]) => compareSnapshotPaths(leftPath, rightPath)
+  );
+  for (const [relativePath, selection] of selectedEntries) {
+    const entry = (selection === "current" ? currentEntries.get(relativePath) : runtimeEntries.get(relativePath)) ?? null;
+    if (!entry) {
+      continue;
+    }
+    const targetPath = join4(targetUserDataDir, relativePath);
+    if (entry.kind === "directory") {
+      await mkdir3(targetPath, { recursive: true });
+      continue;
+    }
+    await mkdir3(dirname4(targetPath), { recursive: true });
+    await copyFile(entry.sourcePath, targetPath);
+  }
+}
+function compareSnapshotPaths(left, right) {
+  const leftDepth = left.split(sep).length;
+  const rightDepth = right.split(sep).length;
+  if (leftDepth !== rightDepth) {
+    return leftDepth - rightDepth;
+  }
+  return left.localeCompare(right);
+}
+async function hashSnapshotFile(filePath, relativePath) {
+  const normalizedJson = await readNormalizedSnapshotJson(filePath, relativePath);
+  if (normalizedJson !== null) {
+    return createHash("sha256").update(JSON.stringify(normalizedJson)).digest("hex");
+  }
+  return await hashFile(filePath);
+}
+async function readNormalizedSnapshotJson(filePath, relativePath) {
+  const normalizer = SNAPSHOT_JSON_NORMALIZERS.get(relativePath);
+  if (!normalizer) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(await readFile4(filePath, "utf8"));
+    return normalizer(parsed);
+  } catch {
+    return null;
+  }
+}
+var SNAPSHOT_JSON_NORMALIZERS = /* @__PURE__ */ new Map([["Local State", normalizeLocalStateSnapshotJson]]);
+function normalizeLocalStateSnapshotJson(value) {
+  if (!isJsonRecord(value)) {
+    return value;
+  }
+  const { user_experience_metrics: _ignored, ...rest } = value;
+  return rest;
+}
+function isJsonRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("error", reject);
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+  });
+}
+async function ensurePersistentProfileMetadata(userDataDir, metadata) {
+  if (existsSync3(join4(userDataDir, OPENSTEER_META_FILE))) {
+    return;
+  }
+  await writePersistentProfileMetadata(userDataDir, metadata);
+}
+async function recoverPersistentProfileBackup(targetUserDataDir) {
+  const backupDirPaths = await listPersistentProfileBackupDirs(targetUserDataDir);
+  if (backupDirPaths.length === 0) {
+    return;
+  }
+  if (!existsSync3(targetUserDataDir)) {
+    const [latestBackupDirPath, ...staleBackupDirPaths] = backupDirPaths;
+    await rename3(latestBackupDirPath, targetUserDataDir);
+    await Promise.all(
+      staleBackupDirPaths.map(
+        (backupDirPath) => rm3(backupDirPath, {
+          recursive: true,
+          force: true
+        }).catch(() => void 0)
+      )
+    );
+    return;
+  }
+  await Promise.all(
+    backupDirPaths.map(
+      (backupDirPath) => rm3(backupDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0)
+    )
+  );
+}
+async function listPersistentProfileBackupDirs(targetUserDataDir) {
+  const profilesDir = dirname4(targetUserDataDir);
+  let entries;
+  try {
+    entries = await readdir2(profilesDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  const backupDirNamePrefix = buildPersistentProfileBackupDirNamePrefix(targetUserDataDir);
+  return entries.filter(
+    (entry) => entry.isDirectory() && entry.name.startsWith(backupDirNamePrefix)
+  ).map((entry) => join4(profilesDir, entry.name)).sort((leftPath, rightPath) => rightPath.localeCompare(leftPath));
+}
+async function readPersistentProfileMetadata(userDataDir) {
+  try {
+    const raw = await readFile4(join4(userDataDir, OPENSTEER_META_FILE), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.createdAt !== "string" || typeof parsed.profileDirectory !== "string" || typeof parsed.source !== "string") {
+      return null;
+    }
+    return {
+      createdAt: parsed.createdAt,
+      profileDirectory: parsed.profileDirectory,
+      source: parsed.source
+    };
+  } catch {
+    return null;
+  }
+}
+async function requirePersistentProfileMetadata(userDataDir) {
+  const metadata = await readPersistentProfileMetadata(userDataDir);
+  if (!metadata) {
+    throw new Error(
+      `Persistent profile metadata was not found for "${userDataDir}".`
+    );
+  }
+  return metadata;
+}
+async function isHealthyPersistentProfile(userDataDir, expectedSourceUserDataDir, expectedProfileDirectory) {
+  if (!existsSync3(userDataDir) || !existsSync3(join4(userDataDir, expectedProfileDirectory))) {
+    return false;
+  }
+  const metadata = await readPersistentProfileMetadata(userDataDir);
+  return metadata?.source === expectedSourceUserDataDir && metadata.profileDirectory === expectedProfileDirectory;
+}
+function wasDirPublishedByAnotherProcess2(error, targetDirPath) {
+  const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+  return existsSync3(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function replaceProfileDirectory(targetUserDataDir, replacementUserDataDir) {
+  if (!existsSync3(targetUserDataDir)) {
+    await rename3(replacementUserDataDir, targetUserDataDir);
+    return;
+  }
+  const backupUserDataDir = buildPersistentProfileBackupDirPath(targetUserDataDir);
+  let targetMovedToBackup = false;
+  let replacementPublished = false;
+  try {
+    await rename3(targetUserDataDir, backupUserDataDir);
+    targetMovedToBackup = true;
+    await rename3(replacementUserDataDir, targetUserDataDir);
+    replacementPublished = true;
+  } catch (error) {
+    if (targetMovedToBackup && !existsSync3(targetUserDataDir)) {
+      await rename3(backupUserDataDir, targetUserDataDir).catch(() => void 0);
+    }
+    throw error;
+  } finally {
+    if (replacementPublished && targetMovedToBackup && existsSync3(backupUserDataDir)) {
+      await rm3(backupUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function withPersistentProfileWriteAccess(targetUserDataDir, action) {
+  const releaseWriteLock = await acquirePersistentProfileWriteLock(
+    targetUserDataDir
+  );
+  try {
+    await waitForRuntimeProfileCreationsToDrain(targetUserDataDir);
+    await waitForSharedRealBrowserSessionToDrain(targetUserDataDir);
+    return await action();
+  } finally {
+    await releaseWriteLock();
+  }
+}
+function buildPersistentProfileTempDirPrefix(targetUserDataDir) {
+  return join4(
+    dirname4(targetUserDataDir),
+    `${buildPersistentProfileTempDirNamePrefix(targetUserDataDir)}${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-`
+  );
+}
+function buildPersistentProfileTempDirNamePrefix(targetUserDataDir) {
+  return `${basename3(targetUserDataDir)}-tmp-`;
+}
+function buildPersistentProfileBackupDirPath(targetUserDataDir) {
+  return join4(
+    dirname4(targetUserDataDir),
+    `${buildPersistentProfileBackupDirNamePrefix(targetUserDataDir)}${Date.now()}-${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-${randomUUID3()}`
+  );
+}
+function buildPersistentProfileBackupDirNamePrefix(targetUserDataDir) {
+  return `${basename3(targetUserDataDir)}-backup-`;
+}
+function buildRuntimeProfileCreationRegistryDirPath(persistentUserDataDir) {
+  return join4(
+    dirname4(persistentUserDataDir),
+    `${basename3(persistentUserDataDir)}.creating`
+  );
+}
+function buildRuntimeProfileCreationRegistrationPath(persistentUserDataDir, runtimeUserDataDir) {
+  const key = createHash("sha256").update(runtimeUserDataDir).digest("hex").slice(0, 16);
+  return join4(
+    buildRuntimeProfileCreationRegistryDirPath(persistentUserDataDir),
+    `${key}.json`
+  );
+}
+function buildRuntimeProfileKey(sourceUserDataDir) {
+  const hash = createHash("sha256").update(sourceUserDataDir).digest("hex").slice(0, 16);
+  return `${sanitizePathSegment(basename3(sourceUserDataDir) || "profile")}-${hash}`;
+}
+function buildRuntimeProfileDirNamePrefix(sourceUserDataDir) {
+  return `${buildRuntimeProfileKey(sourceUserDataDir)}-runtime-`;
+}
+function buildRuntimeProfileDirPrefix(runtimesRootDir, sourceUserDataDir) {
+  return join4(
+    runtimesRootDir,
+    buildRuntimeProfileDirNamePrefix(sourceUserDataDir)
+  );
+}
+async function reserveRuntimeProfileCreation(persistentUserDataDir, runtimeRootDir, profileDirectory) {
+  while (true) {
+    let runtimeUserDataDir = null;
+    await withPersistentProfileControlLock(
+      persistentUserDataDir,
+      async () => {
+        if (await isPersistentProfileWriteLocked(persistentUserDataDir)) {
+          return;
+        }
+        if (await hasLiveSharedRealBrowserSession(persistentUserDataDir)) {
+          return;
+        }
+        const createdRuntimeUserDataDir = await mkdtemp(
+          buildRuntimeProfileDirPrefix(
+            runtimeRootDir,
+            persistentUserDataDir
+          )
+        );
+        runtimeUserDataDir = createdRuntimeUserDataDir;
+        const marker = {
+          creator: CURRENT_PROCESS_OWNER,
+          persistentUserDataDir,
+          profileDirectory,
+          runtimeUserDataDir: createdRuntimeUserDataDir
+        };
+        await writeRuntimeProfileCreationMarker(
+          createdRuntimeUserDataDir,
+          marker
+        );
+        await writeRuntimeProfileCreationRegistration(marker);
+      }
+    );
+    if (runtimeUserDataDir) {
+      return {
+        persistentUserDataDir,
+        userDataDir: runtimeUserDataDir
+      };
+    }
+    await sleep4(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+async function clearRuntimeProfileCreationState(runtimeUserDataDir, persistentUserDataDir) {
+  await Promise.all([
+    rm3(join4(runtimeUserDataDir, OPENSTEER_RUNTIME_CREATING_FILE), {
+      force: true
+    }).catch(() => void 0),
+    rm3(
+      buildRuntimeProfileCreationRegistrationPath(
+        persistentUserDataDir,
+        runtimeUserDataDir
+      ),
+      {
+        force: true
+      }
+    ).catch(() => void 0)
+  ]);
+}
+async function writeRuntimeProfileCreationRegistration(marker) {
+  const registryDirPath = buildRuntimeProfileCreationRegistryDirPath(
+    marker.persistentUserDataDir
+  );
+  await mkdir3(registryDirPath, { recursive: true });
+  await writeFile3(
+    buildRuntimeProfileCreationRegistrationPath(
+      marker.persistentUserDataDir,
+      marker.runtimeUserDataDir
+    ),
+    JSON.stringify(marker, null, 2)
+  );
+}
+async function listRuntimeProfileCreationRegistrations(persistentUserDataDir) {
+  const registryDirPath = buildRuntimeProfileCreationRegistryDirPath(
+    persistentUserDataDir
+  );
+  let entries;
+  try {
+    entries = await readdir2(registryDirPath, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  return await Promise.all(
+    entries.filter((entry) => entry.isFile()).map(async (entry) => {
+      const filePath = join4(registryDirPath, entry.name);
+      return {
+        filePath,
+        marker: await readRuntimeProfileCreationRegistration(filePath)
+      };
+    })
+  );
+}
+async function readRuntimeProfileCreationRegistration(filePath) {
+  try {
+    const raw = await readFile4(filePath, "utf8");
+    return parseRuntimeProfileCreationMarker(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function cleanOrphanedRuntimeProfileDirs(rootDir, runtimeDirNamePrefix) {
+  let entries;
+  try {
+    entries = await readdir2(rootDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return;
+  }
+  const liveProcessCommandLines = await listProcessCommandLines();
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isDirectory() || !entry.name.startsWith(runtimeDirNamePrefix)) {
+        return;
+      }
+      const runtimeDirPath = join4(rootDir, entry.name);
+      const creationMarker = await readRuntimeProfileCreationMarker(
+        runtimeDirPath
+      );
+      if (await isRuntimeProfileDirInUse(
+        runtimeDirPath,
+        liveProcessCommandLines
+      )) {
+        return;
+      }
+      await rm3(runtimeDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+      if (creationMarker) {
+        await clearRuntimeProfileCreationState(
+          runtimeDirPath,
+          creationMarker.persistentUserDataDir
+        );
+      }
+    })
+  );
+}
+async function cleanOrphanedOwnedDirs(rootDir, ownedDirNamePrefix) {
+  let entries;
+  try {
+    entries = await readdir2(rootDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return;
+  }
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isDirectory() || !entry.name.startsWith(ownedDirNamePrefix)) {
+        return;
+      }
+      if (await isOwnedDirByLiveProcess(entry.name, ownedDirNamePrefix)) {
+        return;
+      }
+      await rm3(join4(rootDir, entry.name), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    })
+  );
+}
+async function isOwnedDirByLiveProcess(ownedDirName, ownedDirPrefix) {
+  const owner = parseOwnedDirOwner(ownedDirName, ownedDirPrefix);
+  return owner ? await getProcessLiveness(owner) !== "dead" : false;
+}
+async function isRuntimeProfileDirInUse(runtimeDirPath, liveProcessCommandLines) {
+  const creationMarker = await readRuntimeProfileCreationMarker(runtimeDirPath);
+  if (creationMarker && await getProcessLiveness(creationMarker.creator) !== "dead") {
+    return true;
+  }
+  const metadata = await readRuntimeProfileMetadata(runtimeDirPath);
+  if (metadata && await getProcessLiveness(metadata.creator) !== "dead") {
+    return true;
+  }
+  return liveProcessCommandLines.some(
+    (commandLine) => commandLineIncludesUserDataDir(commandLine, runtimeDirPath)
+  );
+}
+async function claimRuntimeProfileForPersist(runtimeUserDataDir) {
+  while (true) {
+    await waitForRuntimeProfileProcessesToDrain(runtimeUserDataDir);
+    const claimedRuntimeUserDataDir = buildClaimedRuntimeProfileDirPath(runtimeUserDataDir);
+    try {
+      await rename3(runtimeUserDataDir, claimedRuntimeUserDataDir);
+    } catch (error) {
+      const code = getErrorCode3(error);
+      if (code === "ENOENT") {
+        throw new Error(
+          `Runtime profile "${runtimeUserDataDir}" was not found.`
+        );
+      }
+      if (code === "EACCES" || code === "EBUSY" || code === "EPERM") {
+        await sleep4(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+        continue;
+      }
+      throw error;
+    }
+    if (!await hasLiveProcessUsingUserDataDir(runtimeUserDataDir)) {
+      return claimedRuntimeUserDataDir;
+    }
+    await rename3(
+      claimedRuntimeUserDataDir,
+      runtimeUserDataDir
+    ).catch(() => void 0);
+    await sleep4(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+async function restoreClaimedRuntimeProfile(claimedRuntimeUserDataDir, runtimeUserDataDir) {
+  if (!existsSync3(claimedRuntimeUserDataDir)) {
+    return;
+  }
+  if (existsSync3(runtimeUserDataDir)) {
+    throw new Error(
+      `Runtime profile "${runtimeUserDataDir}" was recreated before the failed persist could restore it from "${claimedRuntimeUserDataDir}".`
+    );
+  }
+  await rename3(claimedRuntimeUserDataDir, runtimeUserDataDir);
+}
+function buildClaimedRuntimeProfileDirPath(runtimeUserDataDir) {
+  return join4(
+    dirname4(runtimeUserDataDir),
+    `${basename3(runtimeUserDataDir)}-persisting-${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-${randomUUID3()}`
+  );
+}
+async function waitForRuntimeProfileProcessesToDrain(runtimeUserDataDir) {
+  while (await hasLiveProcessUsingUserDataDir(runtimeUserDataDir)) {
+    await sleep4(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+async function hasLiveProcessUsingUserDataDir(userDataDir) {
+  const liveProcessCommandLines = await listProcessCommandLines();
+  return liveProcessCommandLines.some(
+    (commandLine) => commandLineIncludesUserDataDir(commandLine, userDataDir)
+  );
+}
+async function hasActiveRuntimeProfileCreations(persistentUserDataDir) {
+  const registrations = await listRuntimeProfileCreationRegistrations(
+    persistentUserDataDir
+  );
+  let hasLiveCreation = false;
+  for (const registration of registrations) {
+    const marker = registration.marker;
+    if (!marker || marker.persistentUserDataDir !== persistentUserDataDir) {
+      await rm3(registration.filePath, {
+        force: true
+      }).catch(() => void 0);
+      continue;
+    }
+    const runtimeMarker = await readRuntimeProfileCreationMarker(
+      marker.runtimeUserDataDir
+    );
+    if (!runtimeMarker || runtimeMarker.persistentUserDataDir !== persistentUserDataDir || runtimeMarker.runtimeUserDataDir !== marker.runtimeUserDataDir) {
+      await clearRuntimeProfileCreationState(
+        marker.runtimeUserDataDir,
+        persistentUserDataDir
+      );
+      continue;
+    }
+    if (await getProcessLiveness(runtimeMarker.creator) === "dead") {
+      await clearRuntimeProfileCreationState(
+        marker.runtimeUserDataDir,
+        persistentUserDataDir
+      );
+      await rm3(marker.runtimeUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+      continue;
+    }
+    hasLiveCreation = true;
+  }
+  return hasLiveCreation;
+}
+async function waitForRuntimeProfileCreationsToDrain(persistentUserDataDir) {
+  while (true) {
+    if (!await hasActiveRuntimeProfileCreations(persistentUserDataDir)) {
+      return;
+    }
+    await sleep4(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+function parseRuntimeProfileCreationMarker(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const creator = parseProcessOwner(parsed.creator);
+  const persistentUserDataDir = typeof parsed.persistentUserDataDir === "string" ? parsed.persistentUserDataDir : void 0;
+  const profileDirectory = parsed.profileDirectory === null ? null : typeof parsed.profileDirectory === "string" ? parsed.profileDirectory : void 0;
+  const runtimeUserDataDir = typeof parsed.runtimeUserDataDir === "string" ? parsed.runtimeUserDataDir : void 0;
+  if (!creator || persistentUserDataDir === void 0 || profileDirectory === void 0 || runtimeUserDataDir === void 0) {
+    return null;
+  }
+  return {
+    creator,
+    persistentUserDataDir,
+    profileDirectory,
+    runtimeUserDataDir
+  };
+}
+function parseOwnedDirOwner(ownedDirName, ownedDirPrefix) {
+  const remainder = ownedDirName.slice(ownedDirPrefix.length);
+  const firstDashIndex = remainder.indexOf("-");
+  const secondDashIndex = firstDashIndex === -1 ? -1 : remainder.indexOf("-", firstDashIndex + 1);
+  if (firstDashIndex === -1 || secondDashIndex === -1) {
+    return null;
+  }
+  const pid = Number.parseInt(remainder.slice(0, firstDashIndex), 10);
+  const processStartedAtMs = Number.parseInt(
+    remainder.slice(firstDashIndex + 1, secondDashIndex),
+    10
+  );
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
+  }
+  return { pid, processStartedAtMs };
+}
+async function listProcessCommandLines() {
+  if (process.platform === "win32") {
+    return await listWindowsProcessCommandLines();
+  }
+  return await listPsProcessCommandLines();
+}
+async function listPsProcessCommandLines() {
+  try {
+    const { stdout } = await execFileAsync2(
+      "ps",
+      ["-axww", "-o", "command="],
+      {
+        env: PS_COMMAND_ENV2,
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2
+      }
+    );
+    return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  } catch {
+    return [];
+  }
+}
+async function listWindowsProcessCommandLines() {
+  const script = [
+    "$processes = Get-CimInstance Win32_Process | Select-Object CommandLine",
+    "$processes | ConvertTo-Json -Compress"
+  ].join("; ");
+  try {
+    const { stdout } = await execFileAsync2(
+      "powershell.exe",
+      ["-NoLogo", "-NoProfile", "-Command", script],
+      {
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2
+      }
+    );
+    const parsed = JSON.parse(stdout);
+    const records = Array.isArray(parsed) ? parsed : [parsed];
+    return records.map((record) => record?.CommandLine?.trim() ?? "").filter((commandLine) => commandLine.length > 0);
+  } catch {
+    return [];
+  }
+}
+function commandLineIncludesUserDataDir(commandLine, userDataDir) {
+  const unquoted = `--user-data-dir=${userDataDir}`;
+  const unquotedIndex = commandLine.indexOf(unquoted);
+  if (unquotedIndex !== -1) {
+    const after = commandLine[unquotedIndex + unquoted.length];
+    if (after === void 0 || after === " " || after === "	") {
+      return true;
+    }
+  }
+  return [
+    `--user-data-dir="${userDataDir}"`,
+    `--user-data-dir='${userDataDir}'`
+  ].some((candidate) => commandLine.includes(candidate));
+}
+function getErrorCode3(error) {
+  return typeof error === "object" && error !== null && "code" in error && (typeof error.code === "string" || typeof error.code === "number") ? error.code : void 0;
+}
+async function sleep4(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/shared-real-browser-session.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { spawn } from "child_process";
+import {
+  mkdir as mkdir4,
+  readFile as readFile5,
+  readdir as readdir3,
+  rm as rm4,
+  writeFile as writeFile4
+} from "fs/promises";
+import { createServer } from "net";
+import { join as join5 } from "path";
+import {
+  chromium
+} from "playwright";
+var SHARED_SESSION_RETRY_DELAY_MS2 = 50;
+async function acquireSharedRealBrowserSession(options) {
+  const reservation = await reserveSharedSessionClient(options);
+  const sessionContext = await attachToSharedSession(reservation, options);
+  let closed = false;
+  return {
+    browser: sessionContext.browser,
+    context: sessionContext.context,
+    page: sessionContext.page,
+    close: async () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      await releaseSharedSessionClient(sessionContext);
+    }
+  };
+}
+function getOwnedRealBrowserProcessPolicy(platformName = process.platform) {
+  if (platformName === "win32") {
+    return {
+      detached: false,
+      killStrategy: "taskkill",
+      shouldUnref: true
+    };
+  }
+  if (platformName === "darwin") {
+    return {
+      detached: false,
+      killStrategy: "process",
+      shouldUnref: true
+    };
+  }
+  return {
+    detached: true,
+    killStrategy: "process-group",
+    shouldUnref: true
+  };
+}
+async function reserveSharedSessionClient(options) {
+  while (true) {
+    const outcome = await withPersistentProfileControlLock(
+      options.persistentProfile.userDataDir,
+      async () => {
+        if (await isPersistentProfileWriteLocked(
+          options.persistentProfile.userDataDir
+        )) {
+          return { kind: "wait" };
+        }
+        if (await hasActiveRuntimeProfileCreations(
+          options.persistentProfile.userDataDir
+        )) {
+          return { kind: "wait" };
+        }
+        return await withSharedSessionLock(
+          options.persistentProfile.userDataDir,
+          async () => {
+            const state = await inspectSharedSessionState(options);
+            if (state.kind === "wait") {
+              return { kind: "wait" };
+            }
+            if (state.kind === "ready") {
+              return {
+                kind: "ready",
+                reservation: await registerSharedSessionClient(
+                  options.persistentProfile.userDataDir,
+                  state.metadata
+                )
+              };
+            }
+            return {
+              kind: "launch",
+              reservation: await launchSharedSession(options)
+            };
+          }
+        );
+      }
+    );
+    if (outcome.kind === "wait") {
+      await sleep5(SHARED_SESSION_RETRY_DELAY_MS2);
+      continue;
+    }
+    if (outcome.kind === "ready") {
+      return outcome.reservation;
+    }
+    try {
+      await waitForSharedSessionReady(
+        outcome.reservation.metadata,
+        options.timeoutMs
+      );
+    } catch (error) {
+      await cleanupFailedSharedSessionLaunch(outcome.reservation);
+      throw error;
+    }
+    try {
+      return await withSharedSessionLock(
+        options.persistentProfile.userDataDir,
+        async () => {
+          const metadata = await readSharedSessionMetadata(
+            options.persistentProfile.userDataDir
+          );
+          if (!metadata || metadata.sessionId !== outcome.reservation.metadata.sessionId || !processOwnersEqual(
+            metadata.browserOwner,
+            outcome.reservation.launchedBrowserOwner
+          )) {
+            throw new Error(
+              "The shared real-browser session changed before launch finalized."
+            );
+          }
+          const readyMetadata = {
+            ...metadata,
+            state: "ready"
+          };
+          await writeSharedSessionMetadata(
+            options.persistentProfile.userDataDir,
+            readyMetadata
+          );
+          return await registerSharedSessionClient(
+            options.persistentProfile.userDataDir,
+            readyMetadata
+          );
+        }
+      );
+    } catch (error) {
+      await cleanupFailedSharedSessionLaunch(outcome.reservation);
+      throw error;
+    }
+  }
+}
+async function attachToSharedSession(reservation, options) {
+  let browser = null;
+  let page = null;
+  try {
+    const browserWsUrl = await resolveCdpWebSocketUrl(
+      buildSharedSessionDiscoveryUrl(reservation.metadata.debugPort),
+      options.timeoutMs
+    );
+    browser = await chromium.connectOverCDP(browserWsUrl, {
+      timeout: options.timeoutMs
+    });
+    const context = getPrimaryBrowserContext(browser);
+    page = await getSharedSessionPage(context, reservation.reuseExistingPage);
+    if (options.initialUrl) {
+      await page.goto(options.initialUrl, {
+        timeout: options.timeoutMs,
+        waitUntil: "domcontentloaded"
+      });
+    }
+    return {
+      browser,
+      clientId: reservation.client.clientId,
+      context,
+      page,
+      persistentUserDataDir: reservation.metadata.persistentUserDataDir,
+      sessionId: reservation.metadata.sessionId
+    };
+  } catch (error) {
+    if (page) {
+      await page.close().catch(() => void 0);
+    }
+    if (browser) {
+      await browser.close().catch(() => void 0);
+    }
+    await cleanupFailedSharedSessionAttach({
+      clientId: reservation.client.clientId,
+      persistentUserDataDir: reservation.metadata.persistentUserDataDir,
+      sessionId: reservation.metadata.sessionId
+    });
+    throw error;
+  }
+}
+async function releaseSharedSessionClient(context) {
+  const releasePlan = await prepareSharedSessionCloseIfIdle(
+    context.persistentUserDataDir,
+    context.clientId,
+    context.sessionId
+  );
+  if (releasePlan.closeBrowser) {
+    await closeSharedSessionBrowser(
+      context.persistentUserDataDir,
+      releasePlan,
+      context.browser
+    );
+    return;
+  }
+  await context.page.close().catch(() => void 0);
+  await context.browser.close().catch(() => void 0);
+}
+async function inspectSharedSessionState(options) {
+  const persistentUserDataDir = options.persistentProfile.userDataDir;
+  const liveClients = await listLiveSharedSessionClients(persistentUserDataDir);
+  const metadata = await readSharedSessionMetadata(persistentUserDataDir);
+  if (!metadata) {
+    if (liveClients.length > 0) {
+      throw new Error(
+        `Shared real-browser session metadata for "${persistentUserDataDir}" is missing while clients are still attached.`
+      );
+    }
+    await rm4(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    return { kind: "missing" };
+  }
+  assertSharedSessionCompatibility(metadata, options);
+  const browserState = await getProcessLiveness(metadata.browserOwner);
+  if (browserState === "dead") {
+    await rm4(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    return { kind: "missing" };
+  }
+  if (metadata.state === "ready") {
+    return {
+      kind: "ready",
+      metadata
+    };
+  }
+  const stateOwnerState = await getProcessLiveness(metadata.stateOwner);
+  if (stateOwnerState === "dead") {
+    const recoveredMetadata = {
+      ...metadata,
+      state: "ready"
+    };
+    await writeSharedSessionMetadata(persistentUserDataDir, recoveredMetadata);
+    return {
+      kind: "ready",
+      metadata: recoveredMetadata
+    };
+  }
+  return { kind: "wait" };
+}
+async function launchSharedSession(options) {
+  const persistentUserDataDir = options.persistentProfile.userDataDir;
+  await clearPersistentProfileSingletons(persistentUserDataDir);
+  const debugPort = await reserveDebugPort();
+  const launchArgs = buildRealBrowserLaunchArgs({
+    debugPort,
+    headless: options.headless,
+    profileDirectory: options.profileDirectory,
+    userDataDir: persistentUserDataDir
+  });
+  const processPolicy = getOwnedRealBrowserProcessPolicy();
+  const processHandle = spawn(options.executablePath, launchArgs, {
+    detached: processPolicy.detached,
+    stdio: "ignore"
+  });
+  if (processPolicy.shouldUnref) {
+    processHandle.unref();
+  }
+  try {
+    const browserOwner = await waitForSpawnedProcessOwner(
+      processHandle.pid,
+      options.timeoutMs
+    );
+    const metadata = {
+      browserOwner,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      debugPort,
+      executablePath: options.executablePath,
+      headless: options.headless,
+      persistentUserDataDir,
+      profileDirectory: options.profileDirectory,
+      sessionId: randomUUID4(),
+      state: "launching",
+      stateOwner: CURRENT_PROCESS_OWNER
+    };
+    await writeSharedSessionMetadata(persistentUserDataDir, metadata);
+    return {
+      launchedBrowserOwner: browserOwner,
+      metadata
+    };
+  } catch (error) {
+    await killSpawnedBrowserProcess(processHandle);
+    await rm4(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    throw error;
+  }
+}
+async function cleanupFailedSharedSessionLaunch(reservation) {
+  const shouldPreserveLiveBrowser = await withSharedSessionLock(
+    reservation.metadata.persistentUserDataDir,
+    async () => {
+      const metadata = await readSharedSessionMetadata(
+        reservation.metadata.persistentUserDataDir
+      );
+      if (metadata && metadata.sessionId === reservation.metadata.sessionId && processOwnersEqual(
+        metadata.browserOwner,
+        reservation.launchedBrowserOwner
+      )) {
+        if (await getProcessLiveness(metadata.browserOwner) !== "dead") {
+          const readyMetadata = {
+            ...metadata,
+            state: "ready"
+          };
+          await writeSharedSessionMetadata(
+            reservation.metadata.persistentUserDataDir,
+            readyMetadata
+          );
+          return true;
+        }
+        await rm4(
+          buildSharedSessionDirPath(
+            reservation.metadata.persistentUserDataDir
+          ),
+          {
+            force: true,
+            recursive: true
+          }
+        ).catch(() => void 0);
+      }
+      return false;
+    }
+  );
+  if (shouldPreserveLiveBrowser) {
+    return;
+  }
+  await killOwnedBrowserProcess(reservation.launchedBrowserOwner);
+  await waitForProcessToExit(reservation.launchedBrowserOwner, 2e3);
+}
+async function cleanupFailedSharedSessionAttach(options) {
+  const closePlan = await prepareSharedSessionCloseIfIdle(
+    options.persistentUserDataDir,
+    options.clientId,
+    options.sessionId
+  );
+  if (!closePlan.closeBrowser) {
+    return;
+  }
+  await closeSharedSessionBrowser(options.persistentUserDataDir, closePlan);
+}
+async function waitForSharedSessionReady(metadata, timeoutMs) {
+  await resolveCdpWebSocketUrl(
+    buildSharedSessionDiscoveryUrl(metadata.debugPort),
+    timeoutMs
+  );
+}
+function buildRealBrowserLaunchArgs(options) {
+  const args = [
+    `--user-data-dir=${options.userDataDir}`,
+    `--profile-directory=${options.profileDirectory}`,
+    `--remote-debugging-port=${options.debugPort}`,
+    "--disable-blink-features=AutomationControlled"
+  ];
+  if (options.headless) {
+    args.push("--headless=new");
+  }
+  return args;
+}
+async function requestBrowserShutdown(browser) {
+  let session = null;
+  try {
+    session = await browser.newBrowserCDPSession();
+    await session.send("Browser.close");
+  } catch {
+  } finally {
+    await session?.detach().catch(() => void 0);
+  }
+}
+async function killOwnedBrowserProcess(owner) {
+  if (await getProcessLiveness(owner) === "dead") {
+    return;
+  }
+  await killOwnedBrowserProcessByPid(owner.pid);
+}
+async function killSpawnedBrowserProcess(processHandle) {
+  const pid = processHandle.pid;
+  if (!pid || processHandle.exitCode !== null) {
+    return;
+  }
+  await killOwnedBrowserProcessByPid(pid);
+  await waitForPidToExit(pid, 2e3);
+}
+async function killOwnedBrowserProcessByPid(pid) {
+  const processPolicy = getOwnedRealBrowserProcessPolicy();
+  if (processPolicy.killStrategy === "taskkill") {
+    await new Promise((resolve) => {
+      const killer = spawn(
+        "taskkill",
+        ["/pid", String(pid), "/t", "/f"],
+        {
+          stdio: "ignore"
+        }
+      );
+      killer.on("error", () => resolve());
+      killer.on("exit", () => resolve());
+    });
+    return;
+  }
+  if (processPolicy.killStrategy === "process-group") {
+    try {
+      process.kill(-pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function waitForProcessToExit(owner, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await getProcessLiveness(owner) === "dead") {
+      return;
+    }
+    await sleep5(50);
+  }
+}
+async function waitForPidToExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      return;
+    }
+    await sleep5(50);
+  }
+}
+async function waitForSpawnedProcessOwner(pid, timeoutMs) {
+  if (!pid || pid <= 0) {
+    throw new Error("Chrome did not expose a child process id.");
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const owner = await readProcessOwner(pid);
+    if (owner) {
+      return owner;
+    }
+    await sleep5(50);
+  }
+  throw new Error(
+    `Chrome process ${pid} did not report a stable process start time.`
+  );
+}
+async function withSharedSessionLock(persistentUserDataDir, action) {
+  return await withDirLock(
+    buildSharedSessionLockPath(persistentUserDataDir),
+    action
+  );
+}
+async function registerSharedSessionClient(persistentUserDataDir, metadata) {
+  const liveClients = await listLiveSharedSessionClients(persistentUserDataDir);
+  const client = buildSharedSessionClientRegistration();
+  await mkdir4(buildSharedSessionClientsDirPath(persistentUserDataDir), {
+    recursive: true
+  });
+  await writeFile4(
+    buildSharedSessionClientPath(persistentUserDataDir, client.clientId),
+    JSON.stringify(client, null, 2),
+    {
+      flag: "wx"
+    }
+  );
+  return {
+    client,
+    metadata,
+    reuseExistingPage: liveClients.length === 0
+  };
+}
+async function removeSharedSessionClientRegistration(persistentUserDataDir, clientId) {
+  await rm4(buildSharedSessionClientPath(persistentUserDataDir, clientId), {
+    force: true
+  }).catch(() => void 0);
+}
+async function listLiveSharedSessionClients(persistentUserDataDir) {
+  const clientsDirPath = buildSharedSessionClientsDirPath(persistentUserDataDir);
+  let entries;
+  try {
+    entries = await readdir3(clientsDirPath, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  const liveClients = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const filePath = join5(clientsDirPath, entry.name);
+    const registration = await readSharedSessionClientRegistration(filePath);
+    if (!registration) {
+      await rm4(filePath, { force: true }).catch(() => void 0);
+      continue;
+    }
+    if (await getProcessLiveness(registration.owner) === "dead") {
+      await rm4(filePath, { force: true }).catch(() => void 0);
+      continue;
+    }
+    liveClients.push(registration);
+  }
+  return liveClients;
+}
+async function readSharedSessionClientRegistration(filePath) {
+  try {
+    const raw = await readFile5(filePath, "utf8");
+    return parseSharedSessionClientRegistration(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function buildSharedSessionClientRegistration() {
+  return {
+    clientId: randomUUID4(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    owner: CURRENT_PROCESS_OWNER
+  };
+}
+function parseSharedSessionClientRegistration(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const owner = parseProcessOwner(parsed.owner);
+  if (!owner || typeof parsed.clientId !== "string" || typeof parsed.createdAt !== "string") {
+    return null;
+  }
+  return {
+    clientId: parsed.clientId,
+    createdAt: parsed.createdAt,
+    owner
+  };
+}
+function assertSharedSessionCompatibility(metadata, options) {
+  if (metadata.executablePath !== options.executablePath) {
+    throw new Error(
+      `Chrome profile "${options.profileDirectory}" is already running with executable "${metadata.executablePath}", not "${options.executablePath}".`
+    );
+  }
+  if (metadata.headless !== options.headless) {
+    throw new Error(
+      `Chrome profile "${options.profileDirectory}" is already running with headless=${metadata.headless}, not ${options.headless}.`
+    );
+  }
+}
+async function prepareSharedSessionCloseIfIdle(persistentUserDataDir, clientId, sessionId) {
+  return await withSharedSessionLock(persistentUserDataDir, async () => {
+    const metadata = await readSharedSessionMetadata(persistentUserDataDir);
+    await removeSharedSessionClientRegistration(
+      persistentUserDataDir,
+      clientId
+    );
+    if (!metadata || metadata.sessionId !== sessionId) {
+      return {
+        closeBrowser: false,
+        sessionId
+      };
+    }
+    const liveClients = await listLiveSharedSessionClients(
+      persistentUserDataDir
+    );
+    if (liveClients.length > 0) {
+      return {
+        closeBrowser: false,
+        sessionId: metadata.sessionId
+      };
+    }
+    const closingMetadata = {
+      ...metadata,
+      state: "closing",
+      stateOwner: CURRENT_PROCESS_OWNER
+    };
+    await writeSharedSessionMetadata(
+      persistentUserDataDir,
+      closingMetadata
+    );
+    return {
+      browserOwner: closingMetadata.browserOwner,
+      closeBrowser: true,
+      sessionId: closingMetadata.sessionId
+    };
+  });
+}
+async function closeSharedSessionBrowser(persistentUserDataDir, closePlan, browser) {
+  if (browser) {
+    await requestBrowserShutdown(browser);
+    await waitForProcessToExit(closePlan.browserOwner, 1e3);
+  }
+  if (await getProcessLiveness(closePlan.browserOwner) !== "dead") {
+    await killOwnedBrowserProcess(closePlan.browserOwner);
+    await waitForProcessToExit(closePlan.browserOwner, 2e3);
+  }
+  await finalizeSharedSessionClose(persistentUserDataDir, closePlan.sessionId);
+}
+async function finalizeSharedSessionClose(persistentUserDataDir, sessionId) {
+  await withSharedSessionLock(persistentUserDataDir, async () => {
+    const metadata = await readSharedSessionMetadata(persistentUserDataDir);
+    if (!metadata || metadata.sessionId !== sessionId) {
+      return;
+    }
+    const liveClients = await listLiveSharedSessionClients(
+      persistentUserDataDir
+    );
+    if (liveClients.length > 0) {
+      const readyMetadata = {
+        ...metadata,
+        state: "ready"
+      };
+      await writeSharedSessionMetadata(
+        persistentUserDataDir,
+        readyMetadata
+      );
+      return;
+    }
+    if (await getProcessLiveness(metadata.browserOwner) !== "dead") {
+      const readyMetadata = {
+        ...metadata,
+        state: "ready"
+      };
+      await writeSharedSessionMetadata(
+        persistentUserDataDir,
+        readyMetadata
+      );
+      return;
+    }
+    await rm4(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  });
+}
+function getPrimaryBrowserContext(browser) {
+  const contexts = browser.contexts();
+  if (contexts.length === 0) {
+    throw new Error(
+      "Connection succeeded but no browser contexts were exposed."
+    );
+  }
+  return contexts[0];
+}
+async function getSharedSessionPage(context, reuseExistingPage) {
+  if (reuseExistingPage) {
+    return await getExistingPageOrCreate(context);
+  }
+  return await context.newPage();
+}
+async function getExistingPageOrCreate(context) {
+  const existingPage = context.pages()[0];
+  if (existingPage) {
+    return existingPage;
+  }
+  return await context.newPage();
+}
+function buildSharedSessionDiscoveryUrl(debugPort) {
+  return `http://127.0.0.1:${debugPort}`;
+}
+async function resolveCdpWebSocketUrl(cdpUrl, timeoutMs) {
+  if (cdpUrl.startsWith("ws://") || cdpUrl.startsWith("wss://")) {
+    return cdpUrl;
+  }
+  const versionUrl = normalizeDiscoveryUrl(cdpUrl);
+  const deadline = Date.now() + timeoutMs;
+  let lastError = "CDP discovery did not respond.";
+  while (Date.now() < deadline) {
+    const remaining = Math.max(deadline - Date.now(), 1e3);
+    try {
+      const response = await fetch(versionUrl, {
+        signal: AbortSignal.timeout(Math.min(remaining, 5e3))
+      });
+      if (!response.ok) {
+        lastError = `${response.status} ${response.statusText}`;
+      } else {
+        const payload = await response.json();
+        const wsUrl = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.webSocketDebuggerUrl === "string" ? payload.webSocketDebuggerUrl : null;
+        if (wsUrl && wsUrl.trim()) {
+          return wsUrl;
+        }
+        lastError = "CDP discovery response did not include webSocketDebuggerUrl.";
       }
-      await rm(join(profilesDir, entry.name), {
-        recursive: true,
-        force: true
-      }).catch(() => void 0);
-    })
-  );
-}
-function isTempDirOwnedByLiveProcess(tempDirName, tempDirPrefix) {
-  const owner = parseTempDirOwner(tempDirName, tempDirPrefix);
-  if (!owner) {
-    return false;
-  }
-  if (owner.pid === process.pid && Math.abs(owner.processStartedAtMs - PROCESS_STARTED_AT_MS) <= PROCESS_START_TIME_TOLERANCE_MS) {
-    return true;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : "Unknown error";
+    }
+    await sleep5(100);
   }
-  return isProcessRunning(owner.pid);
+  throw new Error(
+    `Failed to resolve a CDP websocket URL from ${versionUrl.toString()}: ${lastError}`
+  );
 }
-function parseTempDirOwner(tempDirName, tempDirPrefix) {
-  const remainder = tempDirName.slice(tempDirPrefix.length);
-  const firstDashIndex = remainder.indexOf("-");
-  const secondDashIndex = firstDashIndex === -1 ? -1 : remainder.indexOf("-", firstDashIndex + 1);
-  if (firstDashIndex === -1 || secondDashIndex === -1) {
-    return null;
+function normalizeDiscoveryUrl(cdpUrl) {
+  let parsed;
+  try {
+    parsed = new URL(cdpUrl);
+  } catch {
+    throw new Error(
+      `Invalid CDP URL "${cdpUrl}". Use an http(s) or ws(s) endpoint.`
+    );
   }
-  const pid = Number.parseInt(remainder.slice(0, firstDashIndex), 10);
-  const processStartedAtMs = Number.parseInt(
-    remainder.slice(firstDashIndex + 1, secondDashIndex),
-    10
-  );
-  if (!Number.isInteger(pid) || pid <= 0) {
-    return null;
+  if (parsed.protocol === "ws:" || parsed.protocol === "wss:") {
+    return parsed;
   }
-  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
-    return null;
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Unsupported CDP URL protocol "${parsed.protocol}". Use http(s) or ws(s).`
+    );
   }
-  return { pid, processStartedAtMs };
+  const normalized = new URL(parsed.toString());
+  normalized.pathname = "/json/version";
+  normalized.search = "";
+  normalized.hash = "";
+  return normalized;
 }
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return code !== "ESRCH";
-  }
+async function reserveDebugPort() {
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to reserve a local debug port."));
+        return;
+      }
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(address.port);
+      });
+    });
+  });
+}
+async function sleep5(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/browser/pool.ts
-import { spawn } from "child_process";
-import { rm as rm2 } from "fs/promises";
-import { createServer } from "net";
 import {
-  chromium
+  chromium as chromium2
 } from "playwright";
 
 // src/browser/cdp-proxy.ts
@@ -722,16 +3093,14 @@ function errorMessage(error) {
 // src/browser/pool.ts
 var BrowserPool = class {
   browser = null;
-  cdpProxy = null;
-  launchedProcess = null;
-  managedUserDataDir = null;
-  persistentProfile = false;
+  activeSessionClose = null;
+  closeInFlight = null;
   defaults;
   constructor(defaults = {}) {
     this.defaults = defaults;
   }
   async launch(options = {}) {
-    if (this.browser || this.cdpProxy || this.launchedProcess || this.managedUserDataDir) {
+    if (this.browser || this.activeSessionClose) {
       await this.close();
     }
     const mode = options.mode ?? this.defaults.mode ?? "chromium";
@@ -778,30 +3147,26 @@ var BrowserPool = class {
     return this.launchSandbox(options);
   }
   async close() {
-    const browser = this.browser;
-    const cdpProxy = this.cdpProxy;
-    const launchedProcess = this.launchedProcess;
-    const managedUserDataDir = this.managedUserDataDir;
-    const persistentProfile = this.persistentProfile;
-    this.browser = null;
-    this.cdpProxy = null;
-    this.launchedProcess = null;
-    this.managedUserDataDir = null;
-    this.persistentProfile = false;
+    if (this.closeInFlight) {
+      await this.closeInFlight;
+      return;
+    }
+    const closeOperation = this.closeCurrent();
+    this.closeInFlight = closeOperation;
     try {
-      if (browser) {
-        await browser.close().catch(() => void 0);
-      }
+      await closeOperation;
+      this.browser = null;
+      this.activeSessionClose = null;
     } finally {
-      cdpProxy?.close();
-      await killProcessTree(launchedProcess);
-      if (managedUserDataDir && !persistentProfile) {
-        await rm2(managedUserDataDir, {
-          recursive: true,
-          force: true
-        }).catch(() => void 0);
-      }
+      this.closeInFlight = null;
+    }
+  }
+  async closeCurrent() {
+    if (this.activeSessionClose) {
+      await this.activeSessionClose();
+      return;
     }
+    await this.browser?.close().catch(() => void 0);
   }
   async connectToRunning(cdpUrl, timeout) {
     let browser = null;
@@ -816,11 +3181,14 @@ var BrowserPool = class {
       }
       cdpProxy = new CDPProxy(browserWsUrl, targetId);
       const proxyWsUrl = await cdpProxy.start();
-      browser = await chromium.connectOverCDP(proxyWsUrl, {
+      browser = await chromium2.connectOverCDP(proxyWsUrl, {
         timeout: timeout ?? 3e4
       });
       this.browser = browser;
-      this.cdpProxy = cdpProxy;
+      this.activeSessionClose = async () => {
+        await browser?.close().catch(() => void 0);
+        cdpProxy?.close();
+      };
       const { context, page } = await pickBrowserContextAndPage(browser);
       return { browser, context, page, isExternal: true };
     } catch (error) {
@@ -829,7 +3197,7 @@ var BrowserPool = class {
       }
       cdpProxy?.close();
       this.browser = null;
-      this.cdpProxy = null;
+      this.activeSessionClose = null;
       throw error;
     }
   }
@@ -849,55 +3217,29 @@ var BrowserPool = class {
       sourceUserDataDir,
       profileDirectory
     );
-    await clearPersistentProfileSingletons(persistentProfile.userDataDir);
-    const debugPort = await reserveDebugPort();
-    const headless = resolveLaunchHeadless(
-      "real",
-      options.headless,
-      this.defaults.headless
-    );
-    const launchArgs = buildRealBrowserLaunchArgs({
-      userDataDir: persistentProfile.userDataDir,
+    const sharedSession = await acquireSharedRealBrowserSession({
+      executablePath,
+      headless: resolveLaunchHeadless(
+        "real",
+        options.headless,
+        this.defaults.headless
+      ),
+      initialUrl: options.initialUrl,
+      persistentProfile,
       profileDirectory,
-      debugPort,
-      headless
-    });
-    const processHandle = spawn(executablePath, launchArgs, {
-      detached: process.platform !== "win32",
-      stdio: "ignore"
+      timeoutMs: options.timeout ?? 3e4
     });
-    processHandle.unref();
-    let browser = null;
-    try {
-      const wsUrl = await resolveCdpWebSocketUrl(
-        `http://127.0.0.1:${debugPort}`,
-        options.timeout ?? 3e4
-      );
-      browser = await chromium.connectOverCDP(wsUrl, {
-        timeout: options.timeout ?? 3e4
-      });
-      const { context, page } = await createOwnedBrowserContextAndPage(
-        browser
-      );
-      if (options.initialUrl) {
-        await page.goto(options.initialUrl, {
-          waitUntil: "domcontentloaded",
-          timeout: options.timeout ?? 3e4
-        });
-      }
-      this.browser = browser;
-      this.launchedProcess = processHandle;
-      this.managedUserDataDir = persistentProfile.userDataDir;
-      this.persistentProfile = true;
-      return { browser, context, page, isExternal: false };
-    } catch (error) {
-      await browser?.close().catch(() => void 0);
-      await killProcessTree(processHandle);
-      throw error;
-    }
+    this.browser = sharedSession.browser;
+    this.activeSessionClose = sharedSession.close;
+    return {
+      browser: sharedSession.browser,
+      context: sharedSession.context,
+      page: sharedSession.page,
+      isExternal: false
+    };
   }
   async launchSandbox(options) {
-    const browser = await chromium.launch({
+    const browser = await chromium2.launch({
       headless: resolveLaunchHeadless(
         "chromium",
         options.headless,
@@ -910,11 +3252,14 @@ var BrowserPool = class {
     const context = await browser.newContext(options.context || {});
     const page = await context.newPage();
     this.browser = browser;
+    this.activeSessionClose = async () => {
+      await browser.close().catch(() => void 0);
+    };
     return { browser, context, page, isExternal: false };
   }
 };
 async function pickBrowserContextAndPage(browser) {
-  const context = getPrimaryBrowserContext(browser);
+  const context = getPrimaryBrowserContext2(browser);
   const page = await getAttachedPageOrCreate(context);
   return { context, page };
 }
@@ -927,11 +3272,6 @@ function resolveLaunchHeadless(mode, requestedHeadless, defaultHeadless) {
   }
   return mode === "real";
 }
-async function createOwnedBrowserContextAndPage(browser) {
-  const context = getPrimaryBrowserContext(browser);
-  const page = await getExistingPageOrCreate(context);
-  return { context, page };
-}
 async function getAttachedPageOrCreate(context) {
   const pages = context.pages();
   const inspectablePage = pages.find(
@@ -946,14 +3286,7 @@ async function getAttachedPageOrCreate(context) {
   }
   return await context.newPage();
 }
-async function getExistingPageOrCreate(context) {
-  const existingPage = context.pages()[0];
-  if (existingPage) {
-    return existingPage;
-  }
-  return await context.newPage();
-}
-function getPrimaryBrowserContext(browser) {
+function getPrimaryBrowserContext2(browser) {
   const contexts = browser.contexts();
   if (contexts.length === 0) {
     throw new Error(
@@ -972,125 +3305,6 @@ function safePageUrl(page) {
     return "";
   }
 }
-function normalizeDiscoveryUrl(cdpUrl) {
-  let parsed;
-  try {
-    parsed = new URL(cdpUrl);
-  } catch {
-    throw new Error(
-      `Invalid CDP URL "${cdpUrl}". Use an http(s) or ws(s) endpoint.`
-    );
-  }
-  if (parsed.protocol === "ws:" || parsed.protocol === "wss:") {
-    return parsed;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(
-      `Unsupported CDP URL protocol "${parsed.protocol}". Use http(s) or ws(s).`
-    );
-  }
-  const normalized = new URL(parsed.toString());
-  normalized.pathname = "/json/version";
-  normalized.search = "";
-  normalized.hash = "";
-  return normalized;
-}
-async function resolveCdpWebSocketUrl(cdpUrl, timeoutMs) {
-  if (cdpUrl.startsWith("ws://") || cdpUrl.startsWith("wss://")) {
-    return cdpUrl;
-  }
-  const versionUrl = normalizeDiscoveryUrl(cdpUrl);
-  const deadline = Date.now() + timeoutMs;
-  let lastError = "CDP discovery did not respond.";
-  while (Date.now() < deadline) {
-    const remaining = Math.max(deadline - Date.now(), 1e3);
-    try {
-      const response = await fetch(versionUrl, {
-        signal: AbortSignal.timeout(Math.min(remaining, 5e3))
-      });
-      if (!response.ok) {
-        lastError = `${response.status} ${response.statusText}`;
-      } else {
-        const payload = await response.json();
-        const wsUrl = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.webSocketDebuggerUrl === "string" ? payload.webSocketDebuggerUrl : null;
-        if (wsUrl && wsUrl.trim()) {
-          return wsUrl;
-        }
-        lastError = "CDP discovery response did not include webSocketDebuggerUrl.";
-      }
-    } catch (error) {
-      lastError = error instanceof Error ? error.message : "Unknown error";
-    }
-    await sleep(100);
-  }
-  throw new Error(
-    `Failed to resolve a CDP websocket URL from ${versionUrl.toString()}: ${lastError}`
-  );
-}
-async function reserveDebugPort() {
-  return await new Promise((resolve, reject) => {
-    const server = createServer();
-    server.unref();
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close();
-        reject(new Error("Failed to reserve a local debug port."));
-        return;
-      }
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(address.port);
-      });
-    });
-  });
-}
-function buildRealBrowserLaunchArgs(options) {
-  const args = [
-    `--user-data-dir=${options.userDataDir}`,
-    `--profile-directory=${options.profileDirectory}`,
-    `--remote-debugging-port=${options.debugPort}`,
-    "--disable-blink-features=AutomationControlled"
-  ];
-  if (options.headless) {
-    args.push("--headless=new");
-  }
-  return args;
-}
-async function killProcessTree(processHandle) {
-  if (!processHandle || processHandle.pid == null || processHandle.exitCode !== null) {
-    return;
-  }
-  if (process.platform === "win32") {
-    await new Promise((resolve) => {
-      const killer = spawn(
-        "taskkill",
-        ["/pid", String(processHandle.pid), "/t", "/f"],
-        {
-          stdio: "ignore"
-        }
-      );
-      killer.on("error", () => resolve());
-      killer.on("exit", () => resolve());
-    });
-    return;
-  }
-  try {
-    process.kill(-processHandle.pid, "SIGKILL");
-  } catch {
-    try {
-      processHandle.kill("SIGKILL");
-    } catch {
-    }
-  }
-}
-async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 // src/navigation.ts
 var DEFAULT_TIMEOUT = 3e4;
@@ -1470,7 +3684,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
           TRANSIENT_CONTEXT_RETRY_DELAY_MS,
           Math.max(0, deadline - Date.now())
         );
-        await sleep2(retryDelay);
+        await sleep6(retryDelay);
       }
     }
   }
@@ -1503,7 +3717,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
       () => ({ kind: "resolved" }),
       (error) => ({ kind: "rejected", error })
     );
-    const timeoutPromise = sleep2(
+    const timeoutPromise = sleep6(
       timeout + FRAME_EVALUATE_GRACE_MS
     ).then(() => ({ kind: "timeout" }));
     const result = await Promise.race([
@@ -1645,7 +3859,7 @@ function isIgnorableFrameError(error) {
   const message = error.message;
   return message.includes("Frame was detached") || message.includes("Target page, context or browser has been closed") || isTransientExecutionContextError(error) || message.includes("No frame for given id found");
 }
-function sleep2(ms) {
+function sleep6(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -5897,7 +8111,7 @@ async function closeTab(context, activePage, index) {
 }
 
 // src/actions/cookies.ts
-import { readFile, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 async function getCookies(context, url) {
   return context.cookies(url ? [url] : void 0);
 }
@@ -5909,10 +8123,10 @@ async function clearCookies(context) {
 }
 async function exportCookies(context, filePath, url) {
   const cookies = await context.cookies(url ? [url] : void 0);
-  await writeFile2(filePath, JSON.stringify(cookies, null, 2), "utf-8");
+  await writeFile5(filePath, JSON.stringify(cookies, null, 2), "utf-8");
 }
 async function importCookies(context, filePath) {
-  const raw = await readFile(filePath, "utf-8");
+  const raw = await readFile6(filePath, "utf-8");
   const cookies = JSON.parse(raw);
   await context.addCookies(cookies);
 }
@@ -7740,7 +9954,7 @@ async function executeAgentAction(page, action) {
     }
     case "wait": {
       const ms = numberOr(action.timeMs, action.time_ms, 1e3);
-      await sleep3(ms);
+      await sleep7(ms);
       return;
     }
     case "goto": {
@@ -7905,7 +10119,7 @@ async function pressKeyCombo(page, combo) {
     }
   }
 }
-function sleep3(ms) {
+function sleep7(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -7936,7 +10150,7 @@ var OpensteerCuaAgentHandler = class {
       if (isMutatingAgentAction(action)) {
         this.onMutatingAction?.(action);
       }
-      await sleep4(this.config.waitBetweenActionsMs);
+      await sleep8(this.config.waitBetweenActionsMs);
     });
     try {
       const result = await this.client.execute({
@@ -7998,7 +10212,7 @@ var OpensteerCuaAgentHandler = class {
     await this.cursorController.preview({ x, y }, "agent");
   }
 };
-function sleep4(ms) {
+function sleep8(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -8434,7 +10648,7 @@ var CursorController = class {
       for (const step of motion.points) {
         await this.renderer.move(step, this.style);
         if (motion.stepDelayMs > 0) {
-          await sleep5(motion.stepDelayMs);
+          await sleep9(motion.stepDelayMs);
         }
       }
       if (shouldPulse(intent)) {
@@ -8592,12 +10806,12 @@ function clamp2(value, min, max) {
 function shouldPulse(intent) {
   return intent === "click" || intent === "dblclick" || intent === "rightclick" || intent === "agent";
 }
-function sleep5(ms) {
+function sleep9(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/opensteer.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID5 } from "crypto";
 
 // src/action-wait.ts
 var ROBUST_PROFILE = {
@@ -8792,7 +11006,7 @@ var AdaptiveNetworkTracker = class {
         this.idleSince = 0;
       }
       const remaining = Math.max(1, options.deadline - now);
-      await sleep6(Math.min(NETWORK_POLL_MS, remaining));
+      await sleep10(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
@@ -8837,7 +11051,7 @@ var AdaptiveNetworkTracker = class {
     return false;
   }
 };
-async function sleep6(ms) {
+async function sleep10(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -10617,15 +12831,22 @@ var Opensteer = class _Opensteer {
       }
       return;
     }
-    if (this.ownsBrowser) {
-      await this.pool.close();
-    }
-    this.browser = null;
-    this.pageRef = null;
-    this.contextRef = null;
-    this.ownsBrowser = false;
-    if (this.cursorController) {
-      await this.cursorController.dispose().catch(() => void 0);
+    let closedOwnedBrowser = false;
+    try {
+      if (this.ownsBrowser) {
+        await this.pool.close();
+        closedOwnedBrowser = true;
+      }
+    } finally {
+      this.browser = null;
+      this.pageRef = null;
+      this.contextRef = null;
+      if (!this.ownsBrowser || closedOwnedBrowser) {
+        this.ownsBrowser = false;
+      }
+      if (this.cursorController) {
+        await this.cursorController.dispose().catch(() => void 0);
+      }
     }
   }
   async syncLocalSelectorCacheToCloud() {
@@ -12949,12 +15170,16 @@ function normalizeCloudBrowserProfilePreference(value, source) {
 }
 function buildLocalRunId(namespace) {
   const normalized = namespace.trim() || "default";
-  return `${normalized}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+  return `${normalized}-${Date.now().toString(36)}-${randomUUID5().slice(0, 8)}`;
 }
 
 export {
   getOrCreatePersistentProfile,
   clearPersistentProfileSingletons,
+  createIsolatedRuntimeProfile,
+  persistIsolatedRuntimeProfile,
+  hasActiveRuntimeProfileCreations,
+  getOwnedRealBrowserProcessPolicy,
   BrowserPool,
   waitForVisualStability,
   createEmptyRegistry,