sootsim 0.0.1 → 0.0.3

package/dist-lib/bridge-constants.cjs

@@ -0,0 +1,32 @@
+/*! sootsim v0.0.3 | (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/bridge-constants.ts
+var bridge_constants_exports = {};
+__export(bridge_constants_exports, {
+  DEFAULT_SOOTSIM_BRIDGE_PORT: () => DEFAULT_SOOTSIM_BRIDGE_PORT
+});
+module.exports = __toCommonJS(bridge_constants_exports);
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SOOTSIM_BRIDGE_PORT
+});

package/dist-lib/cli-constants.cjs

@@ -0,0 +1,32 @@
+/*! sootsim v0.0.3 | (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/cli-constants.ts
+var cli_constants_exports = {};
+__export(cli_constants_exports, {
+  DEFAULT_SOOTSIM_SHELL_URL: () => DEFAULT_SOOTSIM_SHELL_URL
+});
+module.exports = __toCommonJS(cli_constants_exports);
+var DEFAULT_SOOTSIM_SHELL_URL = "http://localhost:5173/";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SOOTSIM_SHELL_URL
+});

package/dist-lib/config.cjs

@@ -0,0 +1,88 @@
+/*! sootsim v0.0.3 | (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/config.ts
+var config_exports = {};
+__export(config_exports, {
+  SOOTSIM_CONFIG_QUERY_PARAM: () => SOOTSIM_CONFIG_QUERY_PARAM,
+  applySootSimConfigToUrl: () => applySootSimConfigToUrl,
+  defineConfig: () => defineConfig,
+  hasSootSimConfig: () => hasSootSimConfig,
+  mergeSootSimConfig: () => mergeSootSimConfig,
+  readSootSimConfigFromSearchParams: () => readSootSimConfigFromSearchParams
+});
+module.exports = __toCommonJS(config_exports);
+var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+function defineConfig(config) {
+  return config;
+}
+function hasOwnKeys(value) {
+  return !!value && Object.keys(value).length > 0;
+}
+function hasSootSimConfig(config) {
+  if (!config) return false;
+  return hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.env) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
+}
+function mergeSootSimConfig(base, override) {
+  if (!hasSootSimConfig(base) && !hasSootSimConfig(override)) return void 0;
+  if (!hasSootSimConfig(base)) return override ? { ...override } : void 0;
+  if (!hasSootSimConfig(override)) return base ? { ...base } : void 0;
+  return {
+    modules: { ...base.modules || {}, ...override.modules || {} },
+    turboModules: { ...base.turboModules || {}, ...override.turboModules || {} },
+    env: { ...base.env || {}, ...override.env || {} },
+    settings: {
+      ...base.settings || {},
+      ...override.settings || {}
+    },
+    initialState: { ...base.initialState || {}, ...override.initialState || {} }
+  };
+}
+function readSootSimConfigFromSearchParams(searchParams) {
+  const raw = searchParams.get(SOOTSIM_CONFIG_QUERY_PARAM);
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    return hasSootSimConfig(parsed) ? parsed : void 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[sootsim] invalid ${SOOTSIM_CONFIG_QUERY_PARAM}: ${message}`);
+    return void 0;
+  }
+}
+function applySootSimConfigToUrl(url, config) {
+  const parsed = new URL(url);
+  if (hasSootSimConfig(config)) {
+    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config));
+  } else {
+    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM);
+  }
+  return parsed.toString();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SOOTSIM_CONFIG_QUERY_PARAM,
+  applySootSimConfigToUrl,
+  defineConfig,
+  hasSootSimConfig,
+  mergeSootSimConfig,
+  readSootSimConfigFromSearchParams
+});

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

@@ -0,0 +1,236 @@
+/*! sootsim v0.0.3 | (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,
+  assumeDevBundleForPort: () => assumeDevBundleForPort,
+  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 ONE_BUNDLE_PATH = "/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false";
+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 normalizeNativeDevBundleUrl(bundleUrl) {
+  try {
+    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
+    const parsed = new URL(bundleUrl, "http://soot.local");
+    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
+    if (!parsed.searchParams.has("dev")) parsed.searchParams.set("dev", "true");
+    if (!parsed.searchParams.has("minify")) {
+      parsed.searchParams.set("minify", "false");
+    }
+    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 assumeDevBundleForPort(port, options = {}) {
+  const framework = options.framework ?? "one";
+  const host = options.host ?? "localhost";
+  const protocol = options.protocol ?? "http:";
+  const bundlePath = framework === "metro" ? METRO_BUNDLE_PATH : ONE_BUNDLE_PATH;
+  return {
+    bundleUrl: `${buildBaseUrl(protocol, host, port)}${bundlePath}`,
+    port,
+    framework
+  };
+}
+function getDefaultPortForProtocol(protocol) {
+  return protocol === "https:" ? 443 : 80;
+}
+function isBaseServerUrl(url) {
+  const path = url.pathname || "/";
+  return (path === "/" || path === "") && !url.search && !url.hash;
+}
+async function hasDirectOneBundle(baseUrl) {
+  try {
+    const oneRes = await fetchDevProbe(`${baseUrl}${ONE_BUNDLE_PATH}`, {
+      method: "HEAD"
+    });
+    return oneRes.ok;
+  } catch {
+    return false;
+  }
+}
+async function probeBaseUrlBundle(baseUrl, port) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  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) {
+        const framework = inferManifestFramework(launchUrl, client.sdkVersion);
+        const bundleUrl = framework === "one" && await hasDirectOneBundle(normalizedBaseUrl) ? `${normalizedBaseUrl}${ONE_BUNDLE_PATH}` : normalizeNativeDevBundleUrl(
+          launchUrl || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`
+        );
+        return {
+          bundleUrl,
+          port,
+          framework,
+          projectName: client.name
+        };
+      }
+    }
+  } catch {
+  }
+  try {
+    const oneRes = await fetchDevProbe(`${normalizedBaseUrl}${ONE_BUNDLE_PATH}`, {
+      method: "HEAD"
+    });
+    if (oneRes.ok) {
+      return {
+        bundleUrl: `${normalizedBaseUrl}${ONE_BUNDLE_PATH}`,
+        port,
+        framework: "one"
+      };
+    }
+  } catch {
+  }
+  try {
+    const metroBundleRes = await fetchDevProbe(
+      `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+      {
+        method: "HEAD"
+      }
+    );
+    if (metroBundleRes.ok) {
+      return {
+        bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+        port,
+        framework: "metro"
+      };
+    }
+  } 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 (isLoopbackHost(parsed.hostname) && 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,
+  assumeDevBundleForPort,
+  inferManifestFramework,
+  probePortBundle,
+  resolveConnectionInput
+});

package/dist-lib/home-paths.cjs

@@ -0,0 +1,234 @@
+/*! sootsim v0.0.3 | (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,
+  SOOTSIM_HOME_ENV: () => SOOTSIM_HOME_ENV,
+  activeRuntimeDir: () => activeRuntimeDir,
+  activeRuntimeFile: () => activeRuntimeFile,
+  cacheDir: () => cacheDir,
+  claimDaemonLockfile: () => claimDaemonLockfile,
+  compareSemver: () => compareSemver,
+  configFilePath: () => configFilePath,
+  daemonLockfilePath: () => daemonLockfilePath,
+  electronDir: () => electronDir,
+  electronVersionDir: () => electronVersionDir,
+  ensureSootsimHome: () => ensureSootsimHome,
+  isDaemonLockfileFresh: () => isDaemonLockfileFresh,
+  listInstalledRuntimes: () => listInstalledRuntimes,
+  readActiveRuntime: () => readActiveRuntime,
+  readDaemonLockfile: () => readDaemonLockfile,
+  removeDaemonLockfile: () => removeDaemonLockfile,
+  runtimeDir: () => runtimeDir,
+  runtimesDir: () => runtimesDir,
+  sootsimHomeDir: () => sootsimHomeDir,
+  writeActiveRuntime: () => writeActiveRuntime,
+  writeDaemonLockfile: () => writeDaemonLockfile
+});
+module.exports = __toCommonJS(home_paths_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_os = require("os");
+var import_path = __toESM(require("path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.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_path.default.resolve(override);
+  return import_path.default.join((0, import_os.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_path.default.join(sootsimHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function electronDir() {
+  return import_path.default.join(sootsimHomeDir(), "electron");
+}
+function electronVersionDir(version) {
+  return import_path.default.join(electronDir(), version);
+}
+function cacheDir() {
+  return import_path.default.join(sootsimHomeDir(), "cache");
+}
+function daemonLockfilePath() {
+  return import_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+}
+function configFilePath() {
+  return import_path.default.join(sootsimHomeDir(), CONFIG_FILE);
+}
+function ensureSootsimHome() {
+  import_fs.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_fs.default.mkdirSync(cacheDir(), { recursive: true });
+}
+function readActiveRuntime() {
+  try {
+    const value = import_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeActiveRuntime(version) {
+  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_fs.default.writeFileSync(activeRuntimeFile(), `${version}
+`, "utf8");
+}
+function listInstalledRuntimes() {
+  try {
+    return import_fs.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+  } catch {
+    return [];
+  }
+}
+function compareSemver(a, b) {
+  const parse = (v) => {
+    const hyphen = v.indexOf("-");
+    const core = hyphen >= 0 ? v.slice(0, hyphen) : v;
+    const pre = hyphen >= 0 ? v.slice(hyphen + 1) : "";
+    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
+    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v];
+    return [parts, pre];
+  };
+  const [an, ap] = parse(a);
+  const [bn, bp] = parse(b);
+  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
+    const av = an[i] ?? 0;
+    const bv = bn[i] ?? 0;
+    if (av !== bv) return av - bv;
+  }
+  if (ap === bp) return 0;
+  if (!ap) return 1;
+  if (!bp) return -1;
+  return ap < bp ? -1 : 1;
+}
+function activeRuntimeDir() {
+  const version = readActiveRuntime();
+  if (!version) return null;
+  const dir = runtimeDir(version);
+  try {
+    if (import_fs.default.statSync(dir).isDirectory()) return dir;
+  } catch {
+  }
+  return null;
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+function readDaemonLockfile() {
+  try {
+    const fd = import_fs.default.openSync(daemonLockfilePath(), "r");
+    try {
+      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+      const bytesRead = import_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") {
+        return parsed;
+      }
+      return null;
+    } finally {
+      import_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 writeDaemonLockfile(data) {
+  ensureSootsimHome();
+  const tmp = `${daemonLockfilePath()}.tmp`;
+  import_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  import_fs.default.renameSync(tmp, daemonLockfilePath());
+}
+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_fs.default.unlinkSync(daemonLockfilePath());
+  } 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,
+  SOOTSIM_HOME_ENV,
+  activeRuntimeDir,
+  activeRuntimeFile,
+  cacheDir,
+  claimDaemonLockfile,
+  compareSemver,
+  configFilePath,
+  daemonLockfilePath,
+  electronDir,
+  electronVersionDir,
+  ensureSootsimHome,
+  isDaemonLockfileFresh,
+  listInstalledRuntimes,
+  readActiveRuntime,
+  readDaemonLockfile,
+  removeDaemonLockfile,
+  runtimeDir,
+  runtimesDir,
+  sootsimHomeDir,
+  writeActiveRuntime,
+  writeDaemonLockfile
+});