opensteer 0.9.0 → 0.9.1

package/dist/chunk-BMPUL66S.js

@@ -0,0 +1,1170 @@
+import { execFileSync, execFile } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import path3, { join, resolve, basename } from 'path';
+import { mkdir, access, readFile, writeFile, rename, open, readdir, rm } from 'fs/promises';
+import { randomUUID, createHash } from 'crypto';
+import { pathToFileURL } from 'url';
+import { promisify } from 'util';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+({ ...process.env});
+var WINDOWS_PROGRAM_FILES = process.env.PROGRAMFILES ?? "C:\\Program Files";
+var WINDOWS_PROGRAM_FILES_X86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
+var BROWSER_BRANDS = [
+  {
+    id: "chrome",
+    displayName: "Google Chrome",
+    darwin: {
+      executableCandidates: ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"],
+      userDataDir: "~/Library/Application Support/Google/Chrome",
+      bundleId: "com.google.Chrome",
+      processNames: ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"]
+    },
+    win32: {
+      executableCandidates: [
+        join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
+        join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
+        join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
+      ],
+      userDataDir: "~/AppData/Local/Google/Chrome/User Data",
+      processNames: ["/google/chrome/application/chrome.exe"]
+    },
+    linux: {
+      executableCandidates: [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/opt/google/chrome/chrome",
+        resolveBinaryFromPath("google-chrome"),
+        resolveBinaryFromPath("google-chrome-stable")
+      ],
+      userDataDir: "~/.config/google-chrome",
+      processNames: ["/google-chrome", "/google-chrome-stable", "/opt/google/chrome/chrome"]
+    }
+  },
+  {
+    id: "chrome-canary",
+    displayName: "Google Chrome Canary",
+    darwin: {
+      executableCandidates: [
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
+      ],
+      userDataDir: "~/Library/Application Support/Google/Chrome Canary",
+      bundleId: "com.google.Chrome.canary",
+      processNames: ["/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"]
+    },
+    win32: {
+      executableCandidates: [
+        join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
+      ],
+      userDataDir: "~/AppData/Local/Google/Chrome SxS/User Data",
+      processNames: ["/google/chrome sxs/application/chrome.exe"]
+    }
+  },
+  {
+    id: "chromium",
+    displayName: "Chromium",
+    darwin: {
+      executableCandidates: ["/Applications/Chromium.app/Contents/MacOS/Chromium"],
+      userDataDir: "~/Library/Application Support/Chromium",
+      bundleId: "org.chromium.Chromium",
+      processNames: ["/Applications/Chromium.app/Contents/MacOS/Chromium"]
+    },
+    win32: {
+      executableCandidates: [
+        join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
+        join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
+        join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
+      ],
+      userDataDir: "~/AppData/Local/Chromium/User Data",
+      processNames: ["/chromium/application/chrome.exe"]
+    },
+    linux: {
+      executableCandidates: [
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        resolveBinaryFromPath("chromium"),
+        resolveBinaryFromPath("chromium-browser")
+      ],
+      userDataDir: "~/.config/chromium",
+      processNames: ["/chromium", "/chromium-browser"]
+    }
+  },
+  {
+    id: "brave",
+    displayName: "Brave Browser",
+    darwin: {
+      executableCandidates: ["/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"],
+      userDataDir: "~/Library/Application Support/BraveSoftware/Brave-Browser",
+      bundleId: "com.brave.Browser",
+      processNames: ["/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"]
+    },
+    win32: {
+      executableCandidates: [
+        join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+        join(
+          WINDOWS_PROGRAM_FILES_X86,
+          "BraveSoftware",
+          "Brave-Browser",
+          "Application",
+          "brave.exe"
+        ),
+        join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
+      ],
+      userDataDir: "~/AppData/Local/BraveSoftware/Brave-Browser/User Data",
+      processNames: ["/bravesoftware/brave-browser/application/brave.exe"]
+    },
+    linux: {
+      executableCandidates: [
+        "/usr/bin/brave-browser",
+        "/opt/brave.com/brave/brave-browser",
+        resolveBinaryFromPath("brave-browser")
+      ],
+      userDataDir: "~/.config/BraveSoftware/Brave-Browser",
+      processNames: ["/brave-browser", "/opt/brave.com/brave/brave-browser"]
+    }
+  },
+  {
+    id: "edge",
+    displayName: "Microsoft Edge",
+    darwin: {
+      executableCandidates: ["/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"],
+      userDataDir: "~/Library/Application Support/Microsoft Edge",
+      bundleId: "com.microsoft.edgemac",
+      processNames: ["/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"]
+    },
+    win32: {
+      executableCandidates: [
+        join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
+        join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
+        join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
+      ],
+      userDataDir: "~/AppData/Local/Microsoft/Edge/User Data",
+      processNames: ["/microsoft/edge/application/msedge.exe"]
+    },
+    linux: {
+      executableCandidates: [
+        "/usr/bin/microsoft-edge",
+        "/usr/bin/microsoft-edge-stable",
+        "/opt/microsoft/msedge/msedge",
+        resolveBinaryFromPath("microsoft-edge"),
+        resolveBinaryFromPath("microsoft-edge-stable")
+      ],
+      userDataDir: "~/.config/microsoft-edge",
+      processNames: ["/microsoft-edge", "/microsoft-edge-stable", "/opt/microsoft/msedge/msedge"]
+    }
+  },
+  {
+    id: "vivaldi",
+    displayName: "Vivaldi",
+    darwin: {
+      executableCandidates: ["/Applications/Vivaldi.app/Contents/MacOS/Vivaldi"],
+      userDataDir: "~/Library/Application Support/Vivaldi",
+      bundleId: "com.vivaldi.Vivaldi",
+      processNames: ["/Applications/Vivaldi.app/Contents/MacOS/Vivaldi"]
+    },
+    win32: {
+      executableCandidates: [
+        join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
+        join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
+        join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
+      ],
+      userDataDir: "~/AppData/Local/Vivaldi/User Data",
+      processNames: ["/vivaldi/application/vivaldi.exe"]
+    },
+    linux: {
+      executableCandidates: [
+        "/usr/bin/vivaldi",
+        "/usr/bin/vivaldi-stable",
+        "/opt/vivaldi/vivaldi",
+        resolveBinaryFromPath("vivaldi"),
+        resolveBinaryFromPath("vivaldi-stable")
+      ],
+      userDataDir: "~/.config/vivaldi",
+      processNames: ["/vivaldi", "/vivaldi-stable", "/opt/vivaldi/vivaldi"]
+    }
+  },
+  {
+    id: "helium",
+    displayName: "Helium",
+    darwin: {
+      executableCandidates: ["/Applications/Helium.app/Contents/MacOS/Helium"],
+      userDataDir: "~/Library/Application Support/net.imput.helium",
+      processNames: ["/Applications/Helium.app/Contents/MacOS/Helium"]
+    }
+  }
+];
+function getBrowserBrand(id) {
+  const brand = BROWSER_BRANDS.find((candidate) => candidate.id === id);
+  if (!brand) {
+    throw new Error(`Unknown browser brand "${id}".`);
+  }
+  return brand;
+}
+function resolveBrandPlatformConfig(brand, platform = process.platform) {
+  if (platform === "darwin") {
+    return brand.darwin;
+  }
+  if (platform === "win32") {
+    return brand.win32;
+  }
+  if (platform === "linux") {
+    return brand.linux;
+  }
+  return void 0;
+}
+function detectInstalledBrowserBrands() {
+  const installations = [];
+  for (const brand of BROWSER_BRANDS) {
+    const platformConfig = resolveBrandPlatformConfig(brand);
+    if (!platformConfig) {
+      continue;
+    }
+    const executablePath = firstExistingPath(
+      resolveExecutableCandidates(platformConfig.executableCandidates)
+    );
+    if (!executablePath) {
+      continue;
+    }
+    installations.push({
+      brand,
+      brandId: brand.id,
+      displayName: brand.displayName,
+      executablePath,
+      userDataDir: resolve(expandHome(platformConfig.userDataDir))
+    });
+  }
+  return installations;
+}
+function resolveBrandUserDataDir(brand, explicitDir) {
+  if (explicitDir !== void 0) {
+    return resolve(expandHome(explicitDir));
+  }
+  const platformConfig = resolveBrandPlatformConfig(brand);
+  if (!platformConfig) {
+    throw new Error(`${brand.displayName} is not supported on ${process.platform}.`);
+  }
+  return resolve(expandHome(platformConfig.userDataDir));
+}
+function resolveExecutableCandidates(candidates) {
+  return candidates.map((candidate) => candidate ? resolve(expandHome(candidate)) : null);
+}
+
+// src/local-browser/chrome-discovery.ts
+function expandHome(value) {
+  if (value === "~" || value.startsWith("~/")) {
+    return join(homedir(), value.slice(1));
+  }
+  return value;
+}
+function resolveChromeUserDataDir(userDataDir) {
+  const installation = detectLocalChromeInstallations().find(
+    (candidate) => existsSync(join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
+  );
+  if (!installation) {
+    throw new Error("Could not find a local Chrome or Chromium profile directory.");
+  }
+  return installation.userDataDir;
+}
+function resolveChromeExecutablePath(executablePath) {
+  if (executablePath !== void 0) {
+    const resolvedPath = resolve(expandHome(executablePath));
+    if (!existsSync(resolvedPath)) {
+      throw new Error(`Chrome executable was not found at "${resolvedPath}".`);
+    }
+    return resolvedPath;
+  }
+  for (const installation of detectLocalChromeInstallations()) {
+    if (installation.executablePath) {
+      return installation.executablePath;
+    }
+  }
+  throw new Error(
+    "Could not find a Chrome or Chromium executable. Pass browser.executablePath or --executable-path."
+  );
+}
+function detectLocalChromeInstallations() {
+  if (process.platform === "darwin") {
+    return [
+      {
+        brand: "chrome",
+        executablePath: firstExistingPath([
+          "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+          "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
+        ]),
+        userDataDir: join(homedir(), "Library", "Application Support", "Google", "Chrome")
+      },
+      {
+        brand: "chromium",
+        executablePath: firstExistingPath(["/Applications/Chromium.app/Contents/MacOS/Chromium"]),
+        userDataDir: join(homedir(), "Library", "Application Support", "Chromium")
+      }
+    ];
+  }
+  if (process.platform === "win32") {
+    const programFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
+    const programFilesX86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
+    const localAppData = process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local");
+    return [
+      {
+        brand: "chrome",
+        executablePath: firstExistingPath([
+          join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+          join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+          join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
+        ]),
+        userDataDir: join(localAppData, "Google", "Chrome", "User Data")
+      },
+      {
+        brand: "chromium",
+        executablePath: firstExistingPath([
+          join(programFiles, "Chromium", "Application", "chrome.exe"),
+          join(programFilesX86, "Chromium", "Application", "chrome.exe"),
+          join(localAppData, "Chromium", "Application", "chrome.exe")
+        ]),
+        userDataDir: join(localAppData, "Chromium", "User Data")
+      }
+    ];
+  }
+  return [
+    {
+      brand: "chrome",
+      executablePath: firstExistingPath([
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        resolveBinaryFromPath("google-chrome"),
+        resolveBinaryFromPath("google-chrome-stable")
+      ]),
+      userDataDir: join(homedir(), ".config", "google-chrome")
+    },
+    {
+      brand: "chromium",
+      executablePath: firstExistingPath([
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        resolveBinaryFromPath("chromium"),
+        resolveBinaryFromPath("chromium-browser")
+      ]),
+      userDataDir: join(homedir(), ".config", "chromium")
+    }
+  ];
+}
+function detectLocalBrowserInstallations() {
+  return detectInstalledBrowserBrands().map((installation) => ({
+    brand: installation.brandId,
+    executablePath: installation.executablePath,
+    userDataDir: installation.userDataDir
+  }));
+}
+function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
+  const resolvedUserDataDir = resolve(expandHome(userDataDir));
+  const localStatePath = join(resolvedUserDataDir, "Local State");
+  if (!existsSync(localStatePath)) {
+    return [];
+  }
+  try {
+    const raw = JSON.parse(readFileSync(localStatePath, "utf8"));
+    const infoCache = raw.profile?.info_cache;
+    if (!infoCache || typeof infoCache !== "object") {
+      return [];
+    }
+    return Object.entries(infoCache).map(([directory, info]) => {
+      const record = info && typeof info === "object" && !Array.isArray(info) ? info : {};
+      const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : directory || basename(directory);
+      return {
+        directory,
+        name,
+        userDataDir: resolvedUserDataDir
+      };
+    }).filter((profile) => profile.directory.trim().length > 0).sort((left, right) => left.directory.localeCompare(right.directory));
+  } catch {
+    return [];
+  }
+}
+function readDevToolsActivePort(userDataDir) {
+  const devToolsPath = join(userDataDir, "DevToolsActivePort");
+  if (!existsSync(devToolsPath)) {
+    return null;
+  }
+  try {
+    const lines = readFileSync(devToolsPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    const port = Number.parseInt(lines[0] ?? "", 10);
+    if (!Number.isInteger(port) || port <= 0) {
+      return null;
+    }
+    return {
+      port,
+      webSocketPath: lines[1] ?? "/devtools/browser"
+    };
+  } catch {
+    return null;
+  }
+}
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveBinaryFromPath(name) {
+  try {
+    const output = execFileSync("which", [name], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return output.length > 0 ? output : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/local-browser/cdp-discovery.ts
+var DEFAULT_DISCOVERY_TIMEOUT_MS = 2e3;
+var DISCOVERY_FALLBACK_PORT = 9222;
+var OpensteerAttachAmbiguousError = class extends Error {
+  constructor(candidates) {
+    super(
+      "Multiple running Chromium DevTools endpoints were discovered. Specify the desired endpoint explicitly."
+    );
+    this.candidates = candidates;
+    this.name = "OpensteerAttachAmbiguousError";
+  }
+  code = "attach-ambiguous";
+};
+async function inspectCdpEndpoint(input) {
+  const inspected = await probeCdpEndpoint(input);
+  if (inspected === null) {
+    throw new Error(`Could not inspect CDP endpoint "${input.endpoint}".`);
+  }
+  return inspected;
+}
+async function discoverLocalCdpBrowsers(input = {}) {
+  const timeoutMs = input.timeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
+  const candidates = [];
+  for (const installation of detectLocalBrowserInstallations()) {
+    const activePort = readDevToolsActivePort(installation.userDataDir);
+    if (!activePort) {
+      continue;
+    }
+    const inspected = await probeCdpEndpoint({
+      endpoint: `http://127.0.0.1:${String(activePort.port)}`,
+      timeoutMs,
+      fallbackBrowserWebSocketPath: activePort.webSocketPath
+    });
+    if (inspected === null) {
+      continue;
+    }
+    candidates.push({
+      ...inspected,
+      source: "devtools-active-port",
+      installationBrand: installation.brand,
+      userDataDir: installation.userDataDir
+    });
+  }
+  const fallbackCandidate = await probeCdpEndpoint({
+    endpoint: String(DISCOVERY_FALLBACK_PORT),
+    timeoutMs
+  });
+  if (fallbackCandidate !== null) {
+    candidates.push({
+      ...fallbackCandidate,
+      source: "fallback-port"
+    });
+  }
+  return dedupeAndSortCandidates(candidates);
+}
+async function selectAttachBrowserCandidate(input = {}) {
+  const candidates = await discoverLocalCdpBrowsers(input);
+  if (candidates.length === 0) {
+    throw new Error(
+      "No running Chromium browser instance found. Enable remote debugging or specify an attach endpoint explicitly."
+    );
+  }
+  const highestPriority = Math.max(...candidates.map(getAttachCandidatePriority));
+  const winners = candidates.filter(
+    (candidate) => getAttachCandidatePriority(candidate) === highestPriority
+  );
+  if (winners.length === 1) {
+    return winners[0];
+  }
+  throw new OpensteerAttachAmbiguousError(candidates);
+}
+async function probeCdpEndpoint(input) {
+  const trimmedEndpoint = input.endpoint.trim();
+  if (!trimmedEndpoint) {
+    return null;
+  }
+  const target = normalizeProbeTarget(trimmedEndpoint);
+  const timeoutMs = input.timeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
+  const versionPayload = await fetchJson(
+    new URL("/json/version", target.httpUrl),
+    input.headers,
+    timeoutMs
+  );
+  if (versionPayload !== null) {
+    const payload = versionPayload;
+    if (typeof payload.webSocketDebuggerUrl === "string" && payload.webSocketDebuggerUrl.length > 0) {
+      return createInspectedCdpEndpoint({
+        browserWebSocketUrl: rewriteBrowserWebSocketHost(
+          payload.webSocketDebuggerUrl,
+          target.httpUrl
+        ),
+        httpUrl: target.httpUrl,
+        ...payload.Browser === void 0 ? {} : { browser: payload.Browser },
+        ...payload["Protocol-Version"] === void 0 ? {} : { protocolVersion: payload["Protocol-Version"] }
+      });
+    }
+  }
+  const listPayload = await fetchJson(new URL("/json/list", target.httpUrl), input.headers, timeoutMs);
+  if (listPayload !== null) {
+    const browserTarget = listPayload.find((candidate) => candidate.type === "browser") ?? listPayload.find((candidate) => typeof candidate.webSocketDebuggerUrl === "string");
+    if (typeof browserTarget?.webSocketDebuggerUrl === "string") {
+      return createInspectedCdpEndpoint({
+        browserWebSocketUrl: rewriteBrowserWebSocketHost(
+          browserTarget.webSocketDebuggerUrl,
+          target.httpUrl
+        ),
+        httpUrl: target.httpUrl
+      });
+    }
+  }
+  if (input.fallbackBrowserWebSocketPath !== void 0 && await isHttpEndpointReachable(target.httpUrl, timeoutMs)) {
+    return createInspectedCdpEndpoint({
+      browserWebSocketUrl: buildBrowserWebSocketUrl(
+        target.httpUrl,
+        input.fallbackBrowserWebSocketPath
+      ),
+      httpUrl: target.httpUrl
+    });
+  }
+  if (target.fallbackBrowserWebSocketUrl !== void 0 && await isHttpEndpointReachable(target.httpUrl, timeoutMs)) {
+    return createInspectedCdpEndpoint({
+      browserWebSocketUrl: target.fallbackBrowserWebSocketUrl,
+      httpUrl: target.httpUrl
+    });
+  }
+  return null;
+}
+function dedupeAndSortCandidates(candidates) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const candidate of [...candidates].sort(compareCandidates)) {
+    const existing = deduped.get(candidate.endpoint);
+    if (!existing || compareCandidates(candidate, existing) < 0) {
+      deduped.set(candidate.endpoint, candidate);
+    }
+  }
+  return [...deduped.values()].sort(compareCandidates);
+}
+function compareCandidates(left, right) {
+  return getAttachCandidatePriority(right) - getAttachCandidatePriority(left) || left.endpoint.localeCompare(right.endpoint) || (left.userDataDir ?? "").localeCompare(right.userDataDir ?? "");
+}
+function getAttachCandidatePriority(candidate) {
+  return candidate.source === "devtools-active-port" ? 2 : 1;
+}
+function createInspectedCdpEndpoint(input) {
+  const port = readPort(input.httpUrl);
+  return {
+    endpoint: input.browserWebSocketUrl,
+    ...input.browser === void 0 ? {} : { browser: input.browser },
+    ...input.protocolVersion === void 0 ? {} : { protocolVersion: input.protocolVersion },
+    httpUrl: input.httpUrl.toString(),
+    ...port === void 0 ? {} : { port }
+  };
+}
+function normalizeProbeTarget(endpoint) {
+  if (/^\d+$/.test(endpoint)) {
+    return {
+      httpUrl: new URL(`http://127.0.0.1:${endpoint}`)
+    };
+  }
+  if (endpoint.startsWith("ws://") || endpoint.startsWith("wss://")) {
+    const url = new URL(endpoint);
+    return {
+      fallbackBrowserWebSocketUrl: url.toString(),
+      httpUrl: new URL(`${url.protocol === "wss:" ? "https:" : "http:"}//${url.host}`)
+    };
+  }
+  try {
+    const url = endpoint.startsWith("http://") || endpoint.startsWith("https://") ? new URL(endpoint) : new URL(`http://${endpoint}`);
+    return {
+      httpUrl: new URL(`${url.protocol}//${url.host}`)
+    };
+  } catch {
+    throw new Error(`Invalid CDP endpoint "${endpoint}".`);
+  }
+}
+async function fetchJson(url, headers, timeoutMs) {
+  const response = await fetch(url, {
+    ...headers === void 0 ? {} : { headers },
+    signal: AbortSignal.timeout(timeoutMs)
+  }).catch(() => null);
+  if (!response?.ok) {
+    return null;
+  }
+  return await response.json();
+}
+async function isHttpEndpointReachable(url, timeoutMs) {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(timeoutMs)
+  }).catch(() => null);
+  return response !== null;
+}
+function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
+  const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
+  return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
+}
+function normalizeWebSocketPath(path5) {
+  return path5.startsWith("/") ? path5 : `/${path5}`;
+}
+function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
+  try {
+    const parsed = new URL(browserWsUrl);
+    parsed.protocol = requestedUrl.protocol === "https:" ? "wss:" : "ws:";
+    parsed.hostname = requestedUrl.hostname;
+    parsed.port = requestedUrl.port;
+    return parsed.toString();
+  } catch {
+    return browserWsUrl;
+  }
+}
+function readPort(url) {
+  const port = Number.parseInt(url.port, 10);
+  return Number.isInteger(port) && port > 0 ? port : void 0;
+}
+
+// ../runtime-core/src/json.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function canonicalizeJsonValue(value, path5) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`${path5} must be a finite JSON number`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path5}[${index}]`));
+  }
+  if (!isPlainObject(value)) {
+    throw new TypeError(`${path5} must be a plain JSON object`);
+  }
+  const sorted = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  const result = {};
+  for (const key of sorted) {
+    const entry = value[key];
+    if (entry === void 0) {
+      throw new TypeError(`${path5}.${key} must not be undefined`);
+    }
+    result[key] = canonicalizeJsonValue(entry, `${path5}.${key}`);
+  }
+  return result;
+}
+function toCanonicalJsonValue(value) {
+  return canonicalizeJsonValue(value, "value");
+}
+function canonicalJsonString(value) {
+  return JSON.stringify(toCanonicalJsonValue(value));
+}
+function stableJsonString(value) {
+  return `${JSON.stringify(toCanonicalJsonValue(value), null, 2)}
+`;
+}
+
+// ../runtime-core/src/internal/filesystem.ts
+var LOCK_RETRY_DELAYS_MS = [1, 2, 5, 10, 20, 50];
+function normalizeNonEmptyString(name, value) {
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new TypeError(`${name} must not be empty`);
+  }
+  return normalized;
+}
+function normalizeTimestamp(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${name} must be a non-negative integer`);
+  }
+  return value;
+}
+function encodePathSegment(value) {
+  return encodeURIComponent(normalizeNonEmptyString("path segment", value));
+}
+function joinStoragePath(...segments) {
+  return segments.join("/");
+}
+function resolveStoragePath(rootPath, relativePath) {
+  if (path3.isAbsolute(relativePath)) {
+    throw new TypeError(`storage path ${relativePath} must be relative`);
+  }
+  const segments = relativePath.split("/");
+  if (segments.length === 0 || segments.some((segment) => segment.length === 0)) {
+    throw new TypeError(`storage path ${relativePath} is invalid`);
+  }
+  for (const segment of segments) {
+    if (segment === "." || segment === "..") {
+      throw new TypeError(`storage path ${relativePath} must not contain path traversal`);
+    }
+  }
+  return path3.join(rootPath, ...segments);
+}
+async function ensureDirectory(directoryPath) {
+  await mkdir(directoryPath, { recursive: true });
+}
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+async function writeJsonFileAtomic(filePath, value) {
+  await writeTextFileAtomic(filePath, stableJsonString(value));
+}
+async function writeTextFileAtomic(filePath, value) {
+  await ensureDirectory(path3.dirname(filePath));
+  const temporaryPath = `${filePath}.${randomUUID()}.tmp`;
+  await writeFile(temporaryPath, value, "utf8");
+  await rename(temporaryPath, filePath);
+}
+async function writeJsonFileExclusive(filePath, value) {
+  await writeTextFileExclusive(filePath, stableJsonString(value));
+}
+async function writeTextFileExclusive(filePath, value) {
+  await ensureDirectory(path3.dirname(filePath));
+  const handle = await open(filePath, "wx");
+  try {
+    await handle.writeFile(value, "utf8");
+  } finally {
+    await handle.close();
+  }
+}
+async function writeBufferIfMissing(filePath, value) {
+  await ensureDirectory(path3.dirname(filePath));
+  try {
+    const handle = await open(filePath, "wx");
+    try {
+      await handle.writeFile(value);
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (isAlreadyExistsError(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+async function readBinaryFile(filePath) {
+  return new Uint8Array(await readFile(filePath));
+}
+async function listJsonFiles(directoryPath) {
+  if (!await pathExists(directoryPath)) {
+    return [];
+  }
+  return (await readdir(directoryPath)).filter((entry) => entry.endsWith(".json")).sort((left, right) => left.localeCompare(right));
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function filePathToUri(filePath) {
+  return pathToFileURL(filePath).toString();
+}
+function isAlreadyExistsError(error) {
+  return error?.code === "EEXIST";
+}
+async function withFilesystemLock(lockPath, task) {
+  await ensureDirectory(path3.dirname(lockPath));
+  let attempt = 0;
+  while (true) {
+    try {
+      await mkdir(lockPath);
+      break;
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) {
+        throw error;
+      }
+      const delayMs = LOCK_RETRY_DELAYS_MS[Math.min(attempt, LOCK_RETRY_DELAYS_MS.length - 1)];
+      attempt += 1;
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+    }
+  }
+  try {
+    return await task();
+  } finally {
+    await rm(lockPath, { recursive: true, force: true });
+  }
+}
+
+// src/live-session.ts
+var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
+var OPENSTEER_LIVE_SESSION_VERSION = 1;
+function resolveLiveSessionRecordPath(rootPath, provider) {
+  return path3.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+}
+function resolveLocalSessionRecordPath(rootPath) {
+  return resolveLiveSessionRecordPath(rootPath, "local");
+}
+function resolveCloudSessionRecordPath(rootPath) {
+  return resolveLiveSessionRecordPath(rootPath, "cloud");
+}
+async function readPersistedSessionRecord(rootPath, provider) {
+  const sessionPath = resolveLiveSessionRecordPath(rootPath, provider);
+  if (!await pathExists(sessionPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(sessionPath);
+  if (provider === "local" && isPersistedLocalBrowserSessionRecord(parsed)) {
+    return parsed;
+  }
+  if (provider === "cloud" && isPersistedCloudSessionRecord(parsed)) {
+    return parsed;
+  }
+  return void 0;
+}
+async function readPersistedCloudSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath, "cloud");
+  return record?.provider === "cloud" ? record : void 0;
+}
+async function readPersistedLocalBrowserSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath, "local");
+  return record?.provider === "local" ? record : void 0;
+}
+async function writePersistedSessionRecord(rootPath, record) {
+  await writeJsonFileAtomic(resolveLiveSessionRecordPath(rootPath, record.provider), record);
+}
+async function clearPersistedSessionRecord(rootPath, provider) {
+  await rm(resolveLiveSessionRecordPath(rootPath, provider), { force: true });
+}
+function isPersistedCloudSessionRecord(value) {
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+function isPersistedLocalBrowserSessionRecord(value) {
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "local" && (value.engine === "playwright" || value.engine === "abp") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
+}
+function resolveOpensteerStateDir() {
+  const explicit = process.env.OPENSTEER_HOME?.trim();
+  if (explicit) {
+    return path3.resolve(explicit);
+  }
+  if (process.platform === "win32") {
+    return path3.join(
+      process.env.LOCALAPPDATA ?? path3.join(homedir(), "AppData", "Local"),
+      "Opensteer"
+    );
+  }
+  if (process.platform === "darwin") {
+    return path3.join(homedir(), "Library", "Application Support", "Opensteer");
+  }
+  return path3.join(
+    process.env.XDG_STATE_HOME ?? path3.join(homedir(), ".local", "state"),
+    "opensteer"
+  );
+}
+function resolveLocalViewRootDir() {
+  return path3.join(resolveOpensteerStateDir(), "local-view");
+}
+function resolveLocalViewPreferencesPath() {
+  return path3.join(resolveLocalViewRootDir(), "preferences.json");
+}
+function resolveLocalViewServiceDir() {
+  return path3.join(resolveLocalViewRootDir(), "service");
+}
+function resolveLocalViewSessionsDir() {
+  return path3.join(resolveLocalViewRootDir(), "sessions");
+}
+function resolveLocalViewServiceLockDir() {
+  return path3.join(resolveLocalViewServiceDir(), "startup.lock");
+}
+function resolveLocalViewServiceStatePath() {
+  return path3.join(resolveLocalViewServiceDir(), "state.json");
+}
+
+// src/local-view/session-manifest.ts
+var OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT = "opensteer-local-view-session";
+var OPENSTEER_LOCAL_VIEW_SESSION_VERSION = 1;
+function buildLocalViewSessionId(input) {
+  const hash = createHash("sha256").update(`${input.rootPath}
+${String(input.pid)}
+${String(input.startedAt)}`).digest("hex");
+  return `local_${hash.slice(0, 24)}`;
+}
+function createLocalViewSessionManifest(input) {
+  return {
+    layout: OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_SESSION_VERSION,
+    sessionId: buildLocalViewSessionId({
+      rootPath: input.rootPath,
+      pid: input.live.pid,
+      startedAt: input.live.startedAt
+    }),
+    rootPath: input.rootPath,
+    ...input.workspace === void 0 ? {} : { workspace: input.workspace },
+    engine: input.live.engine,
+    ownership: input.ownership,
+    pid: input.live.pid,
+    startedAt: input.live.startedAt,
+    updatedAt: Date.now()
+  };
+}
+async function writeLocalViewSessionManifest(manifest) {
+  await ensureDirectory(resolveLocalViewSessionsDir());
+  await writeJsonFileAtomic(resolveLocalViewSessionManifestPath(manifest.sessionId), manifest);
+}
+async function deleteLocalViewSessionManifest(sessionId) {
+  await rm(resolveLocalViewSessionManifestPath(sessionId), { force: true }).catch(() => void 0);
+}
+async function readLocalViewSessionManifest(sessionId) {
+  const manifestPath = resolveLocalViewSessionManifestPath(sessionId);
+  if (!await pathExists(manifestPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(manifestPath);
+  return isPersistedLocalViewSessionManifest(parsed) ? parsed : void 0;
+}
+async function listLocalViewSessionManifests() {
+  const directoryPath = resolveLocalViewSessionsDir();
+  const fileNames = await listJsonFiles(directoryPath);
+  const manifests = await Promise.all(
+    fileNames.map(async (fileName) => {
+      const parsed = await readJsonFile(
+        path3.join(directoryPath, fileName)
+      ).catch(() => void 0);
+      return isPersistedLocalViewSessionManifest(parsed) ? parsed : void 0;
+    })
+  );
+  return manifests.filter((manifest) => manifest !== void 0).sort(
+    (left, right) => left.startedAt - right.startedAt || left.sessionId.localeCompare(right.sessionId)
+  );
+}
+function resolveLocalViewSessionManifestPath(sessionId) {
+  return path3.join(resolveLocalViewSessionsDir(), `${sessionId}.json`);
+}
+function isPersistedLocalViewSessionManifest(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_SESSION_VERSION && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.rootPath === "string" && value.rootPath.length > 0 && (value.engine === "playwright" || value.engine === "abp") && (value.ownership === "owned" || value.ownership === "attached" || value.ownership === "managed") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+var execFileAsync = promisify(execFile);
+var PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
+var PROCESS_START_TIME_TOLERANCE_MS = 1e3;
+var PROCESS_LIST_MAX_BUFFER_BYTES2 = 16 * 1024 * 1024;
+var PS_COMMAND_ENV2 = { ...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;
+  }
+  return {
+    pid,
+    processStartedAtMs
+  };
+}
+function processOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
+}
+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 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 hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
+}
+async function readProcessStartedAtMs(pid) {
+  if (pid <= 0) {
+    return null;
+  }
+  if (process.platform === "linux") {
+    return readLinuxProcessStartedAtMs(pid);
+  }
+  if (process.platform === "win32") {
+    return readWindowsProcessStartedAtMs(pid);
+  }
+  return readPsProcessStartedAtMs(pid);
+}
+async function readLinuxProcessStartedAtMs(pid) {
+  let statRaw;
+  try {
+    statRaw = await readFile(`/proc/${String(pid)}/stat`, "utf8");
+  } catch {
+    return null;
+  }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
+  }
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(bootTimeMs + startTicks * 1e3 / clockTicksPerSecond);
+}
+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 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;
+  }
+}
+async function readLinuxClockTicksPerSecond() {
+  if (!linuxClockTicksPerSecondPromise) {
+    linuxClockTicksPerSecondPromise = execFileAsync("getconf", ["CLK_TCK"], {
+      encoding: "utf8",
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2
+    }).then(({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    }).catch(() => null);
+  }
+  return linuxClockTicksPerSecondPromise;
+}
+async function readWindowsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${String(pid)}).StartTime.ToUniversalTime().ToString("o")`
+      ],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2
+      }
+    );
+    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_ENV2,
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2
+    });
+    const startedAt = stdout.trim();
+    if (!startedAt) {
+      return null;
+    }
+    const startedAtMs = Date.parse(startedAt.replace(/\s+/g, " "));
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+var OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT = "opensteer-local-view-service";
+var OPENSTEER_LOCAL_VIEW_SERVICE_VERSION = 3;
+async function readLocalViewServiceState() {
+  const statePath = resolveLocalViewServiceStatePath();
+  if (!await pathExists(statePath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(statePath);
+  if (!isPersistedLocalViewServiceState(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+async function writeLocalViewServiceState(state) {
+  await writeJsonFileAtomic(resolveLocalViewServiceStatePath(), state);
+}
+async function clearLocalViewServiceState(match = void 0) {
+  if (match !== void 0) {
+    const current = await readLocalViewServiceState();
+    if (current === void 0 || current.pid !== match.pid || current.token !== match.token) {
+      return;
+    }
+  }
+  await rm(resolveLocalViewServiceStatePath(), { force: true });
+}
+async function isLocalViewServiceStateLive(state) {
+  return await getLocalViewServiceStateLiveness(state) !== "dead";
+}
+async function getLocalViewServiceStateLiveness(state) {
+  if (state === void 0) {
+    return "dead";
+  }
+  return getProcessLiveness({
+    pid: state.pid,
+    processStartedAtMs: state.processStartedAtMs
+  });
+}
+function isPersistedLocalViewServiceState(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_SERVICE_VERSION && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.processStartedAtMs === "number" && Number.isFinite(value.processStartedAtMs) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.port === "number" && Number.isFinite(value.port) && typeof value.token === "string" && value.token.length > 0 && typeof value.url === "string" && value.url.length > 0;
+}
+
+export { CURRENT_PROCESS_OWNER, OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT, OPENSTEER_LOCAL_VIEW_SERVICE_VERSION, OpensteerAttachAmbiguousError, __require, buildLocalViewSessionId, canonicalJsonString, clearLocalViewServiceState, clearPersistedSessionRecord, createLocalViewSessionManifest, deleteLocalViewSessionManifest, detectInstalledBrowserBrands, discoverLocalCdpBrowsers, encodePathSegment, ensureDirectory, expandHome, filePathToUri, getBrowserBrand, getLocalViewServiceStateLiveness, getProcessLiveness, inspectCdpEndpoint, isAlreadyExistsError, isLocalViewServiceStateLive, isProcessRunning, joinStoragePath, listJsonFiles, listLocalChromeProfiles, listLocalViewSessionManifests, normalizeNonEmptyString, normalizeTimestamp, parseProcessOwner, pathExists, processOwnersEqual, readBinaryFile, readDevToolsActivePort, readJsonFile, readLocalViewServiceState, readLocalViewSessionManifest, readPersistedCloudSessionRecord, readPersistedLocalBrowserSessionRecord, readPersistedSessionRecord, resolveBrandUserDataDir, resolveChromeExecutablePath, resolveCloudSessionRecordPath, resolveLiveSessionRecordPath, resolveLocalSessionRecordPath, resolveLocalViewPreferencesPath, resolveLocalViewServiceLockDir, resolveStoragePath, selectAttachBrowserCandidate, sha256Hex, toCanonicalJsonValue, withFilesystemLock, writeBufferIfMissing, writeJsonFileAtomic, writeJsonFileExclusive, writeLocalViewServiceState, writeLocalViewSessionManifest, writePersistedSessionRecord };
+//# sourceMappingURL=chunk-BMPUL66S.js.map
+//# sourceMappingURL=chunk-BMPUL66S.js.map