sootsim 0.1.84 → 0.1.86

package/dist-lib/host/fetch-proxy-handler.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.84 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.86 | (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;
@@ -32,6 +32,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/host/fetch-proxy-handler.ts
 var fetch_proxy_handler_exports = {};
 __export(fetch_proxy_handler_exports, {
+  buildAppApiProxyHeaders: () => buildAppApiProxyHeaders,
   buildFetchProxyHeaders: () => buildFetchProxyHeaders,
   handleAppApiRequest: () => handleAppApiRequest,
   handleFetchProxyRequest: () => handleFetchProxyRequest,
@@ -97,6 +98,14 @@ var FETCH_PROXY_CORS_HEADERS = {
   "access-control-expose-headers": "*",
   "access-control-max-age": "3600"
 };
+var APP_API_HEADER_REWRITES = /* @__PURE__ */ new Set([
+  "host",
+  "origin",
+  "referer",
+  "sec-fetch-site",
+  "sec-fetch-mode",
+  "sec-fetch-dest"
+]);
 function applyFetchProxyCors(res) {
   for (const [key, value] of Object.entries(FETCH_PROXY_CORS_HEADERS)) {
     res.setHeader(key, value);
@@ -129,6 +138,18 @@ function buildFetchProxyHeaders(reqHeaders, targetUrl) {
   );
   return headers;
 }
+function buildAppApiProxyHeaders(reqHeaders, targetUrl) {
+  const headers = {};
+  for (const [key, value] of Object.entries(reqHeaders)) {
+    if (!value) continue;
+    if (APP_API_HEADER_REWRITES.has(key.toLowerCase())) continue;
+    headers[key] = value;
+  }
+  headers.host = targetUrl.host;
+  headers.origin = targetUrl.origin;
+  headers.referer = `${targetUrl.origin}/`;
+  return headers;
+}
 function isFetchProxyRequestUrl(rawUrl) {
   return rawUrl?.startsWith("/__fetch-proxy?") || rawUrl?.startsWith("/__proxy?") || false;
 }
@@ -239,9 +260,7 @@ function handleAppApiRequest(req, res) {
     return true;
   }
   const transport = targetUrl.protocol === "https:" ? import_https.default : import_http.default;
-  const fwdHeaders = { ...req.headers };
-  delete fwdHeaders.host;
-  fwdHeaders.host = targetUrl.host;
+  const fwdHeaders = buildAppApiProxyHeaders(req.headers, targetUrl);
   const proxyReq = transport.request(
     {
       hostname: targetUrl.hostname,
@@ -273,6 +292,7 @@ function handleAppApiRequest(req, res) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildAppApiProxyHeaders,
   buildFetchProxyHeaders,
   handleAppApiRequest,
   handleFetchProxyRequest,

package/dist-lib/host/fetch-proxy-overrides.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.84 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.86 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/host/fetch-proxy-overrides.mjs

@@ -0,0 +1,33 @@
+/*! sootsim v0.1.86 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+
+// src/host/fetch-proxy-overrides.ts
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    }
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override.headers;
+    }
+  }
+  return {};
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  return {
+    "accept-encoding": "identity",
+    "user-agent": FETCH_PROXY_BROWSER_USER_AGENT,
+    ...headerOverridesFor(targetUrl.hostname)
+  };
+}
+export {
+  FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders
+};

package/dist-lib/host/websocket-proxy.cjs

@@ -0,0 +1,207 @@
+/*! sootsim v0.1.86 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/host/websocket-proxy.ts
+var websocket_proxy_exports = {};
+__export(websocket_proxy_exports, {
+  WEBSOCKET_PROXY_PATH: () => WEBSOCKET_PROXY_PATH,
+  handleWebSocketProxyUpgrade: () => handleWebSocketProxyUpgrade,
+  isWebSocketProxyRequestUrl: () => isWebSocketProxyRequestUrl
+});
+module.exports = __toCommonJS(websocket_proxy_exports);
+var import_ws = require("ws");
+var WEBSOCKET_PROXY_PATH = "/__websocket-proxy";
+var STRIP_UPSTREAM_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "upgrade",
+  "transfer-encoding",
+  "content-length",
+  "sec-websocket-accept",
+  "sec-websocket-extensions",
+  "sec-websocket-key",
+  "sec-websocket-protocol",
+  "sec-websocket-version"
+]);
+function rejectUpgrade(socket, status, message) {
+  try {
+    socket.write(
+      `HTTP/1.1 ${status} ${message}\r
+Connection: close\r
+Content-Type: text/plain\r
+Content-Length: ${message.length}\r
+\r
+${message}`
+    );
+  } catch {
+  }
+  socket.destroy();
+}
+function isSameOriginUpgrade(req) {
+  const origin = req.headers.origin;
+  const host = req.headers.host;
+  if (!origin || !host) return false;
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}
+function decodeProxyHeaders(encoded) {
+  if (!encoded) return {};
+  const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const headers = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value == null) continue;
+    if (STRIP_UPSTREAM_HEADERS.has(key.toLowerCase())) continue;
+    headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return headers;
+}
+function getDefaultWebSocketOrigin(targetUrl) {
+  const origin = new URL(targetUrl.href);
+  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) {
+  const upstreamHeaders = { ...headers };
+  if (!Object.keys(upstreamHeaders).some((key) => key.toLowerCase() === "origin")) {
+    upstreamHeaders.origin = getDefaultWebSocketOrigin(targetUrl);
+  }
+  return new import_ws.WebSocket(targetUrl.href, protocols, {
+    headers: upstreamHeaders
+  });
+}
+function isWebSocketProxyRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  try {
+    return new URL(rawUrl, "http://localhost").pathname === WEBSOCKET_PROXY_PATH;
+  } catch {
+    return false;
+  }
+}
+function handleWebSocketProxyUpgrade(req, socket, head) {
+  if (!isWebSocketProxyRequestUrl(req.url)) return false;
+  if (!isSameOriginUpgrade(req)) {
+    rejectUpgrade(socket, 403, "forbidden websocket proxy origin");
+    return true;
+  }
+  let targetUrl;
+  let headers;
+  try {
+    const requestUrl = new URL(req.url || "/", "http://localhost");
+    const target = requestUrl.searchParams.get("url");
+    if (!target) {
+      rejectUpgrade(socket, 400, "missing websocket proxy url");
+      return true;
+    }
+    targetUrl = new URL(target);
+    if (targetUrl.protocol !== "ws:" && targetUrl.protocol !== "wss:") {
+      rejectUpgrade(socket, 400, "invalid websocket proxy protocol");
+      return true;
+    }
+    headers = decodeProxyHeaders(requestUrl.searchParams.get("headers"));
+  } catch {
+    rejectUpgrade(socket, 400, "invalid websocket proxy request");
+    return true;
+  }
+  const protocols = getRequestedProtocols(req);
+  const upstream = createUpstreamWebSocket(targetUrl, protocols, headers);
+  let completed = false;
+  socket.once("close", () => {
+    if (!completed) upstream.terminate();
+  });
+  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);
+    });
+  });
+  upstream.once("error", () => {
+    if (completed) return;
+    completed = true;
+    rejectUpgrade(socket, 502, "upstream websocket error");
+  });
+  upstream.once("close", () => {
+    if (completed) return;
+    completed = true;
+    rejectUpgrade(socket, 502, "upstream websocket closed");
+  });
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WEBSOCKET_PROXY_PATH,
+  handleWebSocketProxyUpgrade,
+  isWebSocketProxyRequestUrl
+});

package/dist-lib/index.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.84 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.86 | (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;
@@ -40,11 +40,45 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/vite-plugin-one.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/runtime-assets.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
-var sootsimRoot = import_path.default.resolve(import_path.default.dirname(new URL(__sootsim_import_meta_url).pathname), "..");
-var distDir = import_path.default.join(sootsimRoot, "dist-plugin");
-var publicDir = import_path.default.join(sootsimRoot, "public");
+
+// src/home-paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/runtime-assets.ts
+var SOOTSIM_RUNTIME_MISSING_MESSAGE = "[sootsim] no engine runtime installed \u2014 run `sootsim setup-repo` in your project, or `sootsim runtime install`";
 var MIME_TYPES = {
   ".js": "application/javascript",
   ".mjs": "application/javascript",
@@ -52,17 +86,64 @@ var MIME_TYPES = {
   ".html": "text/html",
   ".wasm": "application/wasm",
   ".json": "application/json",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
   ".png": "image/png",
   ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".glb": "model/gltf-binary",
   ".ttf": "font/ttf",
   ".otf": "font/otf",
   ".woff": "font/woff",
   ".woff2": "font/woff2",
   ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".jpg": "image/jpeg",
-  ".webp": "image/webp"
+  ".wav": "audio/wav"
 };
+var ROOT_RUNTIME_PATHS = [
+  "/assets/",
+  "/engine/",
+  "/engine-tenant/",
+  "/photos/",
+  "/three-mode/",
+  "/canvaskit.wasm",
+  "/fonts/",
+  "/icons/",
+  "/sounds/",
+  "/spike/",
+  "/test-wallpaper.jpg",
+  "/preview-sw.js"
+];
+function resolveActiveRuntimeRoot() {
+  const active = readActiveRuntime();
+  if (!active) return null;
+  const dir = runtimeDir(active);
+  if (!import_fs.default.existsSync(import_path.default.join(dir, "index.html"))) return null;
+  return dir;
+}
+function isRootRuntimeAssetPath(pathname) {
+  return ROOT_RUNTIME_PATHS.some((p) => pathname === p || pathname.startsWith(p));
+}
+function resolveRuntimeFilePath(runtimeRoot, pathname) {
+  if (!pathname.startsWith("/")) return null;
+  if (pathname.includes("\0") || pathname.includes("\\")) return null;
+  for (const segment of pathname.split("/")) {
+    if (segment === "..") return null;
+  }
+  const fullPath = import_path.default.resolve(runtimeRoot, pathname.replace(/^\/+/, ""));
+  const rootWithSep = runtimeRoot.endsWith(import_path.default.sep) ? runtimeRoot : runtimeRoot + import_path.default.sep;
+  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null;
+  if (!import_fs.default.existsSync(fullPath) || !import_fs.default.statSync(fullPath).isFile()) return null;
+  return fullPath;
+}
+function serveRuntimeFile(res, fullPath) {
+  const ext = import_path.default.extname(fullPath);
+  res.setHeader("content-type", MIME_TYPES[ext] || "application/octet-stream");
+  res.setHeader("cache-control", "max-age=31536000,immutable");
+  import_fs.default.createReadStream(fullPath).pipe(res);
+}
+
+// src/vite-plugin-one.ts
+var sootsimRoot = import_path2.default.resolve(import_path2.default.dirname(new URL(__sootsim_import_meta_url).pathname), "..");
 function sootsimPlugin(options = {}) {
   if (options.enabled === false) return [];
   const prefix2 = options.prefix || "/__soot";
@@ -89,14 +170,27 @@ function sootsimPlugin(options = {}) {
         });
         server.middlewares.use((req, res, next) => {
           const url = req.url || "";
-          if (url === prefix2 || url === prefix2 + "/" || url.startsWith(prefix2 + "/?")) {
-            const htmlPath = import_path.default.join(distDir, "index.html");
-            if (!import_fs.default.existsSync(htmlPath)) {
+          const pathname = url.split("?")[0];
+          const runtimeRoot = resolveActiveRuntimeRoot();
+          if (!runtimeRoot) {
+            if (pathname === prefix2 || pathname === prefix2 + "/" || pathname.startsWith(prefix2 + "/")) {
               res.statusCode = 500;
-              res.end("[sootsim] dist-plugin not built. run: bun scripts/build-plugin.ts");
+              res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE);
               return;
             }
-            let html = import_fs.default.readFileSync(htmlPath, "utf8");
+            next();
+            return;
+          }
+          if (isRootRuntimeAssetPath(pathname)) {
+            const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname);
+            if (fullPath) {
+              serveRuntimeFile(res, fullPath);
+              return;
+            }
+          }
+          if (pathname === prefix2 || pathname === prefix2 + "/") {
+            const htmlPath = import_path2.default.join(runtimeRoot, "index.html");
+            let html = import_fs2.default.readFileSync(htmlPath, "utf8");
             html = html.replace(
               "</head>",
               `<script>history.replaceState(null,'','${prefix2}/?bundle=${encodeURIComponent(bundleUrl)}')</script></head>`
@@ -105,31 +199,25 @@ function sootsimPlugin(options = {}) {
             res.end(html);
             return;
           }
-          if (url.startsWith(prefix2 + "/")) {
-            const filePath = url.slice(prefix2.length).split("?")[0];
-            const fullPath = import_path.default.join(distDir, filePath);
-            if (import_fs.default.existsSync(fullPath) && import_fs.default.statSync(fullPath).isFile()) {
-              const ext = import_path.default.extname(fullPath);
-              res.setHeader("content-type", MIME_TYPES[ext] || "application/octet-stream");
-              res.setHeader("cache-control", "max-age=31536000,immutable");
-              import_fs.default.createReadStream(fullPath).pipe(res);
-              return;
-            }
-            const publicPath = import_path.default.join(publicDir, filePath);
-            if (import_fs.default.existsSync(publicPath) && import_fs.default.statSync(publicPath).isFile()) {
-              const ext = import_path.default.extname(publicPath);
-              res.setHeader("content-type", MIME_TYPES[ext] || "application/octet-stream");
-              import_fs.default.createReadStream(publicPath).pipe(res);
+          if (pathname.startsWith(prefix2 + "/")) {
+            const fullPath = resolveRuntimeFilePath(
+              runtimeRoot,
+              pathname.slice(prefix2.length)
+            );
+            if (fullPath) {
+              serveRuntimeFile(res, fullPath);
               return;
             }
-          }
-          const staticRoots = ["/canvaskit.wasm", "/fonts/", "/icons/", "/sounds/"];
-          if (staticRoots.some((p) => url.startsWith(p))) {
-            const fullPath = import_path.default.join(publicDir, url.split("?")[0]);
-            if (import_fs.default.existsSync(fullPath) && import_fs.default.statSync(fullPath).isFile()) {
-              const ext = import_path.default.extname(fullPath);
-              res.setHeader("content-type", MIME_TYPES[ext] || "application/octet-stream");
-              import_fs.default.createReadStream(fullPath).pipe(res);
+            const ext = import_path2.default.extname(pathname);
+            if (!ext) {
+              const htmlPath = import_path2.default.join(runtimeRoot, "index.html");
+              let html = import_fs2.default.readFileSync(htmlPath, "utf8");
+              html = html.replace(
+                "</head>",
+                `<script>history.replaceState(null,'','${prefix2}/?bundle=${encodeURIComponent(bundleUrl)}')</script></head>`
+              );
+              res.setHeader("content-type", "text/html");
+              res.end(html);
               return;
             }
           }
@@ -138,7 +226,9 @@ function sootsimPlugin(options = {}) {
         const port = server.config.server.port || 8081;
         const sootsimUrl = `http://localhost:${port}${prefix2}/`;
         console.log(`[sootsim] serving at ${sootsimUrl}`);
-        openElectronApp(sootsimUrl);
+        if (options.open !== false) {
+          openElectronApp(sootsimUrl);
+        }
       }
     }
   ];
@@ -154,10 +244,10 @@ async function openElectronApp(sootsimUrl) {
   }
   const candidates = [
     "/Applications/sootsim.app",
-    import_path.default.join(process.env.HOME || "", "Applications/sootsim.app"),
-    import_path.default.join(sootsimRoot, "release/mac-arm64/sootsim.app")
+    import_path2.default.join(process.env.HOME || "", "Applications/sootsim.app"),
+    import_path2.default.join(sootsimRoot, "release/mac-arm64/sootsim.app")
   ];
-  let appPath = candidates.find((p) => import_fs.default.existsSync(p));
+  let appPath = candidates.find((p) => import_fs2.default.existsSync(p));
   if (!appPath) {
     try {
       const found = execSync(
@@ -177,95 +267,9 @@ async function openElectronApp(sootsimUrl) {
 }
 
 // src/metro-plugin.ts
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-
-// src/home-paths.ts
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_os = require("node:os");
-var import_node_path = __toESM(require("node:path"), 1);
-var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
-var ACTIVE_RUNTIME_FILE = "active";
-function sootsimHomeDir() {
-  const override = process.env[SOOTSIM_HOME_ENV];
-  if (override && override.length > 0) return import_node_path.default.resolve(override);
-  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
-}
-function runtimesDir() {
-  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
-}
-function runtimeDir(version) {
-  return import_node_path.default.join(runtimesDir(), version);
-}
-function activeRuntimeFile() {
-  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
-}
-function readActiveRuntime() {
-  try {
-    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
-    return value.length > 0 ? value : null;
-  } catch {
-    return null;
-  }
-}
-var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
-
-// src/metro-plugin.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
 var prefix = "/__soot";
-function resolveRuntimeRoot() {
-  const active = readActiveRuntime();
-  if (!active) return null;
-  const dir = runtimeDir(active);
-  if (!import_fs2.default.existsSync(import_path2.default.join(dir, "index.html"))) return null;
-  return dir;
-}
-var RUNTIME_MISSING_MESSAGE = "[sootsim] no engine runtime installed \u2014 run `sootsim setup-repo` in your project, or `sootsim runtime install`";
-var MIME_TYPES2 = {
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".html": "text/html",
-  ".wasm": "application/wasm",
-  ".json": "application/json",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".glb": "model/gltf-binary",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav"
-};
-var ROOT_RUNTIME_PATHS = [
-  "/assets/",
-  "/engine/",
-  "/engine-tenant/",
-  "/photos/",
-  "/three-mode/",
-  "/canvaskit.wasm",
-  "/fonts/",
-  "/icons/",
-  "/sounds/",
-  "/spike/",
-  "/test-wallpaper.jpg",
-  "/preview-sw.js"
-];
-function isRootRuntimeAssetPath(pathname) {
-  return ROOT_RUNTIME_PATHS.some((p) => pathname === p || pathname.startsWith(p));
-}
-function resolveRuntimeFilePath(runtimeRoot, pathname) {
-  if (!pathname.startsWith("/")) return null;
-  if (pathname.includes("\0") || pathname.includes("\\")) return null;
-  for (const segment of pathname.split("/")) {
-    if (segment === "..") return null;
-  }
-  const fullPath = import_path2.default.resolve(runtimeRoot, pathname.replace(/^\/+/, ""));
-  const rootWithSep = runtimeRoot.endsWith(import_path2.default.sep) ? runtimeRoot : runtimeRoot + import_path2.default.sep;
-  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null;
-  if (!import_fs2.default.existsSync(fullPath) || !import_fs2.default.statSync(fullPath).isFile()) return null;
-  return fullPath;
-}
 function withSootsim(config, options = {}) {
   if (options.enabled === false) return config;
   const bundleUrl = options.bundleUrl || "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
@@ -289,11 +293,11 @@ function withSootsim(config, options = {}) {
       server.use((req, res, next) => {
         const url = req.url || "";
         const pathname = url.split("?")[0];
-        const runtimeRoot = resolveRuntimeRoot();
+        const runtimeRoot = resolveActiveRuntimeRoot();
         if (!runtimeRoot) {
           if (pathname === prefix || pathname === prefix + "/") {
             res.statusCode = 500;
-            res.end(RUNTIME_MISSING_MESSAGE);
+            res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE);
             return;
           }
           next();
@@ -317,10 +321,10 @@ function withSootsim(config, options = {}) {
           }
         }
         if (pathname === prefix || pathname === prefix + "/" || pathname.startsWith(prefix + "/")) {
-          const ext = import_path2.default.extname(pathname);
+          const ext = import_path3.default.extname(pathname);
           if (!ext) {
-            const htmlPath = import_path2.default.join(runtimeRoot, "index.html");
-            let html = import_fs2.default.readFileSync(htmlPath, "utf8");
+            const htmlPath = import_path3.default.join(runtimeRoot, "index.html");
+            let html = import_fs3.default.readFileSync(htmlPath, "utf8");
             html = html.replace(
               "</head>",
               `<script>history.replaceState(null,'','${prefix}/?bundle=${encodeURIComponent(bundleUrl)}')</script></head>`
@@ -340,12 +344,6 @@ function withSootsim(config, options = {}) {
   return { ...config, server: serverConfig };
 }
 var metro_plugin_default = withSootsim;
-function serveRuntimeFile(res, fullPath) {
-  const ext = import_path2.default.extname(fullPath);
-  res.setHeader("content-type", MIME_TYPES2[ext] || "application/octet-stream");
-  res.setHeader("cache-control", "max-age=31536000,immutable");
-  import_fs2.default.createReadStream(fullPath).pipe(res);
-}
 
 // src/bridge-constants.ts
 var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;