peachsim 0.1.527

package/dist-lib/home-paths.cjs

@@ -0,0 +1,638 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/home-paths.ts
+var home_paths_exports = {};
+__export(home_paths_exports, {
+  ACTIVE_RUNTIME_FILE: () => ACTIVE_RUNTIME_FILE,
+  CLI_UPDATE_FILE: () => CLI_UPDATE_FILE,
+  CONFIG_FILE: () => CONFIG_FILE,
+  DAEMON_HEARTBEAT_STALE_MS: () => DAEMON_HEARTBEAT_STALE_MS,
+  DAEMON_LOCKFILE: () => DAEMON_LOCKFILE,
+  DEV_BRIDGES_DIR: () => DEV_BRIDGES_DIR,
+  RNX_HOME_ENV: () => RNX_HOME_ENV,
+  activeRuntimeDir: () => activeRuntimeDir,
+  activeRuntimeFile: () => activeRuntimeFile,
+  cacheDir: () => cacheDir,
+  cameraFixturesDir: () => cameraFixturesDir,
+  claimDaemonLockfile: () => claimDaemonLockfile,
+  cliUpdateFilePath: () => cliUpdateFilePath,
+  configFilePath: () => configFilePath,
+  consumeRuntimeUpgradeNotice: () => consumeRuntimeUpgradeNotice,
+  daemonAppBundlePath: () => daemonAppBundlePath,
+  daemonAppDir: () => daemonAppDir,
+  daemonAppLauncherPath: () => daemonAppLauncherPath,
+  daemonLockfilePath: () => daemonLockfilePath,
+  devBridgeLockfilePath: () => devBridgeLockfilePath,
+  devBridgesDir: () => devBridgesDir,
+  electronDir: () => electronDir,
+  electronUserDataDir: () => electronUserDataDir,
+  electronVersionDir: () => electronVersionDir,
+  ensureRnxHome: () => ensureRnxHome,
+  isDaemonLockfileFresh: () => isDaemonLockfileFresh,
+  isDevBridgeLockfileFresh: () => isDevBridgeLockfileFresh,
+  isDevWorkstation: () => isDevWorkstation,
+  isOnboardingComplete: () => isOnboardingComplete,
+  isSootsimDevCheckout: () => isSootsimDevCheckout,
+  profilesDir: () => profilesDir,
+  readActiveRuntime: () => readActiveRuntime,
+  readDaemonLockfile: () => readDaemonLockfile,
+  readDefaultBox: () => readDefaultBox,
+  readDevBridgeLockfiles: () => readDevBridgeLockfiles,
+  readLiveRuntimeVersions: () => readLiveRuntimeVersions,
+  readOrCreateAnonymousId: () => readOrCreateAnonymousId,
+  readPrivacyPreferences: () => readPrivacyPreferences,
+  readSharedConfig: () => readSharedConfig,
+  readSimulatorDriverPreference: () => readSimulatorDriverPreference,
+  removeDaemonLockfile: () => removeDaemonLockfile,
+  removeDevBridgeLockfile: () => removeDevBridgeLockfile,
+  rnxHomeDir: () => rnxHomeDir,
+  runtimeDir: () => runtimeDir,
+  runtimeUpgradeNoticePath: () => runtimeUpgradeNoticePath,
+  runtimesDir: () => runtimesDir,
+  shouldSkipPersistentDaemon: () => shouldSkipPersistentDaemon,
+  writeActiveRuntime: () => writeActiveRuntime,
+  writeDaemonLockfile: () => writeDaemonLockfile,
+  writeDefaultBox: () => writeDefaultBox,
+  writeDevBridgeLockfile: () => writeDevBridgeLockfile,
+  writeOnboardingPreferences: () => writeOnboardingPreferences,
+  writePrivacyPreferences: () => writePrivacyPreferences,
+  writeRuntimeUpgradeNotice: () => writeRuntimeUpgradeNotice,
+  writeSharedConfig: () => writeSharedConfig
+});
+module.exports = __toCommonJS(home_paths_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var RNX_HOME_ENV = "RNX_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.json";
+var DEV_BRIDGES_DIR = "dev-bridges";
+var CONFIG_FILE = "config.json";
+var CLI_UPDATE_FILE = "cli-update.json";
+var DAEMON_HEARTBEAT_STALE_MS = 3e4;
+function rnxHomeDir() {
+  const override = process.env[RNX_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".rnx");
+}
+function isSootsimDevCheckout() {
+  if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
+  const env = process.env.SOOTSIM_DEV;
+  if (env === "1" || env === "true") return true;
+  if (env === "0" || env === "false") return false;
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  try {
+    const real = import_node_fs.default.realpathSync(argv1);
+    return real.includes(`${import_node_path.default.sep}packages${import_node_path.default.sep}sootsim${import_node_path.default.sep}`);
+  } catch {
+    return false;
+  }
+}
+function isDevWorkstation() {
+  if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
+  return process.env.IS_TAMAGUI_DEV === "1";
+}
+function shouldSkipPersistentDaemon() {
+  return isSootsimDevCheckout() || isDevWorkstation();
+}
+function runtimesDir() {
+  return import_node_path.default.join(rnxHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function electronDir() {
+  return import_node_path.default.join(rnxHomeDir(), "electron");
+}
+function electronUserDataDir() {
+  return import_node_path.default.join(electronDir(), "userData");
+}
+function electronVersionDir(version) {
+  return import_node_path.default.join(electronDir(), version);
+}
+function profilesDir() {
+  return import_node_path.default.join(rnxHomeDir(), "profiles");
+}
+function cameraFixturesDir() {
+  return import_node_path.default.join(rnxHomeDir(), "camera-fixtures");
+}
+function daemonAppDir() {
+  return import_node_path.default.join(rnxHomeDir(), "daemon-app");
+}
+function daemonAppBundlePath() {
+  return import_node_path.default.join(daemonAppDir(), "RNX Daemon.app");
+}
+function daemonAppLauncherPath() {
+  return import_node_path.default.join(daemonAppBundlePath(), "Contents", "MacOS", "rnx-daemon");
+}
+function cacheDir() {
+  return import_node_path.default.join(rnxHomeDir(), "cache");
+}
+function daemonLockfilePath() {
+  return import_node_path.default.join(rnxHomeDir(), DAEMON_LOCKFILE);
+}
+function devBridgesDir() {
+  return import_node_path.default.join(rnxHomeDir(), DEV_BRIDGES_DIR);
+}
+function devBridgeLockfilePath(bridgePort) {
+  if (!Number.isInteger(bridgePort) || bridgePort <= 0) {
+    throw new Error(`invalid development bridge port: ${bridgePort}`);
+  }
+  return import_node_path.default.join(devBridgesDir(), `${bridgePort}.json`);
+}
+function configFilePath() {
+  return import_node_path.default.join(rnxHomeDir(), CONFIG_FILE);
+}
+function cliUpdateFilePath() {
+  return import_node_path.default.join(rnxHomeDir(), CLI_UPDATE_FILE);
+}
+function readSharedConfig() {
+  try {
+    const raw = import_node_fs.default.readFileSync(configFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeSharedConfig(patch) {
+  ensureRnxHome();
+  const current = readSharedConfig();
+  const next = { ...current, ...patch };
+  if (patch.settings && typeof patch.settings === "object") {
+    next.settings = {
+      ...current.settings && typeof current.settings === "object" ? current.settings : {},
+      ...patch.settings
+    };
+  }
+  const tmp = `${configFilePath()}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  import_node_fs.default.renameSync(tmp, configFilePath());
+  return next;
+}
+var CURRENT_ONBOARDING_VERSION = 1;
+function isOnboardingComplete() {
+  return readSharedConfig().onboardingVersion === CURRENT_ONBOARDING_VERSION;
+}
+function readSimulatorDriverPreference() {
+  const driver = readSharedConfig().simulatorDriver;
+  return driver === "electron" || driver === "playwright" ? driver : null;
+}
+function writeOnboardingPreferences(driver) {
+  writeSharedConfig({
+    onboardingVersion: CURRENT_ONBOARDING_VERSION,
+    simulatorDriver: driver
+  });
+}
+function readPrivacyPreferences() {
+  const settings = readSharedConfig().settings;
+  const productAnalytics = settings?.productAnalytics;
+  const crashReports = settings?.crashReports;
+  return {
+    productAnalytics: typeof productAnalytics === "boolean" ? productAnalytics : false,
+    crashReports: typeof crashReports === "boolean" ? crashReports : false,
+    configured: typeof productAnalytics === "boolean" && typeof crashReports === "boolean"
+  };
+}
+function writePrivacyPreferences(preferences) {
+  writeSharedConfig({
+    settings: {
+      productAnalytics: preferences.productAnalytics,
+      crashReports: preferences.crashReports
+    }
+  });
+}
+function readOrCreateAnonymousId() {
+  const existing = readSharedConfig().anonymousId;
+  if (typeof existing === "string" && existing.trim()) return existing;
+  const created = `anon-cli-${(0, import_node_crypto.randomUUID)()}`;
+  writeSharedConfig({ anonymousId: created });
+  return created;
+}
+function readDefaultBox() {
+  const stored = readSharedConfig().defaultBox;
+  if (typeof stored !== "object" || stored === null) return null;
+  if (!("boxId" in stored) || typeof stored.boxId !== "string" || !stored.boxId) {
+    return null;
+  }
+  const name = "name" in stored && typeof stored.name === "string" ? stored.name : null;
+  return { boxId: stored.boxId, name };
+}
+function writeDefaultBox(box) {
+  writeSharedConfig({ defaultBox: box });
+}
+function runtimeUpgradeNoticePath() {
+  return import_node_path.default.join(rnxHomeDir(), "runtime-upgraded.json");
+}
+function writeRuntimeUpgradeNotice(notice) {
+  ensureRnxHome();
+  const tmp = `${runtimeUpgradeNoticePath()}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(notice)}
+`, "utf8");
+  import_node_fs.default.renameSync(tmp, runtimeUpgradeNoticePath());
+}
+function consumeRuntimeUpgradeNotice() {
+  try {
+    const raw = import_node_fs.default.readFileSync(runtimeUpgradeNoticePath(), "utf8");
+    import_node_fs.default.unlinkSync(runtimeUpgradeNoticePath());
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.to !== "string" || !parsed.to) return null;
+    return {
+      from: typeof parsed.from === "string" ? parsed.from : null,
+      to: parsed.to,
+      at: typeof parsed.at === "number" ? parsed.at : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function ensureRnxHome() {
+  import_node_fs.default.mkdirSync(rnxHomeDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(cacheDir(), { recursive: true });
+}
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeActiveRuntime(version) {
+  import_node_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs.default.writeFileSync(activeRuntimeFile(), `${version}
+`, "utf8");
+}
+function activeRuntimeDir() {
+  const version = readActiveRuntime();
+  if (!version) return null;
+  const dir = runtimeDir(version);
+  try {
+    if (import_node_fs.default.statSync(dir).isDirectory()) return dir;
+  } catch {
+  }
+  return null;
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+var DAEMON_CLAIM_STALE_MS = 3e4;
+function readDaemonLockfile() {
+  try {
+    const fd = import_node_fs.default.openSync(daemonLockfilePath(), "r");
+    try {
+      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+      const bytesRead = import_node_fs.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const raw = buf.subarray(0, bytesRead).toString("utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
+        return parsed;
+      }
+      return null;
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function parseDevBridgeLockfile(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.schema === 1 && parsed.source === "vite-dev" && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.cwd === "string" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.shellPort === void 0 || typeof parsed.shellPort === "number") && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readDevBridgeLockfiles() {
+  let entries;
+  try {
+    entries = import_node_fs.default.readdirSync(devBridgesDir(), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const lockfiles = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !/^\d+\.json$/.test(entry.name)) continue;
+    try {
+      const filePath = import_node_path.default.join(devBridgesDir(), entry.name);
+      const fd = import_node_fs.default.openSync(filePath, "r");
+      try {
+        const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+        const bytesRead = import_node_fs.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+        const lockfile = parseDevBridgeLockfile(
+          buf.subarray(0, bytesRead).toString("utf8")
+        );
+        if (lockfile && entry.name === `${lockfile.bridgePort}.json`) {
+          lockfiles.push(lockfile);
+        }
+      } finally {
+        import_node_fs.default.closeSync(fd);
+      }
+    } catch {
+    }
+  }
+  return lockfiles.sort((left, right) => left.bridgePort - right.bridgePort);
+}
+function isDaemonLockfileFresh(lock, now = Date.now()) {
+  if (!lock) return false;
+  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDevBridgeLockfileFresh(lock, now = Date.now()) {
+  if (!lock) return false;
+  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readLiveRuntimeVersions() {
+  const versions = /* @__PURE__ */ new Set();
+  const daemon = readDaemonLockfile();
+  if (isDaemonLockfileFresh(daemon)) {
+    if (daemon.activeRuntime) versions.add(daemon.activeRuntime);
+    for (const version of daemon.servedRuntimes ?? []) versions.add(version);
+  }
+  for (const devBridge of readDevBridgeLockfiles()) {
+    if (!isDevBridgeLockfileFresh(devBridge)) continue;
+    for (const version of devBridge.servedRuntimes ?? []) versions.add(version);
+  }
+  return [...versions].sort();
+}
+function writeDaemonLockfile(data) {
+  ensureRnxHome();
+  const lockfilePath = daemonLockfilePath();
+  const existing = readDaemonLockfile();
+  if (!existing) {
+    if (createDaemonLockfileExclusive(data)) return;
+    throw new Error("another rnx daemon claimed the lockfile before this write");
+  }
+  if (!sameDaemonOwner(existing, data)) {
+    throw new Error("refusing to overwrite another rnx daemon lockfile");
+  }
+  const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  try {
+    const current = readDaemonLockfile();
+    if (!current || !sameDaemonOwner(current, data)) {
+      throw new Error("rnx daemon lock ownership changed during heartbeat");
+    }
+    import_node_fs.default.renameSync(tmp, lockfilePath);
+  } finally {
+    try {
+      import_node_fs.default.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function writeDevBridgeLockfile(data) {
+  import_node_fs.default.mkdirSync(devBridgesDir(), { recursive: true });
+  const lockfilePath = devBridgeLockfilePath(data.bridgePort);
+  const tmp = `${lockfilePath}.${data.pid}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  import_node_fs.default.renameSync(tmp, lockfilePath);
+}
+function sameDaemonOwner(left, right) {
+  return left.pid === right.pid && left.startedAt === right.startedAt;
+}
+function isAlreadyExists(error) {
+  return error instanceof Error && "code" in error && Reflect.get(error, "code") === "EEXIST";
+}
+function createDaemonLockfileExclusive(data) {
+  const lockfilePath = daemonLockfilePath();
+  const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.claim`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  try {
+    import_node_fs.default.linkSync(tmp, lockfilePath);
+    return true;
+  } catch (error) {
+    if (isAlreadyExists(error)) return false;
+    throw error;
+  } finally {
+    try {
+      import_node_fs.default.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function daemonClaimPath() {
+  return `${daemonLockfilePath()}.claim`;
+}
+function parseDaemonClaim(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value !== null && typeof value === "object" && typeof Reflect.get(value, "pid") === "number" && typeof Reflect.get(value, "startedAt") === "number" && typeof Reflect.get(value, "createdAt") === "number") {
+      return {
+        pid: Reflect.get(value, "pid"),
+        startedAt: Reflect.get(value, "startedAt"),
+        createdAt: Reflect.get(value, "createdAt")
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function readDaemonClaim() {
+  try {
+    return parseDaemonClaim(import_node_fs.default.readFileSync(daemonClaimPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isDaemonClaimFresh(claim, now = Date.now()) {
+  if (now - claim.createdAt > DAEMON_CLAIM_STALE_MS) return false;
+  try {
+    process.kill(claim.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireDaemonClaim(data) {
+  const claim = {
+    pid: data.pid,
+    startedAt: data.startedAt,
+    createdAt: Date.now()
+  };
+  const serialized = `${JSON.stringify(claim)}
+`;
+  for (let attempt = 0; attempt < 8; attempt++) {
+    try {
+      import_node_fs.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
+      return true;
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+    }
+    const existing = readDaemonClaim();
+    if (existing && sameDaemonOwner(existing, claim)) return true;
+    if (existing && isDaemonClaimFresh(existing)) return false;
+    let before;
+    try {
+      before = import_node_fs.default.readFileSync(daemonClaimPath(), "utf8");
+      const latest = parseDaemonClaim(before);
+      if (latest && isDaemonClaimFresh(latest)) return false;
+      if (import_node_fs.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs.default.unlinkSync(daemonClaimPath());
+    } catch {
+    }
+  }
+  return false;
+}
+function releaseDaemonClaim(owner) {
+  try {
+    const claim = readDaemonClaim();
+    if (!claim || !sameDaemonOwner(claim, owner)) return;
+    import_node_fs.default.unlinkSync(daemonClaimPath());
+  } catch {
+  }
+}
+function claimDaemonLockfile(data) {
+  ensureRnxHome();
+  if (!acquireDaemonClaim(data)) return false;
+  try {
+    const existing = readDaemonLockfile();
+    if (existing && sameDaemonOwner(existing, data)) {
+      writeDaemonLockfile(data);
+      return true;
+    }
+    if (existing && isDaemonLockfileFresh(existing)) return false;
+    if (existing) {
+      const latest = readDaemonLockfile();
+      if (!latest || !sameDaemonOwner(latest, existing)) return false;
+      if (isDaemonLockfileFresh(latest)) return false;
+      try {
+        import_node_fs.default.unlinkSync(daemonLockfilePath());
+      } catch {
+        return false;
+      }
+    }
+    return createDaemonLockfileExclusive(data);
+  } finally {
+    releaseDaemonClaim(data);
+  }
+}
+function removeDaemonLockfile(owner) {
+  try {
+    const lockfile = readDaemonLockfile();
+    if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
+    import_node_fs.default.unlinkSync(daemonLockfilePath());
+  } catch {
+  }
+}
+function removeDevBridgeLockfile(owner) {
+  try {
+    const lockfilePath = devBridgeLockfilePath(owner.bridgePort);
+    const lockfile = parseDevBridgeLockfile(import_node_fs.default.readFileSync(lockfilePath, "utf8"));
+    if (lockfile?.pid !== owner.pid || lockfile.startedAt !== owner.startedAt) return;
+    import_node_fs.default.unlinkSync(lockfilePath);
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTIVE_RUNTIME_FILE,
+  CLI_UPDATE_FILE,
+  CONFIG_FILE,
+  DAEMON_HEARTBEAT_STALE_MS,
+  DAEMON_LOCKFILE,
+  DEV_BRIDGES_DIR,
+  RNX_HOME_ENV,
+  activeRuntimeDir,
+  activeRuntimeFile,
+  cacheDir,
+  cameraFixturesDir,
+  claimDaemonLockfile,
+  cliUpdateFilePath,
+  configFilePath,
+  consumeRuntimeUpgradeNotice,
+  daemonAppBundlePath,
+  daemonAppDir,
+  daemonAppLauncherPath,
+  daemonLockfilePath,
+  devBridgeLockfilePath,
+  devBridgesDir,
+  electronDir,
+  electronUserDataDir,
+  electronVersionDir,
+  ensureRnxHome,
+  isDaemonLockfileFresh,
+  isDevBridgeLockfileFresh,
+  isDevWorkstation,
+  isOnboardingComplete,
+  isSootsimDevCheckout,
+  profilesDir,
+  readActiveRuntime,
+  readDaemonLockfile,
+  readDefaultBox,
+  readDevBridgeLockfiles,
+  readLiveRuntimeVersions,
+  readOrCreateAnonymousId,
+  readPrivacyPreferences,
+  readSharedConfig,
+  readSimulatorDriverPreference,
+  removeDaemonLockfile,
+  removeDevBridgeLockfile,
+  rnxHomeDir,
+  runtimeDir,
+  runtimeUpgradeNoticePath,
+  runtimesDir,
+  shouldSkipPersistentDaemon,
+  writeActiveRuntime,
+  writeDaemonLockfile,
+  writeDefaultBox,
+  writeDevBridgeLockfile,
+  writeOnboardingPreferences,
+  writePrivacyPreferences,
+  writeRuntimeUpgradeNotice,
+  writeSharedConfig
+});