rnxsim 0.0.0 → 0.1.312

package/dist-lib/detox/jest-preset.cjs

@@ -0,0 +1,51 @@
+// jest preset for running existing detox suites against sootsim.
+//
+// users drop `preset: 'sootsim/detox/jest-preset'` into their jest config
+// (or `sootsim-detox.config.cjs`) and their `import { by, device, element,
+// expect, waitFor } from 'detox'` calls resolve to the sootsim driver.
+
+const path = require('path')
+
+// resolve the published driver entry so the mapping works from any cwd.
+// `require.resolve('sootsim/detox')` honours the subpath export in the
+// sootsim package.json.
+const DRIVER_ENTRY = require.resolve('rnxsim/detox')
+const PACKAGE_ROOT = path.dirname(require.resolve('rnxsim/package.json'))
+
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  testTimeout: 180000,
+  maxWorkers: 1,
+  watchman: false,
+  forceExit: true,
+  verbose: true,
+  testEnvironment: 'node',
+  setupFilesAfterEnv: [path.join(PACKAGE_ROOT, 'detox', 'jest-setup-after-env.cjs')],
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        isolatedModules: true,
+        tsconfig: {
+          module: 'commonjs',
+          target: 'es2020',
+          esModuleInterop: true,
+          jsx: 'react-jsx',
+          strict: false,
+          skipLibCheck: true,
+          moduleResolution: 'node',
+          allowJs: true,
+          resolveJsonModule: true,
+        },
+      },
+    ],
+  },
+  moduleNameMapper: {
+    '^detox$': DRIVER_ENTRY,
+    // shared utils some external detox suites import relatively.
+    '^\\.\\./utils/navigation$': path.join(PACKAGE_ROOT, 'detox', 'navigation.ts'),
+    '^\\.\\./utils/colors$': path.join(PACKAGE_ROOT, 'detox', 'colors.ts'),
+    '^\\./(utils/navigation)$': path.join(PACKAGE_ROOT, 'detox', 'navigation.ts'),
+    '^\\./(utils/colors)$': path.join(PACKAGE_ROOT, 'detox', 'colors.ts'),
+  },
+}

package/dist-lib/dev-bundle-resolution.cjs

@@ -0,0 +1,223 @@
+/*! rnx v0.1.312 | (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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dev-bundle-resolution.ts
+var dev_bundle_resolution_exports = {};
+__export(dev_bundle_resolution_exports, {
+  DEFAULT_TEST_DRIVE_PORT: () => DEFAULT_TEST_DRIVE_PORT,
+  inferManifestFramework: () => inferManifestFramework,
+  probePortBundle: () => probePortBundle,
+  resolveConnectionInput: () => resolveConnectionInput
+});
+module.exports = __toCommonJS(dev_bundle_resolution_exports);
+
+// src/backend-origin.ts
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+// src/native-dev-bundle-url.ts
+var METRO_BUNDLE_PATH = "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
+function isAbsoluteHttpUrl(url) {
+  return /^https?:\/\//i.test(url);
+}
+function isNativeDevBundlePath(pathname) {
+  return pathname.endsWith(".bundle");
+}
+function applyPreviewProdBundle(parsed) {
+  if (!process.env.SOOTSIM_PREVIEW_PROD_BUNDLE) return;
+  parsed.searchParams.set("dev", "false");
+  parsed.searchParams.set("minify", "true");
+  if (parsed.searchParams.has("hot")) parsed.searchParams.set("hot", "false");
+}
+function normalizeNativeDevBundleUrl(bundleUrl) {
+  try {
+    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
+    const parsed = new URL(bundleUrl, "http://sootsim.local");
+    parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
+    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
+    parsed.searchParams.delete("transform.bytecode");
+    if (parsed.searchParams.get("lazy") === "true") {
+      parsed.searchParams.set("lazy", "false");
+    }
+    applyPreviewProdBundle(parsed);
+    if (isAbsolute) return parsed.toString();
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return bundleUrl;
+  }
+}
+
+// src/dev-bundle-resolution.ts
+var DEFAULT_TEST_DRIVE_PORT = 8081;
+function buildUnresolvedTargetError(targetLabel) {
+  return new Error(
+    `could not resolve a native bundle for ${targetLabel}. pass an explicit bundle URL or open Connect and choose the app there.`
+  );
+}
+function inferManifestFramework(launchUrl, sdkVersion) {
+  if (launchUrl?.includes("/one/metro-entry.bundle")) return "one";
+  if (typeof sdkVersion === "string" && sdkVersion) return "expo";
+  return "unknown";
+}
+function buildBaseUrl(protocol, host, port) {
+  return `${protocol}//${host}:${port}`;
+}
+function shouldProxyLoopbackProbe(targetUrl) {
+  if (typeof window === "undefined") return false;
+  try {
+    const parsed = new URL(targetUrl);
+    return isLoopbackHost(parsed.hostname) && isLoopbackHost(window.location.hostname) && parsed.origin !== window.location.origin;
+  } catch {
+    return false;
+  }
+}
+async function fetchDevProbe(targetUrl, init) {
+  const requestInit = {
+    ...init,
+    cache: init?.cache ?? "no-store"
+  };
+  if (!shouldProxyLoopbackProbe(targetUrl)) {
+    return fetch(targetUrl, requestInit);
+  }
+  return fetch(`/__fetch-proxy?url=${encodeURIComponent(targetUrl)}`, requestInit);
+}
+function getDefaultPortForProtocol(protocol) {
+  return protocol === "https:" ? 443 : 80;
+}
+function isBaseServerUrl(url) {
+  const path = url.pathname || "/";
+  return (path === "/" || path === "") && !url.search && !url.hash;
+}
+async function resolvePortViaServerScan(port) {
+  try {
+    const res = await fetch("/__server-scan", { cache: "no-store" });
+    if (!res.ok) return null;
+    if (!(res.headers.get("content-type") || "").toLowerCase().includes("json"))
+      return null;
+    const servers = await res.json();
+    if (!Array.isArray(servers)) return null;
+    const match = servers.find(
+      (s) => !!s && typeof s === "object" && s.port === port && typeof s.bundleUrl === "string"
+    );
+    if (!match) return null;
+    return {
+      // normalize exactly like the manifest-probe branch below — the scan
+      // returns metro's raw launchAsset url (lazy=true for code-split one/vxrn
+      // apps), but sootsim loads ONE self-contained bundle into the tenant
+      // worker, so a deferred React.lazy chunk throws "Requiring unknown module
+      // <id>". normalizeNativeDevBundleUrl forces lazy=false + strips bytecode.
+      bundleUrl: normalizeNativeDevBundleUrl(match.bundleUrl),
+      port,
+      framework: typeof match.framework === "string" ? match.framework : "unknown",
+      projectName: typeof match.projectName === "string" ? match.projectName : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function probeBaseUrlBundle(baseUrl, port) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  try {
+    if (isLoopbackHost(new URL(normalizedBaseUrl).hostname)) {
+      const viaScan = await resolvePortViaServerScan(port);
+      if (viaScan) return viaScan;
+    }
+  } catch {
+  }
+  try {
+    const manifestRes = await fetchDevProbe(`${normalizedBaseUrl}/`, {
+      headers: { "expo-platform": "ios" }
+    });
+    if (manifestRes.ok) {
+      const manifest = await manifestRes.json();
+      const client = manifest?.extra?.expoClient || manifest?.extra || {};
+      const launchUrl = typeof manifest?.launchAsset?.url === "string" ? manifest.launchAsset.url : void 0;
+      if (launchUrl || client.name) {
+        return {
+          bundleUrl: normalizeNativeDevBundleUrl(
+            launchUrl || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`
+          ),
+          port,
+          framework: inferManifestFramework(launchUrl, client.sdkVersion),
+          projectName: client.name
+        };
+      }
+    }
+  } catch {
+  }
+  try {
+    const statusRes = await fetchDevProbe(`${normalizedBaseUrl}/status`);
+    if (statusRes.ok) {
+      const text = await statusRes.text();
+      if (text.includes("packager-status:running")) {
+        return {
+          bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+          port,
+          framework: "metro"
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function probePortBundle(port) {
+  return probeBaseUrlBundle(buildBaseUrl("http:", "localhost", port), port);
+}
+async function resolveConnectionInput(input) {
+  const trimmed = input.trim();
+  if (/^\d+$/.test(trimmed)) {
+    const port2 = parseInt(trimmed, 10);
+    const resolved = await probePortBundle(port2);
+    if (resolved) return resolved;
+    throw buildUnresolvedTargetError(`localhost:${port2}`);
+  }
+  const bundleUrl = trimmed.startsWith("http") ? trimmed : `http://${trimmed}`;
+  let parsed;
+  try {
+    parsed = new URL(bundleUrl);
+  } catch {
+    throw new Error(
+      `could not parse "${input}". pass a dev-server port, a dev-server base URL, or a full bundle URL.`
+    );
+  }
+  const protocol = parsed.protocol || "http:";
+  const port = parsed.port ? parseInt(parsed.port, 10) : getDefaultPortForProtocol(protocol);
+  const baseUrl = buildBaseUrl(protocol, parsed.hostname, port);
+  if (isBaseServerUrl(parsed)) {
+    const resolved = await probeBaseUrlBundle(baseUrl, port);
+    if (resolved) return resolved;
+    throw buildUnresolvedTargetError(baseUrl);
+  }
+  return { bundleUrl: parsed.toString(), port, framework: "unknown" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_TEST_DRIVE_PORT,
+  inferManifestFramework,
+  probePortBundle,
+  resolveConnectionInput
+});

package/dist-lib/home-paths.cjs

@@ -0,0 +1,421 @@
+/*! rnx v0.1.312 | (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,
+  CONFIG_FILE: () => CONFIG_FILE,
+  DAEMON_HEARTBEAT_STALE_MS: () => DAEMON_HEARTBEAT_STALE_MS,
+  DAEMON_LOCKFILE: () => DAEMON_LOCKFILE,
+  DEV_BRIDGE_LOCKFILE: () => DEV_BRIDGE_LOCKFILE,
+  SOOTSIM_HOME_ENV: () => SOOTSIM_HOME_ENV,
+  activeRuntimeDir: () => activeRuntimeDir,
+  activeRuntimeFile: () => activeRuntimeFile,
+  cacheDir: () => cacheDir,
+  claimDaemonLockfile: () => claimDaemonLockfile,
+  configFilePath: () => configFilePath,
+  consumeRuntimeUpgradeNotice: () => consumeRuntimeUpgradeNotice,
+  daemonAppBundlePath: () => daemonAppBundlePath,
+  daemonAppDir: () => daemonAppDir,
+  daemonAppLauncherPath: () => daemonAppLauncherPath,
+  daemonLockfilePath: () => daemonLockfilePath,
+  devBridgeLockfilePath: () => devBridgeLockfilePath,
+  electronDir: () => electronDir,
+  electronUserDataDir: () => electronUserDataDir,
+  electronVersionDir: () => electronVersionDir,
+  ensureSootsimHome: () => ensureSootsimHome,
+  isDaemonLockfileFresh: () => isDaemonLockfileFresh,
+  isDevBridgeLockfileFresh: () => isDevBridgeLockfileFresh,
+  isDevWorkstation: () => isDevWorkstation,
+  isSootsimDevCheckout: () => isSootsimDevCheckout,
+  profilesDir: () => profilesDir,
+  readActiveRuntime: () => readActiveRuntime,
+  readDaemonLockfile: () => readDaemonLockfile,
+  readDevBridgeLockfile: () => readDevBridgeLockfile,
+  readLiveRuntimeVersions: () => readLiveRuntimeVersions,
+  readOrCreateAnonymousId: () => readOrCreateAnonymousId,
+  readPrivacyPreferences: () => readPrivacyPreferences,
+  readSharedConfig: () => readSharedConfig,
+  removeDaemonLockfile: () => removeDaemonLockfile,
+  removeDevBridgeLockfile: () => removeDevBridgeLockfile,
+  runtimeDir: () => runtimeDir,
+  runtimeUpgradeNoticePath: () => runtimeUpgradeNoticePath,
+  runtimesDir: () => runtimesDir,
+  shouldSkipPersistentDaemon: () => shouldSkipPersistentDaemon,
+  sootsimHomeDir: () => sootsimHomeDir,
+  writeActiveRuntime: () => writeActiveRuntime,
+  writeDaemonLockfile: () => writeDaemonLockfile,
+  writeDevBridgeLockfile: () => writeDevBridgeLockfile,
+  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 SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.json";
+var DEV_BRIDGE_LOCKFILE = "dev-bridge.json";
+var CONFIG_FILE = "config.json";
+var DAEMON_HEARTBEAT_STALE_MS = 3e4;
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_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)(), ".sootsim");
+}
+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(sootsimHomeDir(), "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(sootsimHomeDir(), "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(sootsimHomeDir(), "profiles");
+}
+function daemonAppDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "daemon-app");
+}
+function daemonAppBundlePath() {
+  return import_node_path.default.join(daemonAppDir(), "SootSim Daemon.app");
+}
+function daemonAppLauncherPath() {
+  return import_node_path.default.join(daemonAppBundlePath(), "Contents", "MacOS", "sootsim-daemon");
+}
+function cacheDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "cache");
+}
+function daemonLockfilePath() {
+  return import_node_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+}
+function devBridgeLockfilePath() {
+  return import_node_path.default.join(sootsimHomeDir(), DEV_BRIDGE_LOCKFILE);
+}
+function configFilePath() {
+  return import_node_path.default.join(sootsimHomeDir(), CONFIG_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) {
+  ensureSootsimHome();
+  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;
+}
+function readPrivacyPreferences() {
+  const settings = readSharedConfig().settings;
+  const productAnalytics = settings?.productAnalytics;
+  const crashReports = settings?.crashReports;
+  return {
+    productAnalytics: typeof productAnalytics === "boolean" ? productAnalytics : true,
+    crashReports: typeof crashReports === "boolean" ? crashReports : true,
+    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 runtimeUpgradeNoticePath() {
+  return import_node_path.default.join(sootsimHomeDir(), "runtime-upgraded.json");
+}
+function writeRuntimeUpgradeNotice(notice) {
+  ensureSootsimHome();
+  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 ensureSootsimHome() {
+  import_node_fs.default.mkdirSync(sootsimHomeDir(), { 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;
+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 readDevBridgeLockfile() {
+  try {
+    const fd = import_node_fs.default.openSync(devBridgeLockfilePath(), "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 && 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;
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+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);
+  }
+  const devBridge = readDevBridgeLockfile();
+  if (isDevBridgeLockfileFresh(devBridge)) {
+    for (const version of devBridge.servedRuntimes ?? []) versions.add(version);
+  }
+  return [...versions].sort();
+}
+function writeDaemonLockfile(data) {
+  ensureSootsimHome();
+  const tmp = `${daemonLockfilePath()}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  import_node_fs.default.renameSync(tmp, daemonLockfilePath());
+}
+function writeDevBridgeLockfile(data) {
+  ensureSootsimHome();
+  const tmp = `${devBridgeLockfilePath()}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  import_node_fs.default.renameSync(tmp, devBridgeLockfilePath());
+}
+function claimDaemonLockfile(data) {
+  ensureSootsimHome();
+  const existing = readDaemonLockfile();
+  if (existing && isDaemonLockfileFresh(existing) && existing.pid !== data.pid) {
+    return false;
+  }
+  writeDaemonLockfile(data);
+  return true;
+}
+function removeDaemonLockfile() {
+  try {
+    import_node_fs.default.unlinkSync(daemonLockfilePath());
+  } catch {
+  }
+}
+function removeDevBridgeLockfile() {
+  try {
+    import_node_fs.default.unlinkSync(devBridgeLockfilePath());
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTIVE_RUNTIME_FILE,
+  CONFIG_FILE,
+  DAEMON_HEARTBEAT_STALE_MS,
+  DAEMON_LOCKFILE,
+  DEV_BRIDGE_LOCKFILE,
+  SOOTSIM_HOME_ENV,
+  activeRuntimeDir,
+  activeRuntimeFile,
+  cacheDir,
+  claimDaemonLockfile,
+  configFilePath,
+  consumeRuntimeUpgradeNotice,
+  daemonAppBundlePath,
+  daemonAppDir,
+  daemonAppLauncherPath,
+  daemonLockfilePath,
+  devBridgeLockfilePath,
+  electronDir,
+  electronUserDataDir,
+  electronVersionDir,
+  ensureSootsimHome,
+  isDaemonLockfileFresh,
+  isDevBridgeLockfileFresh,
+  isDevWorkstation,
+  isSootsimDevCheckout,
+  profilesDir,
+  readActiveRuntime,
+  readDaemonLockfile,
+  readDevBridgeLockfile,
+  readLiveRuntimeVersions,
+  readOrCreateAnonymousId,
+  readPrivacyPreferences,
+  readSharedConfig,
+  removeDaemonLockfile,
+  removeDevBridgeLockfile,
+  runtimeDir,
+  runtimeUpgradeNoticePath,
+  runtimesDir,
+  shouldSkipPersistentDaemon,
+  sootsimHomeDir,
+  writeActiveRuntime,
+  writeDaemonLockfile,
+  writeDevBridgeLockfile,
+  writePrivacyPreferences,
+  writeRuntimeUpgradeNotice,
+  writeSharedConfig
+});