rnxsim 0.1.344 → 0.1.346

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (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;
@@ -9476,6 +9476,27 @@ var init_bridge_constants = __esm({
   }
 });
 
+// src/backend-origin.ts
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function buildLoopbackProbeBaseUrl(protocol, hostname, port) {
+  const normalizedHostname = normalizeHostname(hostname);
+  const urlHost = normalizedHostname.includes(":") ? `[${normalizedHostname}]` : normalizedHostname;
+  return `${protocol}//${urlHost}:${port}`;
+}
+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);
+}
+var LOOPBACK_PROBE_HOSTNAMES;
+var init_backend_origin = __esm({
+  "src/backend-origin.ts"() {
+    "use strict";
+    LOOPBACK_PROBE_HOSTNAMES = ["::1", "127.0.0.1"];
+  }
+});
+
 // src/config.ts
 function hasOwnKeys(value) {
   return !!value && Object.keys(value).length > 0;
@@ -9531,6 +9552,19 @@ function isAbsoluteHttpUrl(url) {
 function isNativeDevBundlePath(pathname) {
   return pathname.endsWith(".bundle");
 }
+function alignLoopbackBundleUrlWithProbe(bundleUrl, probeBaseUrl) {
+  try {
+    const bundle = new URL(bundleUrl);
+    const probe3 = new URL(probeBaseUrl);
+    if (!isLoopbackHost(bundle.hostname) || !isLoopbackHost(probe3.hostname)) {
+      return bundleUrl;
+    }
+    bundle.hostname = probe3.hostname;
+    return bundle.toString();
+  } catch {
+    return bundleUrl;
+  }
+}
 function applyPreviewProdBundle(parsed) {
   if (!process.env.SOOTSIM_PREVIEW_PROD_BUNDLE) return;
   parsed.searchParams.set("dev", "false");
@@ -9570,6 +9604,7 @@ var METRO_BUNDLE_PATH;
 var init_native_dev_bundle_url = __esm({
   "src/native-dev-bundle-url.ts"() {
     "use strict";
+    init_backend_origin();
     METRO_BUNDLE_PATH = "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
   }
 });
@@ -9678,9 +9713,9 @@ function safeChildPlistName(value) {
     name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
   };
 }
-async function readableSettingsBundle(path19) {
+async function readableSettingsBundle(path18) {
   try {
-    const root = await (0, import_promises.stat)((0, import_node_path.join)(path19, "Root.plist"));
+    const root = await (0, import_promises.stat)((0, import_node_path.join)(path18, "Root.plist"));
     return root.isFile() && root.size <= MAX_PLIST_BYTES;
   } catch {
     return false;
@@ -9725,11 +9760,11 @@ async function settingsBundleFingerprint(bundlePath) {
     return null;
   }
 }
-async function parsePlistRecord(path19) {
+async function parsePlistRecord(path18) {
   try {
-    const metadata = await (0, import_promises.stat)(path19);
+    const metadata = await (0, import_promises.stat)(path18);
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
-    const source = await (0, import_promises.readFile)(path19, "utf8");
+    const source = await (0, import_promises.readFile)(path18, "utf8");
     const parsed = parsePlistSource(source);
     return isRecord2(parsed) ? parsed : null;
   } catch {
@@ -9991,27 +10026,36 @@ var init_optional_demo_registry = __esm({
 });
 
 // scripts/dev-server-scanner.ts
-function tcpPing(port, timeout = TCP_GATE_MS) {
-  return new Promise((resolve7) => {
-    const sock = new import_net.default.Socket();
-    let settled = false;
-    const done = (ok) => {
-      if (settled) return;
-      settled = true;
-      sock.destroy();
-      resolve7(ok);
-    };
-    sock.setTimeout(timeout);
-    sock.once("connect", () => done(true));
-    sock.once("timeout", () => done(false));
-    sock.once("error", () => done(false));
-    sock.connect(port, "localhost");
-  });
+async function tcpPing(port, timeout = TCP_GATE_MS) {
+  try {
+    return await Promise.any(
+      LOOPBACK_PROBE_HOSTNAMES.map(
+        (hostname) => new Promise((resolve7, reject) => {
+          const sock = new import_net.default.Socket();
+          let settled = false;
+          const done = (reachable) => {
+            if (settled) return;
+            settled = true;
+            sock.destroy();
+            if (reachable) resolve7(hostname);
+            else reject(new Error(`unreachable loopback host ${hostname}`));
+          };
+          sock.setTimeout(timeout);
+          sock.once("connect", () => done(true));
+          sock.once("timeout", () => done(false));
+          sock.once("error", () => done(false));
+          sock.connect(port, hostname);
+        })
+      )
+    );
+  } catch {
+    return null;
+  }
 }
-function httpGet(port, path19, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(hostname, port, path18, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve7) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path19, method, timeout, headers },
+      { hostname, port, path: path18, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -10023,7 +10067,12 @@ function httpGet(port, path19, method = "GET", timeout = TIMEOUT_MS, headers = {
         })();
         res.on(
           "end",
-          () => resolve7({ statusCode: res.statusCode || 0, body, contentType })
+          () => resolve7({
+            statusCode: res.statusCode || 0,
+            body,
+            contentType,
+            hostname
+          })
         );
       }
     );
@@ -10163,16 +10212,16 @@ async function resolveProcessCwd(pid) {
   }
   return null;
 }
-function makeResult(port, framework, owner) {
+function makeResult(hostname, port, framework, owner) {
   return {
     port,
     framework,
     bundleUrl: withRuntimeConfig(
       port,
-      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
+      `${buildLoopbackProbeBaseUrl("http:", hostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
       owner.cwd
     ),
-    hmrUrl: `ws://localhost:${port}/hot`,
+    hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", hostname, port)}/hot`,
     lastSeen: Date.now(),
     ...owner
   };
@@ -10203,7 +10252,11 @@ function applyManifest(result, manifestRes, buildIconProxyUrl) {
     if (client.name) result.projectName = client.name;
     if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
     if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
-    const launchUrl2 = manifest?.launchAsset?.url;
+    const rawLaunchUrl = manifest?.launchAsset?.url;
+    const launchUrl2 = typeof rawLaunchUrl === "string" ? alignLoopbackBundleUrlWithProbe(
+      rawLaunchUrl,
+      buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)
+    ) : rawLaunchUrl;
     if (launchUrl2 && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
       result.bundleUrl = withRuntimeConfig(result.port, launchUrl2, result.cwd);
     }
@@ -10216,11 +10269,11 @@ function applyManifest(result, manifestRes, buildIconProxyUrl) {
         } else {
           const cleanPath = rawIconUrl.replace(/^\.\//, "");
           result.iconUrl = buildIconProxyUrl(
-            `http://localhost:${result.port}/assets/${cleanPath}`
+            `${buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)}/assets/${cleanPath}`
           );
         }
       } else {
-        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
+        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `${buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
       }
     }
   } catch {
@@ -10241,35 +10294,48 @@ function enrichWithManifest(result, buildIconProxyUrl) {
   }
   if (!enrichmentInFlight.has(result.port)) {
     enrichmentInFlight.add(result.port);
-    const port = result.port;
-    void fetchManifestEnrichment(port, buildIconProxyUrl).finally(
-      () => enrichmentInFlight.delete(port)
+    void fetchManifestEnrichment(result, buildIconProxyUrl).finally(
+      () => enrichmentInFlight.delete(result.port)
     );
   }
   return result;
 }
-async function fetchManifestEnrichment(port, buildIconProxyUrl) {
-  const manifestRes = await httpGet(port, "/", "GET", ENRICH_TIMEOUT_MS, {
-    "expo-platform": "ios"
-  });
+async function fetchManifestEnrichment(result, buildIconProxyUrl) {
+  const hostname = normalizeHostname(new URL(result.bundleUrl).hostname);
+  const manifestRes = await httpGet(
+    hostname,
+    result.port,
+    "/",
+    "GET",
+    ENRICH_TIMEOUT_MS,
+    {
+      "expo-platform": "ios"
+    }
+  );
   if (!manifestRes || manifestRes.statusCode !== 200) return;
   const parsed = applyManifest(
-    { port, framework: "one", bundleUrl: "", lastSeen: 0 },
+    {
+      port: result.port,
+      framework: "one",
+      bundleUrl: `${buildLoopbackProbeBaseUrl("http:", hostname, result.port)}/index.bundle`,
+      lastSeen: 0
+    },
     manifestRes,
     buildIconProxyUrl
   );
   if (!parsed.projectName && !parsed.iconUrl) return;
-  enrichmentCache.set(port, {
+  enrichmentCache.set(result.port, {
     projectName: parsed.projectName,
     iconUrl: parsed.iconUrl,
     iconPath: parsed.iconPath,
     bundleId: parsed.bundleId
   });
-  portCache.delete(port);
+  portCache.delete(result.port);
 }
 async function probePort(port, buildIconProxyUrl, listeningProcess) {
   await loadOptionalDemoApps();
-  if (!await tcpPing(port)) return null;
+  const probeHostname = await tcpPing(port);
+  if (!probeHostname) return null;
   const suppliedPid = listeningProcess?.pid;
   const ownerPid = suppliedPid && suppliedPid > 0 ? suppliedPid : await resolveListeningPid(port);
   const ownerCwd = ownerPid ? await resolveProcessCwd(ownerPid) : null;
@@ -10279,10 +10345,12 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   };
   const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
   const [sootsimRes, statusRes, manifestRes, expoRes] = await Promise.all([
-    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, "/__soot/"),
-    httpGet(port, "/status"),
-    knownOne.has(port) ? Promise.resolve(null) : httpGet(port, "/", "GET", MANIFEST_TIMEOUT_MS, { "expo-platform": "ios" }),
-    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, "/_expo/status")
+    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/__soot/"),
+    httpGet(probeHostname, port, "/status"),
+    knownOne.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/", "GET", MANIFEST_TIMEOUT_MS, {
+      "expo-platform": "ios"
+    }),
+    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/_expo/status")
   ]);
   if (expoRes && expoRes.statusCode === 200) {
     knownNonExpo.delete(port);
@@ -10294,7 +10362,7 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   const manifestClient = manifestParsed?.extra?.expoClient || manifestParsed?.extra || {};
   if (manifestParsed && (manifestLaunchUrl || typeof manifestClient.name === "string")) {
     knownNonPatched.add(port);
-    const launchUrl2 = manifestLaunchUrl || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
+    const launchUrl2 = manifestLaunchUrl || `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
     const framework = launchUrl2.includes(
       "/one/metro-entry.bundle"
     ) ? "one" : "expo";
@@ -10303,7 +10371,7 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
         port,
         framework,
         bundleUrl: withRuntimeConfig(port, launchUrl2, owner.cwd),
-        hmrUrl: `ws://localhost:${port}/hot`,
+        hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
         lastSeen: Date.now(),
         ...owner
       },
@@ -10315,7 +10383,12 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
     knownNonPatched.add(port);
     return enrichWithManifest(
       applyManifest(
-        makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro", owner),
+        makeResult(
+          probeHostname,
+          port,
+          expoRes && expoRes.statusCode === 200 ? "expo" : "metro",
+          owner
+        ),
         manifestRes,
         buildIconProxyUrl
       ),
@@ -10331,10 +10404,10 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
           framework: "one",
           bundleUrl: withRuntimeConfig(
             port,
-            `http://localhost:${port}/__soot/bundle.js`,
+            `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}/__soot/bundle.js`,
             owner.cwd
           ),
-          hmrUrl: `ws://localhost:${port}/hot`,
+          hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
           lastSeen: Date.now(),
           patched: true,
           ...owner
@@ -10349,7 +10422,7 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   if (looksLikeMetroPackager) {
     return null;
   }
-  const oneRes = await httpGet(port, onePath, "HEAD");
+  const oneRes = await httpGet(probeHostname, port, onePath, "HEAD");
   if (oneRes && oneRes.statusCode > 0 && oneRes.statusCode < 400 && /application\/javascript/i.test(oneRes.contentType || "")) {
     knownNonPatched.add(port);
     knownOne.add(port);
@@ -10360,10 +10433,10 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
           framework: "one",
           bundleUrl: withRuntimeConfig(
             port,
-            `http://localhost:${port}${onePath}&minify=false`,
+            `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}${onePath}&minify=false`,
             owner.cwd
           ),
-          hmrUrl: `ws://localhost:${port}/hot`,
+          hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
           lastSeen: Date.now(),
           ...owner
         },
@@ -10485,6 +10558,7 @@ var init_dev_server_scanner = __esm({
     import_net = __toESM(require("net"), 1);
     import_node_path3 = require("node:path");
     import_util = require("util");
+    init_backend_origin();
     init_config();
     init_native_dev_bundle_url();
     init_settings_bundle();
@@ -10724,8 +10798,8 @@ function readPrivacyPreferences() {
   const productAnalytics = settings?.productAnalytics;
   const crashReports = settings?.crashReports;
   return {
-    productAnalytics: typeof productAnalytics === "boolean" ? productAnalytics : true,
-    crashReports: typeof crashReports === "boolean" ? crashReports : true,
+    productAnalytics: typeof productAnalytics === "boolean" ? productAnalytics : false,
+    crashReports: typeof crashReports === "boolean" ? crashReports : false,
     configured: typeof productAnalytics === "boolean" && typeof crashReports === "boolean"
   };
 }
@@ -10894,10 +10968,30 @@ function readLiveRuntimeVersions() {
 }
 function writeDaemonLockfile(data) {
   ensureSootsimHome();
-  const tmp = `${daemonLockfilePath()}.tmp`;
+  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_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, daemonLockfilePath());
+  try {
+    const current = readDaemonLockfile();
+    if (!current || !sameDaemonOwner(current, data)) {
+      throw new Error("rnx daemon lock ownership changed during heartbeat");
+    }
+    import_node_fs3.default.renameSync(tmp, lockfilePath);
+  } finally {
+    try {
+      import_node_fs3.default.unlinkSync(tmp);
+    } catch {
+    }
+  }
 }
 function writeDevBridgeLockfile(data) {
   import_node_fs3.default.mkdirSync(devBridgesDir(), { recursive: true });
@@ -10907,17 +11001,130 @@ function writeDevBridgeLockfile(data) {
 `, "utf8");
   import_node_fs3.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_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  try {
+    import_node_fs3.default.linkSync(tmp, lockfilePath);
+    return true;
+  } catch (error) {
+    if (isAlreadyExists(error)) return false;
+    throw error;
+  } finally {
+    try {
+      import_node_fs3.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_fs3.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_fs3.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_fs3.default.readFileSync(daemonClaimPath(), "utf8");
+      const latest = parseDaemonClaim(before);
+      if (latest && isDaemonClaimFresh(latest)) return false;
+      if (import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs3.default.unlinkSync(daemonClaimPath());
+    } catch {
+    }
+  }
+  return false;
+}
+function releaseDaemonClaim(owner) {
+  try {
+    const claim = readDaemonClaim();
+    if (!claim || !sameDaemonOwner(claim, owner)) return;
+    import_node_fs3.default.unlinkSync(daemonClaimPath());
+  } catch {
+  }
+}
 function claimDaemonLockfile(data) {
   ensureSootsimHome();
-  const existing = readDaemonLockfile();
-  if (existing && isDaemonLockfileFresh(existing) && existing.pid !== data.pid) {
-    return false;
+  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_fs3.default.unlinkSync(daemonLockfilePath());
+      } catch {
+        return false;
+      }
+    }
+    return createDaemonLockfileExclusive(data);
+  } finally {
+    releaseDaemonClaim(data);
   }
-  writeDaemonLockfile(data);
-  return true;
 }
-function removeDaemonLockfile() {
+function removeDaemonLockfile(owner) {
   try {
+    const lockfile = readDaemonLockfile();
+    if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
     import_node_fs3.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
@@ -10931,7 +11138,7 @@ function removeDevBridgeLockfile(owner) {
   } catch {
   }
 }
-var import_node_crypto, import_node_fs3, import_node_os, import_node_path4, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES;
+var import_node_crypto, import_node_fs3, import_node_os, import_node_path4, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
 var init_home_paths = __esm({
   "src/home-paths.ts"() {
     "use strict";
@@ -10946,6 +11153,7 @@ var init_home_paths = __esm({
     CONFIG_FILE = "config.json";
     DAEMON_HEARTBEAT_STALE_MS = 3e4;
     DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+    DAEMON_CLAIM_STALE_MS = 3e4;
   }
 });
 
@@ -12870,20 +13078,6 @@ var init_agent_host = __esm({
   }
 });
 
-// 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);
-}
-var init_backend_origin = __esm({
-  "src/backend-origin.ts"() {
-    "use strict";
-  }
-});
-
 // src/host/fetch-proxy-overrides.ts
 function headerOverridesFor(hostname) {
   const host = hostname.toLowerCase();
@@ -13367,9 +13561,18 @@ export const Appearance = rn.Appearance
 `;
 }
 function sendJavaScript(req, res, source) {
+  const origin = req.headers.origin;
+  let allowedOrigin;
+  if (origin) {
+    try {
+      if (isLoopbackHost(new URL(origin).hostname)) allowedOrigin = origin;
+    } catch {
+    }
+  }
   res.writeHead(200, {
     "Content-Type": "application/javascript; charset=utf-8",
-    "Cache-Control": "no-cache"
+    "Cache-Control": "no-cache",
+    ...allowedOrigin ? { "Access-Control-Allow-Origin": allowedOrigin, Vary: "Origin" } : {}
   });
   res.end(req.method === "HEAD" ? void 0 : source);
 }
@@ -13390,6 +13593,23 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   } catch {
     return false;
   }
+  if (options.requireLoopbackOrigin) {
+    const origin = req.headers.origin;
+    const remoteAddress = req.socket.remoteAddress?.replace(/^::ffff:/, "");
+    let allowed = Boolean(remoteAddress && isLoopbackHost(remoteAddress));
+    if (allowed && origin) {
+      try {
+        allowed = isLoopbackHost(new URL(origin).hostname);
+      } catch {
+        allowed = false;
+      }
+    }
+    if (!allowed) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement modules are available only to loopback origins");
+      return true;
+    }
+  }
   if (url.pathname === `${REPLACEMENT_RUNTIME_PREFIX}/react`) {
     sendJavaScript(req, res, reactRuntimeSource(options.reactBridgeUrl));
     return true;
@@ -13399,6 +13619,11 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (url.pathname !== REPLACEMENT_MODULE_ROUTE) return false;
+  if (options.requestToken && url.searchParams.get("token") !== options.requestToken) {
+    res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement module request token is invalid");
+    return true;
+  }
   const targetPath = url.searchParams.get("path");
   if (!targetPath) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
@@ -13411,17 +13636,42 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("replacement files must be .js, .jsx, .ts, or .tsx");
     return true;
   }
+  if (!import_node_path10.default.isAbsolute(targetPath)) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement file path must be absolute");
+    return true;
+  }
+  let resolvedProjectRoot;
+  if (options.projectRoot) {
+    const lexicalProjectRoot = import_node_path10.default.resolve(options.projectRoot);
+    resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
+    const lexicalTarget = import_node_path10.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path10.default.isAbsolute(lexicalTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
+  let resolvedTargetPath;
   try {
-    await import_promises5.default.access(targetPath);
+    resolvedTargetPath = await import_promises5.default.realpath(targetPath);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
     res.end(`replacement file not found: ${message}`);
     return true;
   }
+  if (resolvedProjectRoot) {
+    const relativeTarget = import_node_path10.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path10.default.isAbsolute(relativeTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
   try {
     const result = await (0, import_esbuild.build)({
-      entryPoints: [targetPath],
+      entryPoints: [resolvedTargetPath],
       bundle: true,
       write: false,
       format: "esm",
@@ -13460,6 +13710,7 @@ var init_replacement_module_handler = __esm({
     import_promises5 = __toESM(require("node:fs/promises"), 1);
     import_node_path10 = __toESM(require("node:path"), 1);
     import_esbuild = require("esbuild");
+    init_backend_origin();
     REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
     REPLACEMENT_RUNTIME_PREFIX = "/__sootsim-replacement-runtime";
   }
@@ -14726,7 +14977,7 @@ var init_bridge_host = __esm({
       removeLockfile() {
         if (!this.shouldWriteLockfile) return;
         try {
-          removeDaemonLockfile();
+          removeDaemonLockfile({ pid: process.pid, startedAt: this.startedAt });
         } catch {
         }
       }
@@ -15285,7 +15536,7 @@ var init_bridge_host = __esm({
         }
         if (this.shouldWriteLockfile) {
           try {
-            removeDaemonLockfile();
+            removeDaemonLockfile({ pid: process.pid, startedAt: this.startedAt });
           } catch {
           }
         }
@@ -16487,11 +16738,11 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path19, ...args) {
-  return bridge.send({ type: "call", path: path19, args });
+async function callInBridge(bridge, path18, ...args) {
+  return bridge.send({ type: "call", path: path18, args });
 }
-async function callInBridgeWrite(bridge, path19, ...args) {
-  return bridge.send({ type: "call", path: path19, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path18, ...args) {
+  return bridge.send({ type: "call", path: path18, args, acquireLock: true });
 }
 var import_node_fs9, import_node_path11, import_ws3, resolvedWorld, BridgeSimLockedError;
 var init_ws_bridge = __esm({
@@ -16553,8 +16804,8 @@ function getDefaultPortForProtocol(protocol) {
   return protocol === "https:" ? 443 : 80;
 }
 function isBaseServerUrl(url) {
-  const path19 = url.pathname || "/";
-  return (path19 === "/" || path19 === "") && !url.search && !url.hash;
+  const path18 = url.pathname || "/";
+  return (path18 === "/" || path18 === "") && !url.search && !url.hash;
 }
 async function resolvePortViaServerScan(port) {
   try {
@@ -16570,8 +16821,8 @@ async function resolvePortViaServerScan(port) {
     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
+      // returns metro's manifest 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),
@@ -16583,15 +16834,8 @@ async function resolvePortViaServerScan(port) {
     return null;
   }
 }
-async function probeBaseUrlBundle(baseUrl, port) {
+async function probeBaseUrlBundleDirect(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" }
@@ -16599,7 +16843,8 @@ async function probeBaseUrlBundle(baseUrl, port) {
     if (manifestRes.ok) {
       const manifest = await manifestRes.json();
       const client = manifest?.extra?.expoClient || manifest?.extra || {};
-      const launchUrl2 = typeof manifest?.launchAsset?.url === "string" ? manifest.launchAsset.url : void 0;
+      const rawLaunchUrl = typeof manifest?.launchAsset?.url === "string" ? manifest.launchAsset.url : void 0;
+      const launchUrl2 = rawLaunchUrl ? alignLoopbackBundleUrlWithProbe(rawLaunchUrl, normalizedBaseUrl) : void 0;
       if (launchUrl2 || client.name) {
         return {
           bundleUrl: normalizeNativeDevBundleUrl(
@@ -16629,8 +16874,25 @@ async function probeBaseUrlBundle(baseUrl, port) {
   }
   return null;
 }
+async function probeBaseUrlBundle(baseUrl, port) {
+  try {
+    if (isLoopbackHost(new URL(baseUrl).hostname)) {
+      const viaScan = await resolvePortViaServerScan(port);
+      if (viaScan) return viaScan;
+    }
+  } catch {
+  }
+  return probeBaseUrlBundleDirect(baseUrl, port);
+}
 async function probePortBundle(port) {
-  return probeBaseUrlBundle(buildBaseUrl("http:", "localhost", port), port);
+  const viaScan = await resolvePortViaServerScan(port);
+  if (viaScan) return viaScan;
+  const candidates = await Promise.all(
+    LOOPBACK_PROBE_HOSTNAMES.map(
+      (hostname) => probeBaseUrlBundleDirect(buildLoopbackProbeBaseUrl("http:", hostname, port), port)
+    )
+  );
+  return candidates.find((candidate) => candidate !== null) ?? null;
 }
 async function resolveConnectionInput(input) {
   const trimmed = input.trim();
@@ -16788,150 +17050,20 @@ function findExpoAppConfig(dir) {
 function findSootSimAppConfig(dir) {
   return firstNamedFile(dir, SOOTSIM_APP_CONFIG_NAMES);
 }
-function readWorkspacePatterns(rootDir) {
+function resolveAppProject(projectRoot) {
+  const appDir = import_node_path12.default.resolve(projectRoot);
   try {
-    const value = JSON.parse(import_node_fs10.default.readFileSync(import_node_path12.default.join(rootDir, "package.json"), "utf8"));
-    if (!value || typeof value !== "object") return [];
-    const workspaces = Reflect.get(value, "workspaces");
-    if (Array.isArray(workspaces)) {
-      return workspaces.filter((entry) => typeof entry === "string");
-    }
-    if (!workspaces || typeof workspaces !== "object") return [];
-    const packages = Reflect.get(workspaces, "packages");
-    return Array.isArray(packages) ? packages.filter((entry) => typeof entry === "string") : [];
+    if (!import_node_fs10.default.statSync(appDir).isDirectory()) return null;
   } catch {
-    return [];
-  }
-}
-function workspaceDirectories(rootDir) {
-  const directories = /* @__PURE__ */ new Set();
-  let expanded = 0;
-  let complete = true;
-  for (const pattern of readWorkspacePatterns(rootDir)) {
-    if (expanded >= MAX_SCANNED_DIRECTORIES) {
-      complete = false;
-      break;
-    }
-    if (!pattern || import_node_path12.default.isAbsolute(pattern)) continue;
-    const segments = pattern.split(/[\\/]+/).filter(Boolean);
-    if (segments.length === 0 || segments.length > MAX_SCAN_DEPTH) continue;
-    if (segments.some((segment) => segment === ".." || segment === "**")) continue;
-    let current = [rootDir];
-    for (const segment of segments) {
-      const next = [];
-      for (const parent of current) {
-        if (expanded >= MAX_SCANNED_DIRECTORIES) {
-          complete = false;
-          break;
-        }
-        expanded++;
-        if (segment === "*") {
-          let entries;
-          try {
-            entries = import_node_fs10.default.readdirSync(parent, { withFileTypes: true });
-          } catch {
-            continue;
-          }
-          for (const entry of entries) {
-            if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-            if (entry.name.startsWith(".") || SKIP_DIR_NAMES.has(entry.name)) continue;
-            next.push(import_node_path12.default.join(parent, entry.name));
-          }
-        } else if (!segment.includes("*")) {
-          const candidate = import_node_path12.default.join(parent, segment);
-          try {
-            const stat2 = import_node_fs10.default.lstatSync(candidate);
-            if (stat2.isDirectory() && !stat2.isSymbolicLink()) next.push(candidate);
-          } catch {
-          }
-        }
-      }
-      current = next;
-      if (current.length > MAX_SCANNED_DIRECTORIES) {
-        current.length = MAX_SCANNED_DIRECTORIES;
-        complete = false;
-      }
-    }
-    for (const directory of current) directories.add(directory);
-  }
-  return { directories: [...directories], complete };
-}
-function boundedConfigDirectories(rootDir) {
-  const queue = [{ dir: rootDir, depth: 0 }];
-  const matches = [];
-  let visited = 0;
-  let nextIndex = 0;
-  let complete = true;
-  while (nextIndex < queue.length && visited < MAX_SCANNED_DIRECTORIES) {
-    const current = queue[nextIndex++];
-    if (!current) break;
-    visited++;
-    if (current.depth > 0 && findExpoAppConfig(current.dir)) {
-      matches.push(current.dir);
-      if (matches.length > 1) return { directories: matches, complete: true };
-    }
-    if (current.depth >= MAX_SCAN_DEPTH) continue;
-    let entries;
-    try {
-      entries = import_node_fs10.default.readdirSync(current.dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-      if (entry.name.startsWith(".") || SKIP_DIR_NAMES.has(entry.name)) continue;
-      if (queue.length >= MAX_SCANNED_DIRECTORIES) {
-        complete = false;
-        break;
-      }
-      queue.push({ dir: import_node_path12.default.join(current.dir, entry.name), depth: current.depth + 1 });
-    }
-  }
-  return { directories: matches, complete: complete && nextIndex === queue.length };
-}
-function resolveAppProject(startDir, opts = {}) {
-  const rootDir = import_node_path12.default.resolve(startDir);
-  const rootConfigPath = findSootSimAppConfig(rootDir);
-  if (findExpoAppConfig(rootDir) || opts.trustStart && import_node_fs10.default.existsSync(rootDir)) {
-    let configPath = rootConfigPath;
-    if (!configPath && opts.trustStart) {
-      let parent = import_node_path12.default.dirname(rootDir);
-      for (let depth = 0; depth < MAX_SCAN_DEPTH && parent !== import_node_path12.default.dirname(parent); depth++) {
-        configPath = findSootSimAppConfig(parent);
-        if (configPath) break;
-        parent = import_node_path12.default.dirname(parent);
-      }
-    }
-    return { appDir: rootDir, configPath };
-  }
-  const workspaceScan = workspaceDirectories(rootDir);
-  const workspaceApps = workspaceScan.directories.filter(
-    (directory) => findExpoAppConfig(directory)
-  );
-  if (workspaceApps.length > 1) return null;
-  if (!workspaceScan.complete) return null;
-  if (workspaceApps.length === 1) {
-    const workspaceAppDir = workspaceApps[0];
-    return {
-      appDir: workspaceAppDir,
-      configPath: rootConfigPath ?? findSootSimAppConfig(workspaceAppDir)
-    };
+    return null;
   }
-  const fallbackScan = boundedConfigDirectories(rootDir);
-  const scannedApps = fallbackScan.directories;
-  if (scannedApps.length > 1) return null;
-  if (!fallbackScan.complete) return null;
-  if (scannedApps.length === 1) {
-    const scannedAppDir = scannedApps[0];
-    return {
-      appDir: scannedAppDir,
-      configPath: rootConfigPath ?? findSootSimAppConfig(scannedAppDir)
-    };
+  const configPath = findSootSimAppConfig(appDir);
+  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs10.default.existsSync(import_node_path12.default.join(appDir, "package.json"))) {
+    return null;
   }
-  if (rootConfigPath) return { appDir: rootDir, configPath: rootConfigPath };
-  return null;
+  return { appDir, configPath };
 }
-var import_node_fs10, import_node_path12, EXPO_APP_CONFIG_NAMES, SOOTSIM_APP_CONFIG_NAMES, SKIP_DIR_NAMES, MAX_SCANNED_DIRECTORIES, MAX_SCAN_DEPTH;
+var import_node_fs10, import_node_path12, EXPO_APP_CONFIG_NAMES, SOOTSIM_APP_CONFIG_NAMES;
 var init_app_project = __esm({
   "cli/app-project.ts"() {
     "use strict";
@@ -16950,28 +17082,6 @@ var init_app_project = __esm({
       "sootsim.config.mjs",
       "sootsim.config.cjs"
     ];
-    SKIP_DIR_NAMES = /* @__PURE__ */ new Set([
-      "node_modules",
-      "artifacts",
-      "dist",
-      "build",
-      "out",
-      "coverage",
-      "tmp",
-      "public",
-      "ios",
-      "android",
-      "macos",
-      "windows",
-      "__fixtures__",
-      "__tests__",
-      "fixtures",
-      "fixture",
-      "examples",
-      "example"
-    ]);
-    MAX_SCANNED_DIRECTORIES = 256;
-    MAX_SCAN_DEPTH = 4;
   }
 });
 
@@ -17049,28 +17159,18 @@ function localOriginOf(value) {
   }
   return null;
 }
-function hasPackageJson(dir) {
-  try {
-    return import_node_fs11.default.statSync(import_node_path14.default.join(dir, "package.json")).isFile();
-  } catch {
-    return false;
-  }
-}
 function discoverNativeLinkedAppFonts(opts) {
   const metroOrigin = localOriginOf(opts.bundleUrl);
   if (!metroOrigin) return [];
-  const explicit = opts.repoDir || process.env.CONTRAST_REPO_DIR;
-  const startDir = explicit ? import_node_path14.default.resolve(explicit) : process.cwd();
-  if (!explicit && !hasPackageJson(startDir)) return [];
-  const project = resolveAppProject(startDir, { trustStart: opts.exactProjectDir });
+  const project = resolveAppProject(opts.projectDir);
   const selectedAppDir = project?.appDir ?? null;
   if (!selectedAppDir) return [];
   const platform = (opts.platform || process.env.CONTRAST_PLATFORM || "ios").toLowerCase();
   let getConfig = null;
-  if (explicit || project) {
+  if (project) {
     try {
       const modulePath = require3.resolve("@expo/config", {
-        paths: [selectedAppDir, startDir]
+        paths: [selectedAppDir]
       });
       const mod = require3(modulePath);
       if (typeof mod.getConfig === "function") {
@@ -17289,27 +17389,17 @@ function localOriginOf2(value) {
   }
   return null;
 }
-function hasPackageJson2(dir) {
-  try {
-    return import_node_fs12.default.statSync(import_node_path15.default.join(dir, "package.json")).isFile();
-  } catch {
-    return false;
-  }
-}
 function discoverConfigPluginAppSplash(opts) {
   const metroOrigin = localOriginOf2(opts.bundleUrl);
   if (!metroOrigin) return null;
-  const explicit = opts.repoDir || process.env.CONTRAST_REPO_DIR;
-  const startDir = explicit ? import_node_path15.default.resolve(explicit) : process.cwd();
-  if (!explicit && !hasPackageJson2(startDir)) return null;
-  const project = resolveAppProject(startDir, { trustStart: opts.exactProjectDir });
+  const project = resolveAppProject(opts.projectDir);
   const selectedAppDir = project?.appDir ?? null;
   if (!selectedAppDir) return null;
   const platform = (opts.platform || process.env.CONTRAST_PLATFORM || "ios").toLowerCase();
   let getConfig = null;
   try {
     const modulePath = require4.resolve("@expo/config", {
-      paths: [selectedAppDir, startDir]
+      paths: [selectedAppDir]
     });
     const mod = require4(modulePath);
     if (typeof mod.getConfig === "function") {
@@ -17334,13 +17424,11 @@ function discoverConfigPluginAppSplash(opts) {
 function encodeAppSplashWire(spec) {
   return encodeURIComponent(JSON.stringify(spec));
 }
-var import_node_fs12, import_node_module3, import_node_path15, import_config_plugin_splash, require4;
+var import_node_module3, import_config_plugin_splash, require4;
 var init_app_splash = __esm({
   "cli/app-splash.ts"() {
     "use strict";
-    import_node_fs12 = __toESM(require("node:fs"), 1);
     import_node_module3 = require("node:module");
-    import_node_path15 = __toESM(require("node:path"), 1);
     import_config_plugin_splash = require("sootsim-engine/engine/config-plugin-splash");
     init_app_project();
     require4 = (0, import_node_module3.createRequire)(__sootsim_import_meta_url);
@@ -18358,7 +18446,7 @@ function resolvePlaywright() {
         try {
           const modulePath = requireFromRoot.resolve(spec);
           const packageJsonPath = requireFromRoot.resolve(`${spec}/package.json`);
-          const parsed = JSON.parse((0, import_node_fs13.readFileSync)(packageJsonPath, "utf8"));
+          const parsed = JSON.parse((0, import_node_fs12.readFileSync)(packageJsonPath, "utf8"));
           if (!isRecord3(parsed) || typeof parsed.version !== "string") continue;
           const bin = parsed.bin;
           let binPath = null;
@@ -18370,8 +18458,8 @@ function resolvePlaywright() {
             binPath = typeof named === "string" ? named : typeof first === "string" ? first : null;
           }
           if (!binPath) continue;
-          const cliPath = (0, import_node_path16.join)((0, import_node_path16.dirname)(packageJsonPath), binPath);
-          if (!(0, import_node_fs13.existsSync)(cliPath)) continue;
+          const cliPath = (0, import_node_path15.join)((0, import_node_path15.dirname)(packageJsonPath), binPath);
+          if (!(0, import_node_fs12.existsSync)(cliPath)) continue;
           return {
             spec,
             modulePath,
@@ -18410,7 +18498,7 @@ function probeBrowser(resolved, env) {
     return {
       ok: true,
       executablePath: parsed.executablePath,
-      exists: parsed.exists && (0, import_node_fs13.existsSync)(parsed.executablePath)
+      exists: parsed.exists && (0, import_node_fs12.existsSync)(parsed.executablePath)
     };
   } catch (error) {
     return {
@@ -18449,14 +18537,14 @@ ${detail}` : ""}`
   }
   return { ok: true, executablePath: after.executablePath, installed: true };
 }
-var import_node_child_process5, import_node_fs13, import_node_module4, import_node_path16, PLAYWRIGHT_BROWSER_PROBE;
+var import_node_child_process5, import_node_fs12, import_node_module4, import_node_path15, PLAYWRIGHT_BROWSER_PROBE;
 var init_playwright_provisioning = __esm({
   "cli/drivers/playwright-provisioning.ts"() {
     "use strict";
     import_node_child_process5 = require("node:child_process");
-    import_node_fs13 = require("node:fs");
+    import_node_fs12 = require("node:fs");
     import_node_module4 = require("node:module");
-    import_node_path16 = require("node:path");
+    import_node_path15 = require("node:path");
     PLAYWRIGHT_BROWSER_PROBE = `
 const { existsSync } = require('node:fs');
 const modulePath = process.env.SOOTSIM_PW_MODULE;
@@ -19142,11 +19230,11 @@ function isChangelogEntry(value) {
     )
   );
 }
-async function fetchRuntimeReleaseNotes(version, request = fetch) {
+async function fetchRuntimeReleaseNotes(version, fetchImpl = fetch) {
   try {
     const url = new URL(SOOTSIM_CHANGELOG_API_URL);
     url.searchParams.set("version", version);
-    const response = await request(url, {
+    const response = await fetchImpl(url, {
       headers: { accept: "application/json" },
       signal: AbortSignal.timeout(5e3)
     });
@@ -19551,9 +19639,12 @@ function shouldOpenAsDeepLink(target) {
   return !/^https?:\/\//i.test(trimmed);
 }
 async function ensureBridgeForOpen(preferredPort, explicitPort = false) {
-  if (await canConnectToBridge(preferredPort, 250)) return preferredPort;
   const lock = readDaemonLockfile();
   assertExplicitBridgeLock(preferredPort, explicitPort, lock);
+  const preferredWorld = worldForBridgePort(preferredPort);
+  if ((explicitPort || preferredWorld !== null) && await canConnectToBridge(preferredPort, 250)) {
+    return preferredPort;
+  }
   if (lock && isDaemonLockfileFresh(lock) && await canConnectToBridge(lock.bridgePort, 500)) {
     return lock.bridgePort;
   }
@@ -19579,12 +19670,6 @@ async function ensureBridgeForOpen(preferredPort, explicitPort = false) {
       );
       return nextLock.bridgePort;
     }
-    if (await canConnectToBridge(preferredPort, 250)) {
-      console.error(
-        `  started local bridge on port ${preferredPort}; run \`sootsim setup\` to install the background daemon`
-      );
-      return preferredPort;
-    }
     if (childExit) {
       throw new Error(`rnx bridge exited before becoming ready (exit ${childExit})`);
     }
@@ -19604,14 +19689,14 @@ function assertExplicitBridgeLock(preferredPort, explicitPort, lock) {
 }
 async function ensureRuntimeForOpen() {
   const active = readActiveRuntime();
-  if (active && import_node_fs14.default.existsSync(runtimeDir(active))) return;
+  if (active && import_node_fs13.default.existsSync(runtimeDir(active))) return;
   console.error("  installing rnx engine runtime...");
   const { runRuntime: runRuntime2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
   await runRuntime2(["install"], {});
 }
 function spawnSootsim(args) {
   const entry = process.argv[1];
-  if (entry && import_node_fs14.default.existsSync(entry)) {
+  if (entry && import_node_fs13.default.existsSync(entry)) {
     return (0, import_node_child_process6.spawn)(process.execPath, [entry, ...args], {
       detached: true,
       stdio: "ignore",
@@ -19758,10 +19843,10 @@ async function buildResolvedBundleOpenUrl(target, baseUrl, opts = {}) {
 }
 function normalizeReplacementPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return import_node_path17.default.join(import_node_os3.default.homedir(), filePath.slice(2));
+    return import_node_path16.default.join(import_node_os3.default.homedir(), filePath.slice(2));
   }
-  if (import_node_path17.default.isAbsolute(filePath)) return filePath;
-  return import_node_path17.default.resolve(process.cwd(), filePath);
+  if (import_node_path16.default.isAbsolute(filePath)) return filePath;
+  return import_node_path16.default.resolve(process.cwd(), filePath);
 }
 function parseOpenRuntimeConfig(args) {
   const modules = {};
@@ -19780,7 +19865,7 @@ function parseOpenRuntimeConfig(args) {
       }
       const moduleName = raw.slice(0, eqIndex).trim();
       const filePath = normalizeReplacementPath(raw.slice(eqIndex + 1).trim());
-      if (!import_node_fs14.default.existsSync(filePath)) {
+      if (!import_node_fs13.default.existsSync(filePath)) {
         console.error(`  rnx open: replacement file not found: ${filePath}`);
         process.exit(1);
       }
@@ -19806,16 +19891,12 @@ function parseOpenRuntimeConfig(args) {
   return config.modules || config.network ? config : void 0;
 }
 async function resolveOpenAppProject(resolvedBundle) {
-  if (resolvedBundle) {
-    const advertisedRoot = await resolveMetroProjectRoot(resolvedBundle.bundleUrl);
-    if (advertisedRoot) {
-      return resolveAppProject(advertisedRoot, { trustStart: true });
-    }
-  }
-  return resolveAppProject(process.env.CONTRAST_REPO_DIR || process.cwd());
+  if (!resolvedBundle) return null;
+  const advertisedRoot = await resolveMetroProjectRoot(resolvedBundle.bundleUrl);
+  return advertisedRoot ? resolveAppProject(advertisedRoot) : null;
 }
 async function ensureConfiguredRuntime(version) {
-  if (import_node_fs14.default.existsSync(import_node_path17.default.join(runtimeDir(version), "index.html"))) return;
+  if (import_node_fs13.default.existsSync(import_node_path16.default.join(runtimeDir(version), "index.html"))) return;
   console.error(`  installing configured engine runtime ${version}...`);
   const result = await sootsimRuntime.install({
     version,
@@ -19847,12 +19928,10 @@ async function stampAppFonts(urlStr, project) {
   try {
     const url = new URL(urlStr);
     const bundleUrl = url.searchParams.get("bundle") || "";
-    if (!bundleUrl) return urlStr;
-    const repoDir = project?.appDir ?? await resolveMetroProjectRoot(bundleUrl) ?? void 0;
+    if (!bundleUrl || !project) return urlStr;
     const specs = discoverNativeLinkedAppFonts({
       bundleUrl,
-      repoDir,
-      exactProjectDir: !!project || !!repoDir
+      projectDir: project.appDir
     });
     if (specs.length === 0) return urlStr;
     const reachable = await filterReachableAppFonts(specs);
@@ -19914,12 +19993,10 @@ async function stampAppSplash(urlStr, project) {
   try {
     const url = new URL(urlStr);
     const bundleUrl = url.searchParams.get("bundle") || "";
-    if (!bundleUrl) return urlStr;
-    const repoDir = project?.appDir ?? await resolveMetroProjectRoot(bundleUrl) ?? void 0;
+    if (!bundleUrl || !project) return urlStr;
     const spec = discoverConfigPluginAppSplash({
       bundleUrl,
-      repoDir,
-      exactProjectDir: !!project || !!repoDir
+      projectDir: project.appDir
     });
     if (!spec) return urlStr;
     if (spec.imageUrl) {
@@ -20179,7 +20256,7 @@ function playwrightHostPidForSim(sim) {
 function signalDriverLaunchConnected(result) {
   if (!result.connectAckFile) return false;
   try {
-    import_node_fs14.default.writeFileSync(
+    import_node_fs13.default.writeFileSync(
       result.connectAckFile,
       `${JSON.stringify({ connectedAt: Date.now(), pid: result.pid ?? null })}
 `,
@@ -20193,19 +20270,19 @@ function signalDriverLaunchConnected(result) {
 function printDriverDiagnosticLogTail(result) {
   if (!result.diagnosticLogPath) return;
   try {
-    const detail = import_node_fs14.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
+    const detail = import_node_fs13.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
     if (!detail) {
-      console.error(`  ${import_node_path17.default.basename(result.diagnosticLogPath)} was empty`);
+      console.error(`  ${import_node_path16.default.basename(result.diagnosticLogPath)} was empty`);
       return;
     }
     const shown = detail.length > 4e3 ? `\u2026
 ${detail.slice(-4e3)}` : detail;
-    console.error(`  ${import_node_path17.default.basename(result.diagnosticLogPath)}:`);
+    console.error(`  ${import_node_path16.default.basename(result.diagnosticLogPath)}:`);
     console.error(shown);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(
-      `  failed to read ${import_node_path17.default.basename(result.diagnosticLogPath)}: ${message}`
+      `  failed to read ${import_node_path16.default.basename(result.diagnosticLogPath)}: ${message}`
     );
   }
 }
@@ -20687,7 +20764,7 @@ async function runOpenCommand(args, opts = {}) {
         );
         printOpenedSim(shellUrl, { ...targetSim, url: shellUrl }, "current sim");
         await maybeDescribeAfterOpen(parsed.wsPort, targetSim.id, args);
-        return;
+        return parsed.wsPort;
       }
     } finally {
       bridge.close();
@@ -20760,6 +20837,7 @@ async function runOpenCommand(args, opts = {}) {
   signalDriverLaunchConnected(result);
   printOpenedSim(openUrl2, match, `${driver.name} driver`);
   await maybeDescribeAfterOpen(parsed.wsPort, match.id, args);
+  return parsed.wsPort;
 }
 async function runUseLikeCommand(args, opts = {}) {
   const parsed = parseBridgeCliArgs(args, {
@@ -21022,14 +21100,14 @@ async function runCloseCommand(args, opts = {}) {
     bridge.close();
   }
 }
-var import_node_child_process6, import_node_fs14, import_node_os3, import_node_path17, import_settings, import_ws5, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS, DEEP_LINK_SCHEME_RE;
+var import_node_child_process6, import_node_fs13, import_node_os3, import_node_path16, import_settings, import_ws5, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS, DEEP_LINK_SCHEME_RE;
 var init_control = __esm({
   "cli/commands/control.ts"() {
     "use strict";
     import_node_child_process6 = require("node:child_process");
-    import_node_fs14 = __toESM(require("node:fs"), 1);
+    import_node_fs13 = __toESM(require("node:fs"), 1);
     import_node_os3 = __toESM(require("node:os"), 1);
-    import_node_path17 = __toESM(require("node:path"), 1);
+    import_node_path16 = __toESM(require("node:path"), 1);
     import_settings = require("sootsim-engine/settings");
     import_ws5 = require("ws");
     init_dev_server_scanner();
@@ -21811,14 +21889,14 @@ process.stdin.on('end', async () => {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path18.dirname)((0, import_node_path18.resolve)(explicit));
+    return (0, import_node_path17.dirname)((0, import_node_path17.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path18.resolve)(explicit);
-  return (0, import_node_path18.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path17.resolve)(explicit);
+  return (0, import_node_path17.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -21865,26 +21943,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs15.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs14.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs15.rmSync)(filepath, { force: true });
+      (0, import_node_fs14.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs15.rmSync)(filepath, { force: true });
+    (0, import_node_fs14.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs15, import_node_path18, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs14, import_node_path17, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs15 = require("node:fs");
-    import_node_path18 = require("node:path");
+    import_node_fs14 = require("node:fs");
+    import_node_path17 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -21967,33 +22045,13 @@ var init_run_registry = __esm({
   }
 });
 
-// cli/telemetry.ts
-var init_telemetry = __esm({
-  "cli/telemetry.ts"() {
-    "use strict";
-    init_agent_identity();
-    init_shared_session();
-    init_home_paths();
-  }
-});
-
 // cli/commands/upload.ts
 async function resolveDefaultUploadOrigin(explicitOrigin) {
   if (explicitOrigin) return explicitOrigin;
   if (process.env.SOOTSIM_UPLOAD_ORIGIN) return process.env.SOOTSIM_UPLOAD_ORIGIN;
-  try {
-    const res = await fetch(`${LOCAL_DEFAULT_ORIGIN}/api/preview/upload/init`, {
-      method: "OPTIONS",
-      signal: AbortSignal.timeout(LOCAL_UPLOAD_PROBE_TIMEOUT_MS)
-    });
-    if (res.ok || res.status === 204 || res.status === 405) {
-      return LOCAL_DEFAULT_ORIGIN;
-    }
-  } catch {
-  }
   return REMOTE_DEFAULT_ORIGIN;
 }
-var import_compress, import_compress_node, import_presigned_upload, import_trace, REMOTE_DEFAULT_ORIGIN, REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN, LOCAL_DEFAULT_ORIGIN, LOCAL_UPLOAD_PROBE_TIMEOUT_MS;
+var import_compress, import_compress_node, import_presigned_upload, import_trace, REMOTE_DEFAULT_ORIGIN, REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN;
 var init_upload = __esm({
   "cli/commands/upload.ts"() {
     "use strict";
@@ -22001,19 +22059,15 @@ var init_upload = __esm({
     import_compress_node = require("sootsim-engine/preview/compress-node");
     import_presigned_upload = require("sootsim-engine/preview/presigned-upload");
     import_trace = require("sootsim-engine/preview/trace");
-    init_shared_session();
     init_public_brand();
     init_app_fonts();
     init_app_splash();
     init_auth();
     init_open_url2();
     init_run_registry();
-    init_telemetry();
     init_ws_bridge();
     REMOTE_DEFAULT_ORIGIN = process.env.SOOTSIM_UPLOAD_ORIGIN || "https://contrast.dev";
     REMOTE_DEFAULT_PUBLIC_PREVIEW_ORIGIN = process.env.SOOTSIM_PREVIEW_ORIGIN || rnxPublicBrand.origin;
-    LOCAL_DEFAULT_ORIGIN = "https://contrast.localhost:3000";
-    LOCAL_UPLOAD_PROBE_TIMEOUT_MS = 2e3;
   }
 });
 
@@ -22147,16 +22201,16 @@ function resolveFlowScreenshotPath(screenshotDir, name2) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path17.basename(flowDir) === ".maestro" ? path17.dirname(flowDir) : flowDir;
+  return path16.basename(flowDir) === ".maestro" ? path16.dirname(flowDir) : flowDir;
 }
 function resolveFlowScreenshotPathWithMode(screenshotDir, name2, opts) {
   const normalizedName = name2.endsWith(".png") ? name2 : `${name2}.png`;
-  if (path17.isAbsolute(normalizedName)) return normalizedName;
+  if (path16.isAbsolute(normalizedName)) return normalizedName;
   if (opts.mode === "flow" && /[\\/]/.test(normalizedName)) {
     const baseDir = normalizedName.startsWith("./") || normalizedName.startsWith("../") ? opts.flowDir ?? process.cwd() : resolveProjectRelativeFlowBase(opts.flowDir);
-    return path17.resolve(baseDir, normalizedName);
+    return path16.resolve(baseDir, normalizedName);
   }
-  return path17.join(screenshotDir, normalizedName);
+  return path16.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -22213,12 +22267,12 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs17, path17, import_settings3, import_yaml, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
+var fs16, path16, import_settings3, import_yaml, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
-    fs17 = __toESM(require("fs"), 1);
-    path17 = __toESM(require("path"), 1);
+    fs16 = __toESM(require("fs"), 1);
+    path16 = __toESM(require("path"), 1);
     import_settings3 = require("sootsim-engine/settings");
     import_yaml = __toESM(require("yaml"), 1);
     init_frame_compose();
@@ -22515,14 +22569,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs17.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        fs16.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
         const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
-        const outputPath = path17.join(
+        const outputPath = path16.join(
           this.opts.recordingOutputDir,
           `sootsim-${Date.now()}.${extension}`
         );
-        fs17.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs16.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -23025,7 +23079,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs17.mkdirSync(path17.dirname(outputPath), { recursive: true });
+        fs16.mkdirSync(path16.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -23041,11 +23095,11 @@ var init_bridge_flow_runner = __esm({
             throw new Error("could not read current device model for framed screenshot");
           }
           const framed = await composeFramedScreenshot(rawBuffer, model);
-          fs17.writeFileSync(outputPath, framed);
+          fs16.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return outputPath;
         }
-        fs17.writeFileSync(outputPath, rawBuffer);
+        fs16.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
         return outputPath;
       }
@@ -23061,22 +23115,22 @@ var init_bridge_flow_runner = __esm({
         return model;
       }
       async captureScreenshot(outputPath) {
-        fs17.mkdirSync(path17.dirname(outputPath), { recursive: true });
+        fs16.mkdirSync(path16.dirname(outputPath), { recursive: true });
         const dataUrl = await this.bridge.send({
           type: "screenshot",
           simId: this.opts.simId
         });
         const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
-        fs17.writeFileSync(outputPath, Buffer.from(base64, "base64"));
+        fs16.writeFileSync(outputPath, Buffer.from(base64, "base64"));
       }
       // writes a per-failure debug bundle: screenshot + structured describe
       // + a11y tree + console errors/warnings + failed network requests +
       // shell state, all under one directory so post-mortem is one grep away.
       async captureFailureBundle(outputDir, context) {
-        fs17.mkdirSync(outputDir, { recursive: true });
+        fs16.mkdirSync(outputDir, { recursive: true });
         const write = (name2, content) => {
           try {
-            fs17.writeFileSync(path17.join(outputDir, name2), content);
+            fs16.writeFileSync(path16.join(outputDir, name2), content);
           } catch {
           }
         };
@@ -23595,8 +23649,8 @@ var init_bridge_flow_runner = __esm({
       runScript(target) {
         const spec = typeof target === "string" ? { file: target } : target;
         if (!spec.file) throw new Error("runScript requires a file");
-        const scriptPath = path17.resolve(this.opts.flowDir, spec.file);
-        const source = fs17.readFileSync(scriptPath, "utf8");
+        const scriptPath = path16.resolve(this.opts.flowDir, spec.file);
+        const source = fs16.readFileSync(scriptPath, "utf8");
         this.js.evaluate(source, { env: spec.env });
         console.log(`[flow]   runScript: ${spec.file} done`);
       }
@@ -23890,10 +23944,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path17.resolve(this.opts.flowDir, file);
-              const flowContent = fs17.readFileSync(flowPath, "utf8");
+              const flowPath = path16.resolve(this.opts.flowDir, file);
+              const flowContent = fs16.readFileSync(flowPath, "utf8");
               const previousDir = this.opts.flowDir;
-              this.opts.flowDir = path17.dirname(flowPath);
+              this.opts.flowDir = path16.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -24048,8 +24102,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs18 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
+var fs17 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 init_reap_browser();
@@ -24068,8 +24122,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path19 = await import("path");
-        const fs19 = await import("fs");
+        const path18 = await import("path");
+        const fs18 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -24124,9 +24178,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path19.join(context.outputDir, "a11y-report.json");
-          fs19.mkdirSync(path19.dirname(reportPath), { recursive: true });
-          fs19.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path18.join(context.outputDir, "a11y-report.json");
+          fs18.mkdirSync(path18.dirname(reportPath), { recursive: true });
+          fs18.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: issues.filter((i) => i.severity === "error").length === 0,
             message: `${report.errors} errors, ${report.warnings} warnings across ${report.nodeCount} nodes`,
@@ -24159,14 +24213,14 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs19 = await import("node:fs");
-        const path19 = await import("node:path");
+        const fs18 = await import("node:fs");
+        const path18 = await import("node:path");
         const { COMPAT_RESULT_CAVEAT: COMPAT_RESULT_CAVEAT2, formatPackageStatus: formatPackageStatus2, formatScanCounts: formatScanCounts2, scanDeps: scanDeps2 } = await Promise.resolve().then(() => (init_web(), web_exports));
-        const packagePath = path19.join(context.projectDir, "package.json");
-        if (!fs19.existsSync(packagePath)) {
+        const packagePath = path18.join(context.projectDir, "package.json");
+        if (!fs18.existsSync(packagePath)) {
           return { success: false, message: "No package.json found" };
         }
-        const parsed = JSON.parse(fs19.readFileSync(packagePath, "utf8"));
+        const parsed = JSON.parse(fs18.readFileSync(packagePath, "utf8"));
         if (!parsed || typeof parsed !== "object") {
           return { success: false, message: "package.json is not an object" };
         }
@@ -24178,9 +24232,9 @@ var skill2 = {
         }) : scanDeps2(parsed);
         const packageResult = params.packageName ? scan.packages[0] : void 0;
         const message = packageResult ? `${params.packageName}: ${formatPackageStatus2(packageResult)}. ${COMPAT_RESULT_CAVEAT2}` : `${formatScanCounts2(scan)}. ${COMPAT_RESULT_CAVEAT2}`;
-        const reportPath = path19.join(context.outputDir, "compat-report.json");
-        fs19.mkdirSync(path19.dirname(reportPath), { recursive: true });
-        fs19.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}
+        const reportPath = path18.join(context.outputDir, "compat-report.json");
+        fs18.mkdirSync(path18.dirname(reportPath), { recursive: true });
+        fs18.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}
 `);
         return {
           success: true,
@@ -24224,8 +24278,8 @@ var skill3 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs19 = await import("fs");
-        const path19 = await import("path");
+        const fs18 = await import("fs");
+        const path18 = await import("path");
         const yaml2 = await import("yaml");
         const { DEFAULT_SOOTSIM_BRIDGE_PORT: DEFAULT_SOOTSIM_BRIDGE_PORT2 } = await Promise.resolve().then(() => (init_bridge_constants(), bridge_constants_exports));
         const { SootSimBridgeHost: SootSimBridgeHost2 } = await Promise.resolve().then(() => (init_bridge_host(), bridge_host_exports));
@@ -24235,7 +24289,7 @@ var skill3 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT2 });
         host.start({ silent: true });
         try {
-          const flowContent = fs19.readFileSync(params.flowPath, "utf8");
+          const flowContent = fs18.readFileSync(params.flowPath, "utf8");
           const fmMatch = flowContent.match(/^---\n([\s\S]*?)\n---\n?/);
           const stepsBody = fmMatch ? flowContent.slice(fmMatch[0].length) : flowContent;
           const steps = yaml2.parse(stepsBody);
@@ -24262,7 +24316,7 @@ var skill3 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path19.dirname(path19.resolve(params.flowPath)),
+            flowDir: path18.dirname(path18.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -24284,7 +24338,7 @@ var skill3 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path19.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path18.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -24331,8 +24385,8 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path19 = await import("path");
-        const fs19 = await import("fs");
+        const path18 = await import("path");
+        const fs18 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -24358,9 +24412,9 @@ var skill4 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path19.join(context.outputDir, "perf-report.json");
-          fs19.mkdirSync(path19.dirname(reportPath), { recursive: true });
-          fs19.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path18.join(context.outputDir, "perf-report.json");
+          fs18.mkdirSync(path18.dirname(reportPath), { recursive: true });
+          fs18.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: true,
             message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
@@ -24393,8 +24447,8 @@ var skill5 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path19 = await import("path");
-        const fs19 = await import("fs");
+        const path18 = await import("path");
+        const fs18 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -24402,8 +24456,8 @@ var skill5 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const outputPath = path19.join(context.outputDir, `${params.name}.png`);
-          fs19.mkdirSync(path19.dirname(outputPath), { recursive: true });
+          const outputPath = path18.join(context.outputDir, `${params.name}.png`);
+          fs18.mkdirSync(path18.dirname(outputPath), { recursive: true });
           await page.screenshot({ path: outputPath });
           return {
             success: true,
@@ -24444,8 +24498,8 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path19 = await import("path");
-        const fs19 = await import("fs");
+        const path18 = await import("path");
+        const fs18 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -24453,14 +24507,14 @@ var skill6 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const currentPath = path19.join(context.outputDir, `${params.name}-current.png`);
-          fs19.mkdirSync(path19.dirname(currentPath), { recursive: true });
+          const currentPath = path18.join(context.outputDir, `${params.name}-current.png`);
+          fs18.mkdirSync(path18.dirname(currentPath), { recursive: true });
           await page.screenshot({ path: currentPath });
           try {
             const { PNG } = await import("pngjs");
             const pixelmatch = (await import("pixelmatch")).default;
-            const baseline = PNG.sync.read(fs19.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs19.readFileSync(currentPath));
+            const baseline = PNG.sync.read(fs18.readFileSync(params.baseline));
+            const current = PNG.sync.read(fs18.readFileSync(currentPath));
             const { width, height } = baseline;
             const diff = new PNG({ width, height });
             const numDiffPixels = pixelmatch(
@@ -24471,8 +24525,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path19.join(context.outputDir, `${params.name}-diff.png`);
-            fs19.writeFileSync(diffPath, PNG.sync.write(diff));
+            const diffPath = path18.join(context.outputDir, `${params.name}-diff.png`);
+            fs18.writeFileSync(diffPath, PNG.sync.write(diff));
             const totalPixels = width * height;
             const diffPercent = (numDiffPixels / totalPixels * 100).toFixed(2);
             return {
@@ -24536,10 +24590,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (sootsim-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path18.join(projectDir, "sootsim-skills.json");
-    if (!fs18.existsSync(manifestPath)) return;
+    const manifestPath = path17.join(projectDir, "sootsim-skills.json");
+    if (!fs17.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs18.readFileSync(manifestPath, "utf8"));
+      const manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf8"));
       if (Array.isArray(manifest.skills)) {
         for (const entry of manifest.skills) {
           if (typeof entry === "string") {
@@ -24550,7 +24604,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path18.resolve(projectDir, entry.file));
+              const mod = await import(path17.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -24563,10 +24617,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path18.join(projectDir, "package.json");
-    if (!fs18.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path17.join(projectDir, "package.json");
+    if (!fs17.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs18.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("maestro-test");