rnxsim 0.1.427 → 0.1.428

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.427 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.428 | (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;
@@ -16782,17 +16782,40 @@ var init_standalone = __esm({
 });
 
 // cli/self-invocation.ts
+function sourceEntryPath() {
+  try {
+    const candidate = (0, import_node_path7.join)((0, import_node_path7.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
+    return (0, import_node_fs7.existsSync)(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function isCliEntry(path20) {
+  const name2 = (0, import_node_path7.basename)(path20);
+  return name2 === "bin.ts" || name2 === "bin.js";
+}
 function rnxSelfInvocation() {
   if (IS_STANDALONE) return { executable: process.execPath, prefixArgs: [] };
   const entry = process.argv[1];
+  if (entry && isCliEntry(entry)) {
+    return { executable: process.execPath, prefixArgs: [entry] };
+  }
+  const sourceEntry = sourceEntryPath();
+  if (sourceEntry) {
+    return { executable: process.execPath, prefixArgs: [sourceEntry] };
+  }
   if (!entry) {
     throw new Error(`could not locate the ${rnxPublicBrand.commandName} entry script`);
   }
   return { executable: process.execPath, prefixArgs: [entry] };
 }
+var import_node_fs7, import_node_path7, import_node_url3;
 var init_self_invocation = __esm({
   "cli/self-invocation.ts"() {
     "use strict";
+    import_node_fs7 = require("node:fs");
+    import_node_path7 = require("node:path");
+    import_node_url3 = require("node:url");
     init_public_brand();
     init_standalone();
   }
@@ -16859,7 +16882,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path7.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path8.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -16873,7 +16896,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs7.default.readFileSync(file, "utf8");
+    raw = import_node_fs8.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -16890,7 +16913,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs7.default.renameSync(file, quarantine);
+      import_node_fs8.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -16901,16 +16924,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true });
+  import_node_fs8.default.mkdirSync(import_node_path8.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs7.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs8.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs7.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs7.default.fsyncSync(fd);
+    import_node_fs8.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs8.default.fsyncSync(fd);
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs8.default.closeSync(fd);
   }
-  import_node_fs7.default.renameSync(tmp, file);
+  import_node_fs8.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -16919,13 +16942,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path7.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path8.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto3.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path7.default.resolve(input.cwd);
+  const cwd = import_node_path8.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -16951,7 +16974,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path7.default.basename(cwd),
+      name: input.name ?? import_node_path8.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -17096,8 +17119,8 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs7.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path7.default.resolve(app.dir);
+      if (!import_node_fs8.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path8.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -17118,13 +17141,13 @@ async function seedFromDemoAppRegistry() {
     }
   });
 }
-var import_node_crypto3, import_node_fs7, import_node_path7, overrideDir, COST_HISTORY_MAX_AGE_MS;
+var import_node_crypto3, import_node_fs8, import_node_path8, overrideDir, COST_HISTORY_MAX_AGE_MS;
 var init_attached_projects = __esm({
   "src/attached-projects.ts"() {
     "use strict";
     import_node_crypto3 = require("node:crypto");
-    import_node_fs7 = __toESM(require("node:fs"), 1);
-    import_node_path7 = __toESM(require("node:path"), 1);
+    import_node_fs8 = __toESM(require("node:fs"), 1);
+    import_node_path8 = __toESM(require("node:path"), 1);
     init_home_paths();
     overrideDir = null;
     COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -17133,16 +17156,16 @@ var init_attached_projects = __esm({
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path8.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path9.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path8.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path9.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path8.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path9.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path8.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path9.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -17152,7 +17175,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs8.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs9.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -17165,11 +17188,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path8.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path8.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path9.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path9.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs8.default.existsSync(c)) return { executable: c, prefixArgs: [] };
+        if (import_node_fs9.default.existsSync(c)) return { executable: c, prefixArgs: [] };
       }
     }
   }
@@ -17188,15 +17211,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `rnx-${process.platform === "win32" ? "windows" : process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
-    const distBinary = import_node_path8.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs8.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
-    const distBin = import_node_path8.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs8.default.existsSync(distBin)) {
+    const distBinary = import_node_path9.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs9.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
+    const distBin = import_node_path9.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs9.default.existsSync(distBin)) {
       try {
-        const src = import_node_path8.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs8.default.existsSync(src)) {
-          const srcMtime = import_node_fs8.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs8.default.statSync(distBin).mtimeMs;
+        const src = import_node_path9.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs9.default.existsSync(src)) {
+          const srcMtime = import_node_fs9.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs9.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[rnx] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\`.`
@@ -17215,22 +17238,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve(`${rnxPublicBrand.packageName}/package.json`);
-    return import_node_path8.default.dirname(resolved);
+    return import_node_path9.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path8.default.dirname(here);
+  let cur = import_node_path9.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path8.default.join(cur, "package.json");
+    const pkg = import_node_path9.default.join(cur, "package.json");
     try {
-      if (import_node_fs8.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs8.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs9.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs9.default.readFileSync(pkg, "utf8"));
         if (parsed.name === rnxPublicBrand.packageName) return cur;
       }
     } catch {
     }
-    const parent = import_node_path8.default.dirname(cur);
+    const parent = import_node_path9.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -17246,28 +17269,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path8.default.join(getUserDataDir(), "locks");
-  import_node_fs8.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path9.default.join(getUserDataDir(), "locks");
+  import_node_fs9.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs8.default.chmodSync(lockDir, 448);
+    import_node_fs9.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path8.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path9.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs8.default.openSync(
+      fd = import_node_fs9.default.openSync(
         lockPath,
-        import_node_fs8.constants.O_WRONLY | import_node_fs8.constants.O_CREAT | import_node_fs8.constants.O_EXCL,
+        import_node_fs9.constants.O_WRONLY | import_node_fs9.constants.O_CREAT | import_node_fs9.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs8.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs9.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs8.default.unlinkSync(lockPath);
+          import_node_fs9.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -17281,15 +17304,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs8.default.writeFileSync(fd, String(process.pid));
+    import_node_fs9.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs8.default.closeSync(fd);
+      import_node_fs9.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs8.default.unlinkSync(lockPath);
+      import_node_fs9.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -17303,25 +17326,25 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path8.default.dirname(p);
-  import_node_fs8.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path9.default.dirname(p);
+  import_node_fs9.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs8.default.chmodSync(parent, 448);
+    import_node_fs9.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs8.default.existsSync(p)) {
+  if (import_node_fs9.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs8.default.statSync(p);
+      const stat2 = import_node_fs9.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs8.default.chmodSync(p, 384);
+          import_node_fs9.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs8.default.unlinkSync(p);
+      import_node_fs9.default.unlinkSync(p);
     } catch {
-      import_node_fs8.default.unlinkSync(p);
+      import_node_fs9.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process3.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -17361,10 +17384,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path8.default.dirname(transcript);
-    import_node_fs8.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path9.default.dirname(transcript);
+    import_node_fs9.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs8.default.chmodSync(transcriptDir, 448);
+      import_node_fs9.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { executable, prefixArgs } = resolveSootsimInvocation();
@@ -17415,7 +17438,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs8.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs9.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -17443,18 +17466,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs8.default.existsSync(fifo)) {
+  if (!import_node_fs9.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_WRONLY);
+  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs8.default.writeSync(fd, wireText + "\n");
+    import_node_fs9.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs8.default.closeSync(fd);
+    import_node_fs9.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -17476,7 +17499,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs8.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs9.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -17484,11 +17507,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs8.default.existsSync(fifo)) {
+  if (!import_node_fs9.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_RDWR);
-  const stream = import_node_fs8.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_RDWR);
+  const stream = import_node_fs9.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -17499,7 +17522,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs8.default.writeSync(fd, "\n");
+      import_node_fs9.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -17513,7 +17536,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_RDWR | import_node_fs8.constants.O_NONBLOCK);
+  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_RDWR | import_node_fs9.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -17521,7 +17544,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs8.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs9.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -17541,17 +17564,17 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs8.default.closeSync(fd);
+    import_node_fs9.default.closeSync(fd);
   }
 }
-var import_node_child_process3, import_node_crypto4, import_node_fs8, import_node_path8, import_node_readline, AgentSessionError;
+var import_node_child_process3, import_node_crypto4, import_node_fs9, import_node_path9, import_node_readline, AgentSessionError;
 var init_agent_sessions = __esm({
   "src/agent-sessions.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
     import_node_crypto4 = require("node:crypto");
-    import_node_fs8 = __toESM(require("node:fs"), 1);
-    import_node_path8 = __toESM(require("node:path"), 1);
+    import_node_fs9 = __toESM(require("node:fs"), 1);
+    import_node_path9 = __toESM(require("node:path"), 1);
     import_node_readline = __toESM(require("node:readline"), 1);
     init_self_invocation();
     init_standalone();
@@ -17666,12 +17689,12 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_fs9, import_node_path9, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
+var import_node_fs10, import_node_path10, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
-    import_node_fs9 = __toESM(require("node:fs"), 1);
-    import_node_path9 = __toESM(require("node:path"), 1);
+    import_node_fs10 = __toESM(require("node:fs"), 1);
+    import_node_path10 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
     init_attached_projects();
@@ -17870,7 +17893,7 @@ var init_agent_host = __esm({
         );
         const project = upsertProject({
           cwd: match.cwd,
-          name: match.projectName ?? import_node_path9.default.basename(match.cwd),
+          name: match.projectName ?? import_node_path10.default.basename(match.cwd),
           preferredProvider: input.provider ?? existing?.preferredProvider,
           sourceRoots: existing?.sourceRoots ?? [match.cwd],
           knownBundleUrls,
@@ -17881,18 +17904,18 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs9.default.existsSync(p)) {
+        if (!import_node_fs10.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs9.default.readFileSync(p, "utf8");
+        return import_node_fs10.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
         return {
           userDataDir: dir,
-          storeFile: import_node_path9.default.join(dir, "attached-projects.json"),
-          sessionsDir: import_node_path9.default.join(dir, "sessions"),
-          transcriptsDir: import_node_path9.default.join(dir, "transcripts")
+          storeFile: import_node_path10.default.join(dir, "attached-projects.json"),
+          sessionsDir: import_node_path10.default.join(dir, "sessions"),
+          transcriptsDir: import_node_path10.default.join(dir, "transcripts")
         };
       }
       // --- subscription management ---
@@ -18739,23 +18762,23 @@ function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs10.default.openSync(filePath, "r");
+    fd = import_node_fs11.default.openSync(filePath, "r");
     const buffer = Buffer.alloc(Math.min(BINARY_SNIFF_BYTES, size));
-    const read = import_node_fs10.default.readSync(fd, buffer, 0, buffer.length, 0);
+    const read = import_node_fs11.default.readSync(fd, buffer, 0, buffer.length, 0);
     return buffer.subarray(0, read).includes(0);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) import_node_fs10.default.closeSync(fd);
+    if (fd !== void 0) import_node_fs11.default.closeSync(fd);
   }
 }
-var import_node_child_process5, import_node_fs10, import_node_path10, CheckoutRequiresGitError, BINARY_SNIFF_BYTES, LIST_FILES_TIMEOUT_MS, LIST_FILES_ATTEMPTS, LIST_FILES_RETRY_MS, CheckoutFilePlane;
+var import_node_child_process5, import_node_fs11, import_node_path11, CheckoutRequiresGitError, BINARY_SNIFF_BYTES, LIST_FILES_TIMEOUT_MS, LIST_FILES_ATTEMPTS, LIST_FILES_RETRY_MS, CheckoutFilePlane;
 var init_checkout_plane = __esm({
   "cli/commands/box/checkout-plane.ts"() {
     "use strict";
     import_node_child_process5 = require("node:child_process");
-    import_node_fs10 = __toESM(require("node:fs"), 1);
-    import_node_path10 = __toESM(require("node:path"), 1);
+    import_node_fs11 = __toESM(require("node:fs"), 1);
+    import_node_path11 = __toESM(require("node:path"), 1);
     CheckoutRequiresGitError = class extends Error {
     };
     BINARY_SNIFF_BYTES = 8192;
@@ -18772,7 +18795,7 @@ var init_checkout_plane = __esm({
       listTimeoutMs;
       trackedOnly;
       constructor(root, options = {}) {
-        this.root = import_node_path10.default.resolve(root);
+        this.root = import_node_path11.default.resolve(root);
         this.listTimeoutMs = options.listTimeoutMs ?? LIST_FILES_TIMEOUT_MS;
         this.trackedOnly = options.trackedOnly ?? false;
       }
@@ -18834,13 +18857,13 @@ var init_checkout_plane = __esm({
           if (!relative) continue;
           let stat2;
           try {
-            stat2 = import_node_fs10.default.statSync(import_node_path10.default.join(this.root, relative));
+            stat2 = import_node_fs11.default.statSync(import_node_path11.default.join(this.root, relative));
           } catch {
             continue;
           }
           if (!stat2.isFile()) continue;
           const seen = this.sniffed.get(relative);
-          const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path10.default.join(this.root, relative), stat2.size);
+          const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path11.default.join(this.root, relative), stat2.size);
           nextSniffed.set(relative, { size: stat2.size, mtimeMs: stat2.mtimeMs, binary });
           next.set(relative, {
             size: stat2.size,
@@ -18854,22 +18877,22 @@ var init_checkout_plane = __esm({
         this.sniffed = nextSniffed;
       }
       absolute(planePath) {
-        const resolved = import_node_path10.default.resolve(this.root, planePath);
-        if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path10.default.sep}`)) {
+        const resolved = import_node_path11.default.resolve(this.root, planePath);
+        if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path11.default.sep}`)) {
           throw new Error(`path escapes the project: ${planePath}`);
         }
         return resolved;
       }
       async read(planePath) {
-        return import_node_fs10.default.promises.readFile(this.absolute(planePath), "utf8");
+        return import_node_fs11.default.promises.readFile(this.absolute(planePath), "utf8");
       }
       async readBytes(planePath) {
-        return import_node_fs10.default.promises.readFile(this.absolute(planePath));
+        return import_node_fs11.default.promises.readFile(this.absolute(planePath));
       }
       async write(planePath, content) {
         const absolute = this.absolute(planePath);
-        await import_node_fs10.default.promises.mkdir(import_node_path10.default.dirname(absolute), { recursive: true });
-        await import_node_fs10.default.promises.writeFile(absolute, content);
+        await import_node_fs11.default.promises.mkdir(import_node_path11.default.dirname(absolute), { recursive: true });
+        await import_node_fs11.default.promises.writeFile(absolute, content);
         this.entries.set(planePath, {
           size: content.byteLength,
           readOnly: false,
@@ -18878,7 +18901,7 @@ var init_checkout_plane = __esm({
         });
       }
       async delete(planePath) {
-        await import_node_fs10.default.promises.rm(this.absolute(planePath), { force: true });
+        await import_node_fs11.default.promises.rm(this.absolute(planePath), { force: true });
         this.entries.delete(planePath);
       }
     };
@@ -18886,12 +18909,12 @@ var init_checkout_plane = __esm({
 });
 
 // src/host/plane-host.ts
-var import_node_fs11, import_node_path11, WS_OPEN2, PlaneNotRegisteredError, PlaneHost;
+var import_node_fs12, import_node_path12, WS_OPEN2, PlaneNotRegisteredError, PlaneHost;
 var init_plane_host = __esm({
   "src/host/plane-host.ts"() {
     "use strict";
-    import_node_fs11 = __toESM(require("node:fs"), 1);
-    import_node_path11 = __toESM(require("node:path"), 1);
+    import_node_fs12 = __toESM(require("node:fs"), 1);
+    import_node_path12 = __toESM(require("node:path"), 1);
     init_plane();
     init_checkout_plane();
     WS_OPEN2 = 1;
@@ -19014,14 +19037,14 @@ var init_plane_host = __esm({
       // root and an opened one cannot disagree about the same directory.
       realRoot(root) {
         if (!root) throw new Error("root is required");
-        const resolved = import_node_path11.default.resolve(root);
+        const resolved = import_node_path12.default.resolve(root);
         let real;
         try {
-          real = import_node_fs11.default.realpathSync(resolved);
+          real = import_node_fs12.default.realpathSync(resolved);
         } catch {
           throw new Error(`no such directory: ${resolved}`);
         }
-        if (!import_node_fs11.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
+        if (!import_node_fs12.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
         return real;
       }
       respond(ws, id, result) {
@@ -19044,7 +19067,7 @@ var init_plane_host = __esm({
 
 // src/host/replacement-module-handler.ts
 function getReplacementLoader(filePath) {
-  const ext = import_node_path12.default.extname(filePath).toLowerCase();
+  const ext = import_node_path13.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".js":
       return "js";
@@ -19126,7 +19149,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("replacement files must be .js, .jsx, .ts, or .tsx");
     return true;
   }
-  if (!import_node_path12.default.isAbsolute(targetPath)) {
+  if (!import_node_path13.default.isAbsolute(targetPath)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file path must be absolute");
     return true;
@@ -19134,10 +19157,10 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
   let resolvedProjectRoot;
   if (options.projectRoot) {
-    const lexicalProjectRoot = import_node_path12.default.resolve(options.projectRoot);
+    const lexicalProjectRoot = import_node_path13.default.resolve(options.projectRoot);
     resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
-    const lexicalTarget = import_node_path12.default.relative(lexicalProjectRoot, targetPath);
-    if (lexicalTarget.startsWith("..") || import_node_path12.default.isAbsolute(lexicalTarget)) {
+    const lexicalTarget = import_node_path13.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path13.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;
@@ -19153,8 +19176,8 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (resolvedProjectRoot) {
-    const relativeTarget = import_node_path12.default.relative(resolvedProjectRoot, resolvedTargetPath);
-    if (relativeTarget.startsWith("..") || import_node_path12.default.isAbsolute(relativeTarget)) {
+    const relativeTarget = import_node_path13.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path13.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;
@@ -19239,12 +19262,12 @@ exports.jsxDEV = exports.jsx`,
   }
   return true;
 }
-var import_promises5, import_node_path12, import_esbuild, REPLACEMENT_MODULE_ROUTE;
+var import_promises5, import_node_path13, import_esbuild, REPLACEMENT_MODULE_ROUTE;
 var init_replacement_module_handler = __esm({
   "src/host/replacement-module-handler.ts"() {
     "use strict";
     import_promises5 = __toESM(require("node:fs/promises"), 1);
-    import_node_path12 = __toESM(require("node:path"), 1);
+    import_node_path13 = __toESM(require("node:path"), 1);
     import_esbuild = require("esbuild");
     init_backend_origin();
     REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
@@ -19252,20 +19275,62 @@ var init_replacement_module_handler = __esm({
 });
 
 // src/host/websocket-proxy.ts
-function rejectUpgrade(socket, status, message) {
+function rejectUpgrade(socket, status, message, headers = {}) {
   try {
+    const extraHeaders = Object.entries(headers).map(([name2, value]) => `${name2}: ${value}\r
+`).join("");
     socket.write(
       `HTTP/1.1 ${status} ${message}\r
 Connection: close\r
 Content-Type: text/plain\r
 Content-Length: ${message.length}\r
-\r
+${extraHeaders}\r
 ${message}`
     );
   } catch {
   }
   socket.destroy();
 }
+function hasHeaderToken(value, token) {
+  return (value || "").split(",").some((part) => part.trim().toLowerCase() === token);
+}
+function hasValidProtocolOffer(value) {
+  if (value === void 0) return true;
+  if (!WEBSOCKET_PROTOCOL_TOKEN.test(value[0] || "")) return false;
+  if (!WEBSOCKET_PROTOCOL_TOKEN.test(value[value.length - 1] || "")) return false;
+  const protocols = /* @__PURE__ */ new Set();
+  for (const part of value.split(",")) {
+    const protocol = part.trim();
+    if (!WEBSOCKET_PROTOCOL_TOKEN.test(protocol) || protocols.has(protocol)) {
+      return false;
+    }
+    protocols.add(protocol);
+  }
+  return true;
+}
+function validateUpgradeRequest(req) {
+  if (req.method !== "GET") {
+    return { status: 405, message: "invalid websocket http method" };
+  }
+  if (!hasHeaderToken(req.headers.connection, "upgrade") || !hasHeaderToken(req.headers.upgrade, "websocket")) {
+    return { status: 400, message: "invalid websocket upgrade headers" };
+  }
+  const key = req.headers["sec-websocket-key"];
+  if (typeof key !== "string" || !WEBSOCKET_KEY.test(key) || Buffer.from(key, "base64").byteLength !== 16 || Buffer.from(key, "base64").toString("base64") !== key) {
+    return { status: 400, message: "invalid websocket key" };
+  }
+  if (req.headers["sec-websocket-version"] !== "13") {
+    return {
+      status: 400,
+      message: "invalid websocket version",
+      headers: { "Sec-WebSocket-Version": "13" }
+    };
+  }
+  if (!hasValidProtocolOffer(req.headers["sec-websocket-protocol"])) {
+    return { status: 400, message: "invalid websocket protocol offer" };
+  }
+  return null;
+}
 function isSameOriginUpgrade(req) {
   const origin = req.headers.origin;
   const host = req.headers.host;
@@ -19295,61 +19360,29 @@ function getDefaultWebSocketOrigin(targetUrl) {
   origin.protocol = targetUrl.protocol === "wss:" ? "https:" : "http:";
   return origin.origin;
 }
-function getRequestedProtocols(req) {
-  const header = req.headers["sec-websocket-protocol"];
-  const value = Array.isArray(header) ? header.join(",") : header || "";
-  return value.split(",").map((part) => part.trim()).filter(Boolean);
-}
-function safeClose(ws, code, reason) {
-  if (ws.readyState === import_ws.WebSocket.CLOSED || ws.readyState === import_ws.WebSocket.CLOSING) {
-    return;
-  }
-  try {
-    ws.close(code, reason);
-  } catch {
-    ws.terminate();
-  }
-}
-function connectProxyPair(clientWs, upstream) {
-  let closing = false;
-  const closeBoth = (source, target, code, reason) => {
-    if (closing) return;
-    closing = true;
-    safeClose(target, code, reason.toString());
-    if (source.readyState === import_ws.WebSocket.OPEN) {
-      safeClose(source, code, reason.toString());
-    }
-  };
-  clientWs.on("message", (data, isBinary) => {
-    if (upstream.readyState === import_ws.WebSocket.OPEN) {
-      upstream.send(data, { binary: isBinary });
-    }
-  });
-  upstream.on("message", (data, isBinary) => {
-    if (clientWs.readyState === import_ws.WebSocket.OPEN) {
-      clientWs.send(data, { binary: isBinary });
-    }
-  });
-  clientWs.on("close", (code, reason) => closeBoth(clientWs, upstream, code, reason));
-  upstream.on("close", (code, reason) => closeBoth(upstream, clientWs, code, reason));
-  clientWs.on("error", () => safeClose(upstream, 1011, "proxy client error"));
-  upstream.on("error", () => safeClose(clientWs, 1011, "upstream websocket error"));
-}
-function createUpstreamWebSocket(targetUrl, protocols, headers, forwardOrigin) {
+function createUpstreamHeaders(req, targetUrl, headers, forwardOrigin) {
   const upstreamHeaders = { ...headers };
   const originKeys = Object.keys(upstreamHeaders).filter(
-    (key) => key.toLowerCase() === "origin"
+    (key2) => key2.toLowerCase() === "origin"
   );
   if (forwardOrigin && originKeys.length === 0) {
     upstreamHeaders.origin = getDefaultWebSocketOrigin(targetUrl);
   } else if (!forwardOrigin) {
-    for (const key of originKeys) delete upstreamHeaders[key];
-  }
-  if (Object.keys(upstreamHeaders).length === 0)
-    return new import_ws.WebSocket(targetUrl.href, protocols);
-  return new import_ws.WebSocket(targetUrl.href, protocols, {
-    headers: upstreamHeaders
-  });
+    for (const key2 of originKeys) delete upstreamHeaders[key2];
+  }
+  upstreamHeaders.connection = "Upgrade";
+  upstreamHeaders.upgrade = "websocket";
+  const key = req.headers["sec-websocket-key"];
+  if (typeof key === "string") upstreamHeaders["sec-websocket-key"] = key;
+  const version = req.headers["sec-websocket-version"];
+  if (typeof version === "string") upstreamHeaders["sec-websocket-version"] = version;
+  const protocol = req.headers["sec-websocket-protocol"];
+  if (typeof protocol === "string") upstreamHeaders["sec-websocket-protocol"] = protocol;
+  const extensions = req.headers["sec-websocket-extensions"];
+  if (typeof extensions === "string") {
+    upstreamHeaders["sec-websocket-extensions"] = extensions;
+  }
+  return upstreamHeaders;
 }
 function isWebSocketProxyRequestUrl(rawUrl) {
   if (!rawUrl) return false;
@@ -19365,6 +19398,16 @@ function handleWebSocketProxyUpgrade(req, socket, head, forwardOrigin = true) {
     rejectUpgrade(socket, 403, "forbidden websocket proxy origin");
     return true;
   }
+  const upgradeRejection = validateUpgradeRequest(req);
+  if (upgradeRejection) {
+    rejectUpgrade(
+      socket,
+      upgradeRejection.status,
+      upgradeRejection.message,
+      upgradeRejection.headers
+    );
+    return true;
+  }
   let targetUrl;
   let headers;
   try {
@@ -19384,45 +19427,107 @@ function handleWebSocketProxyUpgrade(req, socket, head, forwardOrigin = true) {
     rejectUpgrade(socket, 400, "invalid websocket proxy request");
     return true;
   }
-  const protocols = getRequestedProtocols(req);
-  const upstream = createUpstreamWebSocket(targetUrl, protocols, headers, forwardOrigin);
-  let completed = false;
+  const upstreamHeaders = createUpstreamHeaders(req, targetUrl, headers, forwardOrigin);
+  let settled = false;
+  const request = targetUrl.protocol === "wss:" ? import_https2.request : import_http3.request;
+  const upstreamRequestUrl = new URL(targetUrl);
+  upstreamRequestUrl.protocol = targetUrl.protocol === "wss:" ? "https:" : "http:";
+  const upstreamRequest = request(upstreamRequestUrl, {
+    method: "GET",
+    headers: upstreamHeaders
+  });
+  let destroyUpstreamSocket = () => {
+  };
+  upstreamRequest.once("socket", (upstreamSocket) => {
+    destroyUpstreamSocket = () => upstreamSocket.destroy();
+  });
+  const fail = (status, message) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    upstreamRequest.destroy();
+    destroyUpstreamSocket();
+    rejectUpgrade(socket, status, message);
+  };
+  const timer = setTimeout(() => {
+    fail(504, "upstream websocket handshake timeout");
+  }, WEBSOCKET_PROXY_HANDSHAKE_TIMEOUT_MS);
   socket.once("close", () => {
-    if (!completed) upstream.terminate();
+    if (!settled) {
+      settled = true;
+      clearTimeout(timer);
+    }
+    upstreamRequest.destroy();
+    destroyUpstreamSocket();
   });
-  upstream.once("open", () => {
-    if (completed) return;
-    completed = true;
-    const selectedProtocol = upstream.protocol;
-    const proxyServer = new import_ws.WebSocketServer({
-      noServer: true,
-      clientTracking: false,
-      handleProtocols(requestedProtocols) {
-        return selectedProtocol || requestedProtocols.values().next().value || false;
-      }
-    });
-    proxyServer.handleUpgrade(req, socket, head, (clientWs) => {
-      connectProxyPair(clientWs, upstream);
-    });
+  upstreamRequest.once("response", (response) => {
+    response.resume();
+    fail(502, "upstream websocket rejected upgrade");
   });
-  upstream.once("error", () => {
-    if (completed) return;
-    completed = true;
-    rejectUpgrade(socket, 502, "upstream websocket error");
+  upstreamRequest.once("error", () => {
+    fail(502, "upstream websocket error");
   });
-  upstream.once("close", () => {
-    if (completed) return;
-    completed = true;
-    rejectUpgrade(socket, 502, "upstream websocket closed");
+  upstreamRequest.once("upgrade", (response, upstreamSocket, upstreamHead) => {
+    if (settled) {
+      upstreamSocket.destroy();
+      return;
+    }
+    const accept = response.headers["sec-websocket-accept"];
+    const upgrade = response.headers.upgrade;
+    const requestKey = req.headers["sec-websocket-key"];
+    const expectedAccept = typeof requestKey === "string" ? (0, import_crypto.createHash)("sha1").update(`${requestKey}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64") : "";
+    if (typeof accept !== "string" || accept !== expectedAccept || typeof upgrade !== "string" || upgrade.toLowerCase() !== "websocket") {
+      upstreamSocket.destroy();
+      fail(502, "upstream websocket handshake is invalid");
+      return;
+    }
+    const selectedProtocol = response.headers["sec-websocket-protocol"];
+    const requestedProtocols = (req.headers["sec-websocket-protocol"] || "").split(",").map((protocol) => protocol.trim());
+    if (typeof selectedProtocol === "string" && !requestedProtocols.includes(selectedProtocol)) {
+      upstreamSocket.destroy();
+      fail(502, "upstream websocket selected an unrequested protocol");
+      return;
+    }
+    settled = true;
+    clearTimeout(timer);
+    const responseHeaders = [
+      "HTTP/1.1 101 Switching Protocols",
+      "Upgrade: websocket",
+      "Connection: Upgrade",
+      `Sec-WebSocket-Accept: ${accept}`
+    ];
+    if (typeof selectedProtocol === "string") {
+      responseHeaders.push(`Sec-WebSocket-Protocol: ${selectedProtocol}`);
+    }
+    const selectedExtensions = response.headers["sec-websocket-extensions"];
+    if (typeof selectedExtensions === "string") {
+      responseHeaders.push(`Sec-WebSocket-Extensions: ${selectedExtensions}`);
+    }
+    socket.write(`${responseHeaders.join("\r\n")}\r
+\r
+`);
+    if (head.length > 0) upstreamSocket.write(head);
+    if (upstreamHead.length > 0) socket.write(upstreamHead);
+    socket.once("close", () => upstreamSocket.destroy());
+    socket.once("error", () => upstreamSocket.destroy());
+    upstreamSocket.once("error", () => socket.destroy());
+    socket.pipe(upstreamSocket);
+    upstreamSocket.pipe(socket);
   });
+  upstreamRequest.end();
   return true;
 }
-var import_ws, WEBSOCKET_PROXY_PATH, STRIP_UPSTREAM_HEADERS;
+var import_crypto, import_http3, import_https2, WEBSOCKET_PROXY_PATH, WEBSOCKET_PROXY_HANDSHAKE_TIMEOUT_MS, WEBSOCKET_PROTOCOL_TOKEN, WEBSOCKET_KEY, STRIP_UPSTREAM_HEADERS;
 var init_websocket_proxy = __esm({
   "src/host/websocket-proxy.ts"() {
     "use strict";
-    import_ws = require("ws");
+    import_crypto = require("crypto");
+    import_http3 = require("http");
+    import_https2 = require("https");
     WEBSOCKET_PROXY_PATH = "/__websocket-proxy";
+    WEBSOCKET_PROXY_HANDSHAKE_TIMEOUT_MS = 1e4;
+    WEBSOCKET_PROTOCOL_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+    WEBSOCKET_KEY = /^[+/0-9A-Za-z]{22}==$/;
     STRIP_UPSTREAM_HEADERS = /* @__PURE__ */ new Set([
       "host",
       "connection",
@@ -19473,15 +19578,15 @@ function unrefTimer(timer) {
     timer.unref();
   }
 }
-var import_child_process3, import_fs2, import_http3, import_path2, import_ws2, SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY, WRITE_COMMAND_TYPES, FORCE_CLOSE_GRACE_MS, FORCE_CLOSE_TERMINATE_MS, DAEMON_HEARTBEAT_INTERVAL_MS, DEFAULT_RUNTIME_UPDATE_INTERVAL_MS, RUNTIME_UPDATE_INTERVAL_ENV, HTTP_MIME_TYPES, CAMERA_FIXTURE_ROUTE, CAMERA_FIXTURE_NAME_RE, SootSimBridgeHost;
+var import_child_process3, import_fs2, import_http4, import_path2, import_ws, SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY, WRITE_COMMAND_TYPES, FORCE_CLOSE_GRACE_MS, FORCE_CLOSE_TERMINATE_MS, DAEMON_HEARTBEAT_INTERVAL_MS, DEFAULT_RUNTIME_UPDATE_INTERVAL_MS, RUNTIME_UPDATE_INTERVAL_ENV, HTTP_MIME_TYPES, CAMERA_FIXTURE_ROUTE, CAMERA_FIXTURE_NAME_RE, SootSimBridgeHost;
 var init_bridge_host = __esm({
   "src/host/bridge-host.ts"() {
     "use strict";
     import_child_process3 = require("child_process");
     import_fs2 = __toESM(require("fs"), 1);
-    import_http3 = require("http");
+    import_http4 = require("http");
     import_path2 = __toESM(require("path"), 1);
-    import_ws2 = require("ws");
+    import_ws = require("ws");
     init_dev_server_scanner();
     init_bridge_constants();
     init_cli_version();
@@ -19705,7 +19810,7 @@ var init_bridge_host = __esm({
       }
       bindOnce(port, _silent) {
         return new Promise((resolve7, reject) => {
-          const server = (0, import_http3.createServer)((req, res) => this.handleHttpRequest(req, res));
+          const server = (0, import_http4.createServer)((req, res) => this.handleHttpRequest(req, res));
           let settled = false;
           const onError = (err) => {
             if (settled) return;
@@ -19728,7 +19833,7 @@ var init_bridge_host = __esm({
 `);
             });
             this.httpServer = server;
-            this.wss = new import_ws2.WebSocketServer({ noServer: true });
+            this.wss = new import_ws.WebSocketServer({ noServer: true });
             this.wireWebSocketServer();
             server.on("upgrade", (req, socket, head) => {
               if (handleWebSocketProxyUpgrade(req, socket, head)) return;
@@ -19966,7 +20071,7 @@ var init_bridge_host = __esm({
               const entry = this.cliBySentId.get(msg.id);
               if (entry) {
                 this.cliBySentId.delete(msg.id);
-                if (entry.ws.readyState === import_ws2.WebSocket.OPEN) {
+                if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
                   const otherCliCount = this.getOtherCliIdentityCount(entry.ws, entry.simId);
                   const response = otherCliCount > 0 ? { ...msg, id: entry.originalId, _otherCliCount: otherCliCount } : { ...msg, id: entry.originalId };
                   entry.ws.send(JSON.stringify(response));
@@ -19994,7 +20099,7 @@ var init_bridge_host = __esm({
                   if (typeof msg.cliLabel === "string" && msg.cliLabel.trim()) {
                     this.cliLabelBySocket.set(ws, msg.cliLabel.trim());
                   }
-                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -20009,7 +20114,7 @@ var init_bridge_host = __esm({
                   return;
                 }
                 if (msg.type === "bridge:list-sims") {
-                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -20025,7 +20130,7 @@ var init_bridge_host = __esm({
                     force: msg.force === true
                   });
                   if (!outcome.granted) {
-                    if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                    if (ws.readyState === import_ws.WebSocket.OPEN) {
                       ws.send(
                         JSON.stringify({
                           id: msg.id,
@@ -20041,7 +20146,7 @@ var init_bridge_host = __esm({
                     targetSim2.id,
                     outcome.bootedCount > 0 ? `cli force-claimed sim (booted ${outcome.bootedCount})` : "cli claimed sim"
                   );
-                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -20060,7 +20165,7 @@ var init_bridge_host = __esm({
                 if (shouldAcquireLease(msg)) {
                   const outcome = this.tryAcquireLease(ws, targetSim);
                   if (!outcome.granted) {
-                    if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                    if (ws.readyState === import_ws.WebSocket.OPEN) {
                       ws.send(
                         JSON.stringify({
                           id: msg.id,
@@ -20086,7 +20191,7 @@ var init_bridge_host = __esm({
                 targetSim.ws.send(JSON.stringify({ ...forwarded, id: sentId }));
                 if (forwarded.type === "close") {
                   this.cliBySentId.delete(sentId);
-                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -20101,7 +20206,7 @@ var init_bridge_host = __esm({
                   unrefTimer(closeTimer);
                 }
               } catch (err) {
-                if (ws.readyState === import_ws2.WebSocket.OPEN) {
+                if (ws.readyState === import_ws.WebSocket.OPEN) {
                   ws.send(
                     JSON.stringify({
                       id: msg.id,
@@ -20127,7 +20232,7 @@ var init_bridge_host = __esm({
               }
               for (const [sentId, entry] of this.cliBySentId) {
                 if (entry.simId !== sim.id) continue;
-                if (entry.ws.readyState === import_ws2.WebSocket.OPEN) {
+                if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
                   entry.ws.send(
                     JSON.stringify({
                       id: entry.originalId,
@@ -20499,7 +20604,7 @@ var init_bridge_host = __esm({
             if (runtimeVersionFromHostname(simUrl.hostname)) continue;
           } catch {
           }
-          if (sim.ws.readyState === import_ws2.WebSocket.OPEN) {
+          if (sim.ws.readyState === import_ws.WebSocket.OPEN) {
             try {
               sim.ws.send(payload);
             } catch {
@@ -20883,7 +20988,7 @@ var init_bridge_host = __esm({
       sweepDeadWebSockets() {
         if (!this.wss) return;
         for (const ws of this.wss.clients) {
-          if (ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+          if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
           const alive = this.wsIsAlive.get(ws);
           if (alive === false) {
             try {
@@ -20904,7 +21009,7 @@ var init_bridge_host = __esm({
         }
       }
       closeSimSocketFromHost(ws) {
-        if (ws.readyState !== import_ws2.WebSocket.OPEN) return;
+        if (ws.readyState !== import_ws.WebSocket.OPEN) return;
         try {
           ws.close(SOOTSIM_BRIDGE_SIM_CLOSE_CODE, SOOTSIM_BRIDGE_SIM_CLOSE_REASON);
         } catch {
@@ -20915,7 +21020,7 @@ var init_bridge_host = __esm({
           return;
         }
         const terminateTimer = setTimeout(() => {
-          if (ws.readyState === import_ws2.WebSocket.CLOSED) return;
+          if (ws.readyState === import_ws.WebSocket.CLOSED) return;
           try {
             ws.terminate();
           } catch {
@@ -21078,7 +21183,7 @@ var init_bridge_host = __esm({
         try {
           readyState = sim.ws.readyState;
         } catch {
-          readyState = import_ws2.WebSocket.CLOSED;
+          readyState = import_ws.WebSocket.CLOSED;
         }
         const lease = this.getActiveLease(sim);
         return {
@@ -21091,7 +21196,7 @@ var init_bridge_host = __esm({
           lastSeenAt: sim.lastSeenAt,
           lastActiveAt: sim.lastActiveAt || void 0,
           isPrimary: sim.id === this.primarySimId,
-          readyState: readyState === import_ws2.WebSocket.OPEN ? "open" : readyState === import_ws2.WebSocket.CLOSING ? "closing" : "closed",
+          readyState: readyState === import_ws.WebSocket.OPEN ? "open" : readyState === import_ws.WebSocket.CLOSING ? "closing" : "closed",
           attachedCliCount: this.getAttachedCliCount(sim.id),
           lockedBy: lease ? lease.cliLabel || lease.cliIdentityKey : void 0,
           lockedByKind: lease ? lease.kind : void 0,
@@ -21208,7 +21313,7 @@ var init_bridge_host = __esm({
       getOpenSim(simId) {
         if (simId) {
           const sim = this.sims.get(simId);
-          if (sim?.ws.readyState === import_ws2.WebSocket.OPEN) return sim;
+          if (sim?.ws.readyState === import_ws.WebSocket.OPEN) return sim;
           return null;
         }
         const candidates = this.getDefaultSimCandidates();
@@ -21216,7 +21321,7 @@ var init_bridge_host = __esm({
       }
       getDefaultSimCandidates() {
         const open = Array.from(this.sims.values()).filter(
-          (sim) => sim.ws.readyState === import_ws2.WebSocket.OPEN
+          (sim) => sim.ws.readyState === import_ws.WebSocket.OPEN
         );
         const registered = open.filter((sim) => sim.url);
         return registered.length > 0 ? registered : open;
@@ -21249,7 +21354,7 @@ var init_bridge_host = __esm({
       shouldPromoteSim(sim) {
         const current = this.primarySimId ? this.sims.get(this.primarySimId) : null;
         if (!sim.url) return !current;
-        const currentAlive = current?.ws.readyState === import_ws2.WebSocket.OPEN;
+        const currentAlive = current?.ws.readyState === import_ws.WebSocket.OPEN;
         if (!current || !currentAlive || !current.url) return true;
         const isPrimaryCandidate = sim.origin?.includes(":5173");
         const currentIsPrimary = current.origin?.includes(":5173");
@@ -21257,7 +21362,7 @@ var init_bridge_host = __esm({
       }
       broadcastSimAssignments() {
         for (const sim of this.sims.values()) {
-          if (sim.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+          if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
           sim.ws.send(
             JSON.stringify({
               type: "bridge:welcome",
@@ -21274,7 +21379,7 @@ var init_bridge_host = __esm({
           config: next
         });
         for (const peer of this.sims.values()) {
-          if (peer.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+          if (peer.ws.readyState !== import_ws.WebSocket.OPEN) continue;
           try {
             peer.ws.send(payload);
           } catch {
@@ -21284,7 +21389,7 @@ var init_bridge_host = __esm({
       }
       broadcastSimClientStates() {
         for (const sim of this.sims.values()) {
-          if (sim.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+          if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
           const lease = this.getActiveLease(sim);
           const message = {
             type: "bridge:client-state",
@@ -21355,7 +21460,7 @@ var init_bridge_host = __esm({
         const keys = /* @__PURE__ */ new Set();
         for (const [ws, attachedSimId] of this.cliSimBySocket) {
           if (attachedSimId !== simId) continue;
-          if (ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+          if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
           const key = this.cliIdentityKeyBySocket.get(ws);
           keys.add(key ?? `ws-unknown-${keys.size}`);
         }
@@ -21368,7 +21473,7 @@ var init_bridge_host = __esm({
         const keys = /* @__PURE__ */ new Set();
         for (const [ws, attachedSimId] of this.cliSimBySocket) {
           if (attachedSimId !== simId) continue;
-          if (ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+          if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
           const key = this.cliIdentityKeyBySocket.get(ws);
           if (key && key === selfKey) continue;
           keys.add(key ?? `ws-unknown-${keys.size}`);
@@ -21393,7 +21498,7 @@ var init_bridge_host = __esm({
         const nextId = requestedId?.trim();
         if (!nextId || nextId === sim.id) return false;
         const existing = this.sims.get(nextId);
-        if (existing && existing !== sim && existing.ws.readyState === import_ws2.WebSocket.OPEN) {
+        if (existing && existing !== sim && existing.ws.readyState === import_ws.WebSocket.OPEN) {
           return false;
         }
         const restorable = this.getRestorableSimState(nextId);
@@ -21943,31 +22048,31 @@ var init_parent_pid = __esm({
 
 // cli/secure-file.ts
 function writeSecureJsonAtomic(filepath, value) {
-  (0, import_node_fs12.mkdirSync)((0, import_node_path13.dirname)(filepath), { recursive: true });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path14.dirname)(filepath), { recursive: true });
   const temporary = `${filepath}.tmp-${process.pid}-${(0, import_node_crypto6.randomUUID)()}`;
   let descriptor = null;
   try {
-    descriptor = (0, import_node_fs12.openSync)(temporary, "wx", 384);
-    (0, import_node_fs12.fchmodSync)(descriptor, 384);
-    (0, import_node_fs12.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
+    descriptor = (0, import_node_fs13.openSync)(temporary, "wx", 384);
+    (0, import_node_fs13.fchmodSync)(descriptor, 384);
+    (0, import_node_fs13.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
 `);
-    (0, import_node_fs12.fsyncSync)(descriptor);
-    (0, import_node_fs12.closeSync)(descriptor);
+    (0, import_node_fs13.fsyncSync)(descriptor);
+    (0, import_node_fs13.closeSync)(descriptor);
     descriptor = null;
-    (0, import_node_fs12.renameSync)(temporary, filepath);
+    (0, import_node_fs13.renameSync)(temporary, filepath);
   } catch (error) {
-    if (descriptor !== null) (0, import_node_fs12.closeSync)(descriptor);
-    (0, import_node_fs12.rmSync)(temporary, { force: true });
+    if (descriptor !== null) (0, import_node_fs13.closeSync)(descriptor);
+    (0, import_node_fs13.rmSync)(temporary, { force: true });
     throw error;
   }
 }
-var import_node_crypto6, import_node_fs12, import_node_path13;
+var import_node_crypto6, import_node_fs13, import_node_path14;
 var init_secure_file = __esm({
   "cli/secure-file.ts"() {
     "use strict";
     import_node_crypto6 = require("node:crypto");
-    import_node_fs12 = require("node:fs");
-    import_node_path13 = require("node:path");
+    import_node_fs13 = require("node:fs");
+    import_node_path14 = require("node:path");
   }
 });
 
@@ -22141,17 +22246,17 @@ function liveDevBridgeLockfiles() {
   return readDevBridgeLockfiles().filter((lockfile) => isDevBridgeLockfileFresh(lockfile));
 }
 function checkoutRoot(cwd) {
-  let current = import_node_path14.default.resolve(cwd);
+  let current = import_node_path15.default.resolve(cwd);
   while (true) {
-    if (import_node_fs13.default.existsSync(import_node_path14.default.join(current, ".git"))) return current;
-    const parent = import_node_path14.default.dirname(current);
+    if (import_node_fs14.default.existsSync(import_node_path15.default.join(current, ".git"))) return current;
+    const parent = import_node_path15.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function pathContains(parent, child) {
-  const relative = import_node_path14.default.relative(parent, child);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path14.default.sep}`) && !import_node_path14.default.isAbsolute(relative);
+  const relative = import_node_path15.default.relative(parent, child);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path15.default.sep}`) && !import_node_path15.default.isAbsolute(relative);
 }
 function resolveDefaultDevBridgeLockfile() {
   const lockfiles = liveDevBridgeLockfiles();
@@ -22357,7 +22462,7 @@ function createBridge(wsPort, opts = {}) {
   let nextId = 1;
   const commandTimeoutMs = opts.commandTimeoutMs ?? 15e3;
   const pending = /* @__PURE__ */ new Map();
-  const ws = new import_ws3.WebSocket(bridgeWsUrl(wsPort));
+  const ws = new import_ws2.WebSocket(bridgeWsUrl(wsPort));
   const identity = getCliIdentity();
   const ready = new Promise((resolve7, reject) => {
     ws.on("open", () => {
@@ -22504,14 +22609,14 @@ function createBridge(wsPort, opts = {}) {
     },
     close() {
       try {
-        if (ws.readyState === import_ws3.WebSocket.OPEN) {
+        if (ws.readyState === import_ws2.WebSocket.OPEN) {
           ws.send(JSON.stringify({ type: "bridge:bye", id: 0 }));
         }
       } catch {
       }
       ws.close();
       const terminateGrace = setTimeout(() => {
-        if (ws.readyState !== import_ws3.WebSocket.CLOSED) {
+        if (ws.readyState !== import_ws2.WebSocket.CLOSED) {
           ws.terminate();
         }
       }, 250);
@@ -22584,13 +22689,13 @@ async function callInBridge(bridge, path20, ...args) {
 async function callInBridgeWrite(bridge, path20, ...args) {
   return bridge.send({ type: "call", path: path20, args, acquireLock: true });
 }
-var import_node_fs13, import_node_path14, import_ws3, RNX_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError;
+var import_node_fs14, import_node_path15, import_ws2, RNX_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError;
 var init_ws_bridge = __esm({
   "cli/ws-bridge.ts"() {
     "use strict";
-    import_node_fs13 = __toESM(require("node:fs"), 1);
-    import_node_path14 = __toESM(require("node:path"), 1);
-    import_ws3 = require("ws");
+    import_node_fs14 = __toESM(require("node:fs"), 1);
+    import_node_path15 = __toESM(require("node:path"), 1);
+    import_ws2 = require("ws");
     init_bridge_constants();
     init_cli_constants();
     init_home_paths();
@@ -22954,9 +23059,9 @@ var init_profiles = __esm({
 // cli/app-project.ts
 function firstNamedFile(dir, names) {
   for (const name2 of names) {
-    const candidate = import_node_path15.default.join(dir, name2);
+    const candidate = import_node_path16.default.join(dir, name2);
     try {
-      if (import_node_fs14.default.statSync(candidate).isFile()) return candidate;
+      if (import_node_fs15.default.statSync(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -22969,24 +23074,24 @@ function findRNXAppConfig(dir) {
   return firstNamedFile(dir, RNX_APP_CONFIG_NAMES);
 }
 function resolveAppProject(projectRoot) {
-  const appDir = import_node_path15.default.resolve(projectRoot);
+  const appDir = import_node_path16.default.resolve(projectRoot);
   try {
-    if (!import_node_fs14.default.statSync(appDir).isDirectory()) return null;
+    if (!import_node_fs15.default.statSync(appDir).isDirectory()) return null;
   } catch {
     return null;
   }
   const configPath = findRNXAppConfig(appDir);
-  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs14.default.existsSync(import_node_path15.default.join(appDir, "package.json"))) {
+  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs15.default.existsSync(import_node_path16.default.join(appDir, "package.json"))) {
     return null;
   }
   return { appDir, configPath };
 }
-var import_node_fs14, import_node_path15, EXPO_APP_CONFIG_NAMES, RNX_APP_CONFIG_NAMES;
+var import_node_fs15, import_node_path16, EXPO_APP_CONFIG_NAMES, RNX_APP_CONFIG_NAMES;
 var init_app_project = __esm({
   "cli/app-project.ts"() {
     "use strict";
-    import_node_fs14 = __toESM(require("node:fs"), 1);
-    import_node_path15 = __toESM(require("node:path"), 1);
+    import_node_fs15 = __toESM(require("node:fs"), 1);
+    import_node_path16 = __toESM(require("node:path"), 1);
     EXPO_APP_CONFIG_NAMES = [
       "app.config.js",
       "app.config.ts",
@@ -23015,13 +23120,13 @@ function isRNXConfig(value) {
 }
 function resolveConfigReplacementFiles(config, configPath) {
   if (!config.modules) return config;
-  const configDir = import_node_path16.default.dirname(configPath);
+  const configDir = import_node_path17.default.dirname(configPath);
   return {
     ...config,
     modules: Object.fromEntries(
       Object.entries(config.modules).map(([name2, resolution]) => [
         name2,
-        resolution && typeof resolution === "object" && "file" in resolution ? { ...resolution, file: import_node_path16.default.resolve(configDir, resolution.file) } : resolution
+        resolution && typeof resolution === "object" && "file" in resolution ? { ...resolution, file: import_node_path17.default.resolve(configDir, resolution.file) } : resolution
       ])
     )
   };
@@ -23051,12 +23156,12 @@ async function resolveRNXAppConfig(startDir = process.cwd()) {
   const project = resolveAppProject(startDir);
   return { project, config: await loadRNXAppConfig(project) };
 }
-var import_node_module, import_node_path16, import_jiti, require2;
+var import_node_module, import_node_path17, import_jiti, require2;
 var init_app_config = __esm({
   "cli/app-config.ts"() {
     "use strict";
     import_node_module = require("node:module");
-    import_node_path16 = __toESM(require("node:path"), 1);
+    import_node_path17 = __toESM(require("node:path"), 1);
     init_src();
     import_jiti = require("jiti");
     init_public_brand();
@@ -23124,13 +23229,13 @@ function discoverNativeLinkedAppFonts(opts) {
       scannedFontDirectories++;
       let entries;
       try {
-        entries = import_node_fs15.default.readdirSync(current.dir, { withFileTypes: true });
+        entries = import_node_fs16.default.readdirSync(current.dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of entries) {
         if (entry.isSymbolicLink()) continue;
-        const fullPath = import_node_path17.default.join(current.dir, entry.name);
+        const fullPath = import_node_path18.default.join(current.dir, entry.name);
         if (entry.isDirectory()) {
           if (current.depth < 4 && pending.length < 64 && !entry.name.startsWith(".")) {
             pending.push({ dir: fullPath, depth: current.depth + 1 });
@@ -23138,15 +23243,15 @@ function discoverNativeLinkedAppFonts(opts) {
           continue;
         }
         if (!entry.isFile() || !/\.(ttf|otf|woff|woff2)$/i.test(entry.name)) continue;
-        const relative = import_node_path17.default.relative(root, fullPath).split(import_node_path17.default.sep).join("/");
-        fontPaths.push(import_node_path17.default.posix.join(metroPathPrefix, relative));
+        const relative = import_node_path18.default.relative(root, fullPath).split(import_node_path18.default.sep).join("/");
+        fontPaths.push(import_node_path18.default.posix.join(metroPathPrefix, relative));
         if (fontPaths.length >= 256) break;
       }
     }
   };
   try {
     const packageJson = JSON.parse(
-      import_node_fs15.default.readFileSync(import_node_path17.default.join(selectedAppDir, "package.json"), "utf8")
+      import_node_fs16.default.readFileSync(import_node_path18.default.join(selectedAppDir, "package.json"), "utf8")
     );
     const dependencyNames = /* @__PURE__ */ new Set();
     for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
@@ -23161,24 +23266,24 @@ function discoverNativeLinkedAppFonts(opts) {
       const config = Reflect.get(packageJson, "reactNativeVectorIcons");
       const configuredFontDir = config && typeof config === "object" ? Reflect.get(config, "fontDir") : null;
       const configuredDir = typeof configuredFontDir === "string" ? configuredFontDir : "rnvi-fonts";
-      const root = import_node_path17.default.resolve(selectedAppDir, configuredDir);
-      const relativeRoot = import_node_path17.default.relative(selectedAppDir, root);
-      if (!relativeRoot.startsWith("..") && !import_node_path17.default.isAbsolute(relativeRoot)) {
-        collectFontFiles(root, relativeRoot.split(import_node_path17.default.sep).join("/"));
+      const root = import_node_path18.default.resolve(selectedAppDir, configuredDir);
+      const relativeRoot = import_node_path18.default.relative(selectedAppDir, root);
+      if (!relativeRoot.startsWith("..") && !import_node_path18.default.isAbsolute(relativeRoot)) {
+        collectFontFiles(root, relativeRoot.split(import_node_path18.default.sep).join("/"));
       }
-      const vectorIconRequire = (0, import_node_module2.createRequire)(import_node_path17.default.join(selectedAppDir, "package.json"));
+      const vectorIconRequire = (0, import_node_module2.createRequire)(import_node_path18.default.join(selectedAppDir, "package.json"));
       for (const dependencyName of vectorIconDependencies) {
         try {
           const entryPath = vectorIconRequire.resolve(dependencyName);
-          const dependencyPath = dependencyName.split("/").join(import_node_path17.default.sep);
-          const marker = `${import_node_path17.default.sep}node_modules${import_node_path17.default.sep}${dependencyPath}${import_node_path17.default.sep}`;
+          const dependencyPath = dependencyName.split("/").join(import_node_path18.default.sep);
+          const marker = `${import_node_path18.default.sep}node_modules${import_node_path18.default.sep}${dependencyPath}${import_node_path18.default.sep}`;
           const markerIndex = entryPath.lastIndexOf(marker);
           if (markerIndex === -1) continue;
           const packageRoot = entryPath.slice(0, markerIndex + marker.length - 1);
           const fontsDir = dependencyName === "react-native-vector-icons" ? "Fonts" : "fonts";
           collectFontFiles(
-            import_node_path17.default.join(packageRoot, fontsDir),
-            import_node_path17.default.posix.join("node_modules", dependencyName, fontsDir)
+            import_node_path18.default.join(packageRoot, fontsDir),
+            import_node_path18.default.posix.join("node_modules", dependencyName, fontsDir)
           );
         } catch {
         }
@@ -23187,37 +23292,37 @@ function discoverNativeLinkedAppFonts(opts) {
   } catch {
   }
   try {
-    const configPath = import_node_path17.default.join(selectedAppDir, "react-native.config.js");
-    if (import_node_fs15.default.statSync(configPath).isFile()) {
-      const appConfigRequire = (0, import_node_module2.createRequire)(import_node_path17.default.join(selectedAppDir, "package.json"));
+    const configPath = import_node_path18.default.join(selectedAppDir, "react-native.config.js");
+    if (import_node_fs16.default.statSync(configPath).isFile()) {
+      const appConfigRequire = (0, import_node_module2.createRequire)(import_node_path18.default.join(selectedAppDir, "package.json"));
       const rnConfig = appConfigRequire(configPath);
       const assets = rnConfig && typeof rnConfig === "object" ? Reflect.get(rnConfig, "assets") : null;
       if (Array.isArray(assets)) {
         for (const assetDir of assets) {
           if (typeof assetDir !== "string") continue;
-          const root = import_node_path17.default.resolve(selectedAppDir, assetDir);
-          const relativeRoot = import_node_path17.default.relative(selectedAppDir, root);
-          if (relativeRoot.startsWith("..") || import_node_path17.default.isAbsolute(relativeRoot)) continue;
-          collectFontFiles(root, relativeRoot.split(import_node_path17.default.sep).join("/"));
+          const root = import_node_path18.default.resolve(selectedAppDir, assetDir);
+          const relativeRoot = import_node_path18.default.relative(selectedAppDir, root);
+          if (relativeRoot.startsWith("..") || import_node_path18.default.isAbsolute(relativeRoot)) continue;
+          collectFontFiles(root, relativeRoot.split(import_node_path18.default.sep).join("/"));
         }
       }
     }
   } catch {
   }
   if (platform === "ios") {
-    const iosDir = import_node_path17.default.join(selectedAppDir, "ios");
+    const iosDir = import_node_path18.default.join(selectedAppDir, "ios");
     try {
-      const targetDirs = import_node_fs15.default.readdirSync(iosDir, { withFileTypes: true }).filter(
+      const targetDirs = import_node_fs16.default.readdirSync(iosDir, { withFileTypes: true }).filter(
         (entry) => entry.isDirectory() && !entry.isSymbolicLink() && entry.name !== "Pods" && entry.name !== "build" && !entry.name.startsWith(".")
       ).slice(0, 64);
-      const plistPaths = [import_node_path17.default.join(iosDir, "Info.plist")];
+      const plistPaths = [import_node_path18.default.join(iosDir, "Info.plist")];
       for (const entry of targetDirs) {
-        plistPaths.push(import_node_path17.default.join(iosDir, entry.name, "Info.plist"));
+        plistPaths.push(import_node_path18.default.join(iosDir, entry.name, "Info.plist"));
       }
       for (const plistPath of plistPaths) {
         let parsed;
         try {
-          parsed = parsePlistSource(import_node_fs15.default.readFileSync(plistPath, "utf8"));
+          parsed = parsePlistSource(import_node_fs16.default.readFileSync(plistPath, "utf8"));
         } catch {
           continue;
         }
@@ -23227,21 +23332,21 @@ function discoverNativeLinkedAppFonts(opts) {
         for (const declaredFont of declaredFonts) {
           if (typeof declaredFont !== "string") continue;
           const candidates = [
-            import_node_path17.default.resolve(import_node_path17.default.dirname(plistPath), declaredFont),
-            import_node_path17.default.resolve(iosDir, declaredFont)
+            import_node_path18.default.resolve(import_node_path18.default.dirname(plistPath), declaredFont),
+            import_node_path18.default.resolve(iosDir, declaredFont)
           ];
           const fontPath = candidates.find((candidate) => {
-            const relative = import_node_path17.default.relative(selectedAppDir, candidate);
-            if (relative.startsWith("..") || import_node_path17.default.isAbsolute(relative)) return false;
+            const relative = import_node_path18.default.relative(selectedAppDir, candidate);
+            if (relative.startsWith("..") || import_node_path18.default.isAbsolute(relative)) return false;
             try {
-              return import_node_fs15.default.statSync(candidate).isFile();
+              return import_node_fs16.default.statSync(candidate).isFile();
             } catch {
               return false;
             }
           });
           if (!fontPath) continue;
           fontPaths.push(
-            import_node_path17.default.relative(selectedAppDir, fontPath).split(import_node_path17.default.sep).join("/")
+            import_node_path18.default.relative(selectedAppDir, fontPath).split(import_node_path18.default.sep).join("/")
           );
         }
       }
@@ -23280,13 +23385,13 @@ async function resolveMetroProjectRoot(bundleUrl, opts) {
 function encodeAppFontsWire(specs) {
   return specs.map((spec) => `${encodeURIComponent(spec.url)}::${encodeURIComponent(spec.family)}`).join(",");
 }
-var import_node_fs15, import_node_module2, import_node_path17, import_config_plugin_fonts, require3;
+var import_node_fs16, import_node_module2, import_node_path18, import_config_plugin_fonts, require3;
 var init_app_fonts = __esm({
   "cli/app-fonts.ts"() {
     "use strict";
-    import_node_fs15 = __toESM(require("node:fs"), 1);
+    import_node_fs16 = __toESM(require("node:fs"), 1);
     import_node_module2 = require("node:module");
-    import_node_path17 = __toESM(require("node:path"), 1);
+    import_node_path18 = __toESM(require("node:path"), 1);
     import_config_plugin_fonts = require("sootsim-engine/engine/config-plugin-fonts");
     init_dev_server_scanner();
     init_plist();
@@ -24382,7 +24487,7 @@ function resolvePlaywright() {
         try {
           const modulePath = requireFromRoot.resolve(spec);
           const packageJsonPath = requireFromRoot.resolve(`${spec}/package.json`);
-          const parsed = JSON.parse((0, import_node_fs16.readFileSync)(packageJsonPath, "utf8"));
+          const parsed = JSON.parse((0, import_node_fs17.readFileSync)(packageJsonPath, "utf8"));
           if (!isRecord5(parsed) || typeof parsed.version !== "string") continue;
           const bin = parsed.bin;
           let binPath = null;
@@ -24394,8 +24499,8 @@ function resolvePlaywright() {
             binPath = typeof named === "string" ? named : typeof first === "string" ? first : null;
           }
           if (!binPath) continue;
-          const cliPath = (0, import_node_path18.join)((0, import_node_path18.dirname)(packageJsonPath), binPath);
-          if (!(0, import_node_fs16.existsSync)(cliPath)) continue;
+          const cliPath = (0, import_node_path19.join)((0, import_node_path19.dirname)(packageJsonPath), binPath);
+          if (!(0, import_node_fs17.existsSync)(cliPath)) continue;
           return {
             spec,
             modulePath,
@@ -24439,7 +24544,7 @@ function probeBrowser(resolved, env) {
     return {
       ok: true,
       executablePath: parsed.executablePath,
-      exists: parsed.exists && (0, import_node_fs16.existsSync)(parsed.executablePath)
+      exists: parsed.exists && (0, import_node_fs17.existsSync)(parsed.executablePath)
     };
   } catch (error) {
     return {
@@ -24490,14 +24595,14 @@ ${detail}` : ""}`
   }
   return { ok: true, executablePath: after.executablePath, installed: true };
 }
-var import_node_child_process6, import_node_fs16, import_node_module4, import_node_path18;
+var import_node_child_process6, import_node_fs17, import_node_module4, import_node_path19;
 var init_playwright_provisioning = __esm({
   "cli/drivers/playwright-provisioning.ts"() {
     "use strict";
     import_node_child_process6 = require("node:child_process");
-    import_node_fs16 = require("node:fs");
+    import_node_fs17 = require("node:fs");
     import_node_module4 = require("node:module");
-    import_node_path18 = require("node:path");
+    import_node_path19 = require("node:path");
     init_internal_child();
     init_self_invocation();
   }
@@ -24888,7 +24993,7 @@ async function tellDaemonRuntimeChanged(version) {
       settled = true;
       resolve7(ok);
     };
-    const ws = new import_ws4.WebSocket(`ws://127.0.0.1:${port}`, {
+    const ws = new import_ws3.WebSocket(`ws://127.0.0.1:${port}`, {
       handshakeTimeout: 800
     });
     const timer = setTimeout(() => {
@@ -25042,13 +25147,13 @@ function describeError(err) {
   if (err instanceof Error) return err.message;
   return String(err);
 }
-var import_fs8, import_ws4;
+var import_fs8, import_ws3;
 var init_runtime = __esm({
   "cli/commands/runtime.ts"() {
     "use strict";
     import_fs8 = __toESM(require("fs"), 1);
     init_src();
-    import_ws4 = require("ws");
+    import_ws3 = require("ws");
     init_home_paths();
     init_runtime_delivery();
     init_app_config();
@@ -25172,13 +25277,18 @@ function assertExplicitBridgeLock(preferredPort, explicitPort, lock) {
   if (!explicitPort || !lock || !isDaemonLockfileFresh(lock) || lock.bridgePort === preferredPort) {
     return;
   }
+  if (readDevBridgeLockfiles().some(
+    (devBridge) => devBridge.bridgePort === preferredPort && isDevBridgeLockfileFresh(devBridge)
+  )) {
+    return;
+  }
   throw new Error(
     `${rnxPublicBrand.commandName} open: requested bridge port ${preferredPort}, but the active daemon owns port ${lock.bridgePort}. explicit --port never selects another bridge; stop that daemon or use an isolated RNX_HOME.`
   );
 }
 async function ensureRuntimeForOpen() {
   const active = readActiveRuntime();
-  if (active && import_node_fs17.default.existsSync(runtimeDir(active))) return;
+  if (active && import_node_fs18.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"], {});
@@ -25193,13 +25303,13 @@ function spawnSootsim(args) {
 }
 function canConnectToBridge(port, timeoutMs) {
   return new Promise((resolve7) => {
-    const ws = new import_ws5.WebSocket(`ws://127.0.0.1:${port}`, { handshakeTimeout: timeoutMs });
+    const ws = new import_ws4.WebSocket(`ws://127.0.0.1:${port}`, { handshakeTimeout: timeoutMs });
     let settled = false;
     const finish = (ok) => {
       if (settled) return;
       settled = true;
-      if (ws.readyState === import_ws5.WebSocket.OPEN) ws.close();
-      else if (ws.readyState === import_ws5.WebSocket.CONNECTING) ws.terminate();
+      if (ws.readyState === import_ws4.WebSocket.OPEN) ws.close();
+      else if (ws.readyState === import_ws4.WebSocket.CONNECTING) ws.terminate();
       resolve7(ok);
     };
     ws.once("open", () => finish(true));
@@ -25325,10 +25435,10 @@ async function buildResolvedBundleOpenUrl(target, baseUrl, opts = {}) {
 }
 function normalizeReplacementPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return import_node_path19.default.join(import_node_os3.default.homedir(), filePath.slice(2));
+    return import_node_path20.default.join(import_node_os3.default.homedir(), filePath.slice(2));
   }
-  if (import_node_path19.default.isAbsolute(filePath)) return filePath;
-  return import_node_path19.default.resolve(process.cwd(), filePath);
+  if (import_node_path20.default.isAbsolute(filePath)) return filePath;
+  return import_node_path20.default.resolve(process.cwd(), filePath);
 }
 function parseOpenRuntimeConfig(args) {
   const modules = {};
@@ -25347,7 +25457,7 @@ function parseOpenRuntimeConfig(args) {
       }
       const moduleName = raw.slice(0, eqIndex).trim();
       const filePath = normalizeReplacementPath(raw.slice(eqIndex + 1).trim());
-      if (!import_node_fs17.default.existsSync(filePath)) {
+      if (!import_node_fs18.default.existsSync(filePath)) {
         console.error(`  rnx open: replacement file not found: ${filePath}`);
         rnxExit(1);
       }
@@ -25378,7 +25488,7 @@ async function resolveOpenAppProject(resolvedBundle) {
   return advertisedRoot ? resolveAppProject(advertisedRoot) : null;
 }
 async function ensureConfiguredRuntime(version) {
-  if (import_node_fs17.default.existsSync(import_node_path19.default.join(runtimeDir(version), "index.html"))) return;
+  if (import_node_fs18.default.existsSync(import_node_path20.default.join(runtimeDir(version), "index.html"))) return;
   console.error(`  installing configured engine runtime ${version}...`);
   const result = await rnxRuntime.install({
     version,
@@ -25454,7 +25564,13 @@ async function resolveShellUrl(target, baseUrl, opts = {}) {
     return new URL(baseUrl).toString();
   }
   if (looksLikeSootsimUrl(target)) {
-    return new URL(target).toString();
+    const url = new URL(target);
+    const base = new URL(baseUrl);
+    const baseConfig = base.searchParams.get(RNX_CONFIG_QUERY_PARAM);
+    if (baseConfig && !url.searchParams.has(RNX_CONFIG_QUERY_PARAM)) {
+      url.searchParams.set(RNX_CONFIG_QUERY_PARAM, baseConfig);
+    }
+    return url.toString();
   }
   if (looksLikeShellPathTarget(target)) {
     return buildShellPathOpenUrl(target, baseUrl);
@@ -25738,7 +25854,7 @@ function playwrightHostPidForSim(sim) {
 function signalDriverLaunchConnected(result) {
   if (!result.connectAckFile) return false;
   try {
-    import_node_fs17.default.writeFileSync(
+    import_node_fs18.default.writeFileSync(
       result.connectAckFile,
       `${JSON.stringify({ connectedAt: Date.now(), pid: result.pid ?? null })}
 `,
@@ -25752,19 +25868,19 @@ function signalDriverLaunchConnected(result) {
 function printDriverDiagnosticLogTail(result) {
   if (!result.diagnosticLogPath) return;
   try {
-    const detail = import_node_fs17.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
+    const detail = import_node_fs18.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
     if (!detail) {
-      console.error(`  ${import_node_path19.default.basename(result.diagnosticLogPath)} was empty`);
+      console.error(`  ${import_node_path20.default.basename(result.diagnosticLogPath)} was empty`);
       return;
     }
     const shown = detail.length > 4e3 ? `\u2026
 ${detail.slice(-4e3)}` : detail;
-    console.error(`  ${import_node_path19.default.basename(result.diagnosticLogPath)}:`);
+    console.error(`  ${import_node_path20.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_path19.default.basename(result.diagnosticLogPath)}: ${message}`
+      `  failed to read ${import_node_path20.default.basename(result.diagnosticLogPath)}: ${message}`
     );
   }
 }
@@ -26575,16 +26691,16 @@ async function runCloseCommand(args, opts = {}) {
     bridge.close();
   }
 }
-var import_node_child_process7, import_node_fs17, import_node_os3, import_node_path19, 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;
+var import_node_child_process7, import_node_fs18, import_node_os3, import_node_path20, import_settings, import_ws4, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS;
 var init_control = __esm({
   "cli/commands/control.ts"() {
     "use strict";
     import_node_child_process7 = require("node:child_process");
-    import_node_fs17 = __toESM(require("node:fs"), 1);
+    import_node_fs18 = __toESM(require("node:fs"), 1);
     import_node_os3 = __toESM(require("node:os"), 1);
-    import_node_path19 = __toESM(require("node:path"), 1);
+    import_node_path20 = __toESM(require("node:path"), 1);
     import_settings = require("sootsim-engine/settings");
-    import_ws5 = require("ws");
+    import_ws4 = require("ws");
     init_dev_server_scanner();
     init_app_url();
     init_backend_origin();
@@ -27436,14 +27552,14 @@ var init_maestro_js = __esm({
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path20.dirname)((0, import_node_path20.resolve)(explicit));
+    return (0, import_node_path21.dirname)((0, import_node_path21.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path20.resolve)(explicit);
-  return (0, import_node_path20.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path21.resolve)(explicit);
+  return (0, import_node_path21.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -27490,26 +27606,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs18.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs19.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs18.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs19.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs18.rmSync)(filepath, { force: true });
+      (0, import_node_fs19.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs18.rmSync)(filepath, { force: true });
+    (0, import_node_fs19.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs18, import_node_path20, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs19, import_node_path21, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs18 = require("node:fs");
-    import_node_path20 = require("node:path");
+    import_node_fs19 = require("node:fs");
+    import_node_path21 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";