rnxsim 0.1.427 → 0.1.429

package/dist-lib/host/bridge-host.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.427 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.429 | (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;
@@ -104,9 +104,9 @@ __export(bridge_host_exports, {
 module.exports = __toCommonJS(bridge_host_exports);
 var import_child_process3 = require("child_process");
 var import_fs2 = __toESM(require("fs"), 1);
-var import_http3 = require("http");
+var import_http4 = require("http");
 var import_path2 = __toESM(require("path"), 1);
-var import_ws2 = require("ws");
+var import_ws = require("ws");
 
 // scripts/dev-server-scanner.ts
 var import_child_process = require("child_process");
@@ -2054,23 +2054,47 @@ var RNX_RUNTIME_PRODUCT = {
 var rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
+// cli/self-invocation.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_node_url3 = require("node:url");
+
 // cli/standalone.ts
 var IS_STANDALONE = typeof __SOOTSIM_STANDALONE__ !== "undefined" && __SOOTSIM_STANDALONE__;
 
 // 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(path12) {
+  const name2 = (0, import_node_path7.basename)(path12);
+  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`);
   }
@@ -2118,8 +2142,8 @@ function encodeAgentPromptEnvelope(input) {
 
 // src/attached-projects.ts
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 var overrideDir = null;
 function userDataDir() {
   if (overrideDir) return overrideDir;
@@ -2131,7 +2155,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 {
@@ -2145,7 +2169,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;
@@ -2162,7 +2186,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}`
       );
@@ -2173,16 +2197,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();
@@ -2191,13 +2215,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) => {
@@ -2223,7 +2247,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],
@@ -2369,8 +2393,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();
@@ -2394,16 +2418,16 @@ async function seedFromDemoAppRegistry() {
 
 // 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;
@@ -2413,7 +2437,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;
 }
@@ -2426,11 +2450,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: [] };
       }
     }
   }
@@ -2449,15 +2473,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\`.`
@@ -2476,22 +2500,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;
   }
@@ -2507,28 +2531,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 {
@@ -2542,15 +2566,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 {
     }
   }
@@ -2564,25 +2588,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_process2.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -2629,10 +2653,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();
@@ -2683,7 +2707,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" });
@@ -2711,18 +2735,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,
@@ -2744,7 +2768,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 {
     }
   }
@@ -2752,11 +2776,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);
@@ -2767,7 +2791,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 {
@@ -2781,7 +2805,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;
@@ -2789,7 +2813,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;
@@ -2809,7 +2833,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs8.default.closeSync(fd);
+    import_node_fs9.default.closeSync(fd);
   }
 }
 
@@ -3087,7 +3111,7 @@ var AgentHost = class {
     );
     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,
@@ -3098,18 +3122,18 @@ var AgentHost = class {
   }
   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 ---
@@ -3812,8 +3836,8 @@ async function openUrl(url, options = {}) {
 }
 
 // src/host/plane-host.ts
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 
 // ../rnx-box/src/planeProtocol.ts
 var PLANE_FLAG_READ_ONLY = 1;
@@ -3893,8 +3917,8 @@ async function dispatchPlaneCommand(plane, type, msg, mutationOptions) {
 
 // cli/commands/box/checkout-plane.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs10 = __toESM(require("node:fs"), 1);
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 var CheckoutRequiresGitError = class extends Error {
 };
 var BINARY_SNIFF_BYTES = 8192;
@@ -3905,14 +3929,14 @@ 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 CheckoutFilePlane = class {
@@ -3925,7 +3949,7 @@ var CheckoutFilePlane = class {
   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;
   }
@@ -3987,13 +4011,13 @@ var CheckoutFilePlane = class {
       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,
@@ -4007,22 +4031,22 @@ var CheckoutFilePlane = class {
     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,
@@ -4031,7 +4055,7 @@ var CheckoutFilePlane = class {
     });
   }
   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);
   }
 };
@@ -4157,14 +4181,14 @@ var PlaneHost = class {
   // 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) {
@@ -4185,11 +4209,11 @@ var PlaneHost = class {
 
 // src/host/replacement-module-handler.ts
 var import_promises5 = __toESM(require("node:fs/promises"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var import_esbuild = require("esbuild");
 var REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
 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";
@@ -4271,7 +4295,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;
@@ -4279,10 +4303,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;
@@ -4298,8 +4322,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;
@@ -4386,8 +4410,13 @@ exports.jsxDEV = exports.jsx`,
 }
 
 // src/host/websocket-proxy.ts
-var import_ws = require("ws");
+var import_crypto = require("crypto");
+var import_http3 = require("http");
+var import_https2 = require("https");
 var WEBSOCKET_PROXY_PATH = "/__websocket-proxy";
+var WEBSOCKET_PROXY_HANDSHAKE_TIMEOUT_MS = 1e4;
+var WEBSOCKET_PROTOCOL_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var WEBSOCKET_KEY = /^[+/0-9A-Za-z]{22}==$/;
 var STRIP_UPSTREAM_HEADERS = /* @__PURE__ */ new Set([
   "host",
   "connection",
@@ -4400,20 +4429,62 @@ var STRIP_UPSTREAM_HEADERS = /* @__PURE__ */ new Set([
   "sec-websocket-protocol",
   "sec-websocket-version"
 ]);
-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;
@@ -4443,61 +4514,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;
@@ -4513,6 +4552,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 {
@@ -4532,37 +4581,94 @@ 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;
 }
 
@@ -4807,7 +4913,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   bindOnce(port, _silent) {
     return new Promise((resolve2, 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;
@@ -4830,7 +4936,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
 `);
         });
         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;
@@ -5068,7 +5174,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           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));
@@ -5096,7 +5202,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               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,
@@ -5111,7 +5217,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               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,
@@ -5127,7 +5233,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
                 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,
@@ -5143,7 +5249,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
                 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,
@@ -5162,7 +5268,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
             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,
@@ -5188,7 +5294,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
             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,
@@ -5203,7 +5309,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
               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,
@@ -5229,7 +5335,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
           }
           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,
@@ -5601,7 +5707,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
         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 {
@@ -5985,7 +6091,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   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 {
@@ -6006,7 +6112,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     }
   }
   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 {
@@ -6017,7 +6123,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       return;
     }
     const terminateTimer = setTimeout(() => {
-      if (ws.readyState === import_ws2.WebSocket.CLOSED) return;
+      if (ws.readyState === import_ws.WebSocket.CLOSED) return;
       try {
         ws.terminate();
       } catch {
@@ -6180,7 +6286,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     try {
       readyState = sim.ws.readyState;
     } catch {
-      readyState = import_ws2.WebSocket.CLOSED;
+      readyState = import_ws.WebSocket.CLOSED;
     }
     const lease = this.getActiveLease(sim);
     return {
@@ -6193,7 +6299,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       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,
@@ -6310,7 +6416,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   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();
@@ -6318,7 +6424,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   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;
@@ -6351,7 +6457,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   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");
@@ -6359,7 +6465,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   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",
@@ -6376,7 +6482,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
       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 {
@@ -6386,7 +6492,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   }
   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",
@@ -6457,7 +6563,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     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}`);
     }
@@ -6470,7 +6576,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     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}`);
@@ -6495,7 +6601,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     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);