sootsim 0.1.85 → 0.1.87

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.85 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.87 | (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;
@@ -10124,11 +10124,22 @@ var init_demo_app_registry = __esm({
         // be holding pglite locks on ~/takeout/.orez (soot can attach takeout as
         // a project and spin up its own orez against the same data dir).
         readyTimeoutMs: 24e4,
+        managedPorts: (p) => {
+          const offset = p - 8081;
+          return [5433 + offset, 4848 + offset, 9200 + offset];
+        },
         command: (p) => ({
-          cmd: "bun lite",
+          cmd: "bun lite:demo",
           env: {
+            TAKEOUT_ENV_MODE: "development",
             PORT_OFFSET: String(p - 8081),
-            OREZ_DATA_DIR: `${HOME}/.cache/sootsim-demo/takeout-orez`
+            OREZ_DATA_DIR: `${HOME}/.cache/sootsim-demo/takeout-orez`,
+            VITE_DEMO_MODE: "1",
+            ZERO_APP_ID: "takeout",
+            ZERO_APP_PUBLICATIONS: "zero_takeout",
+            ZERO_CVR_MAX_CONNS: "4",
+            ZERO_NUM_SYNC_WORKERS: "2",
+            ZERO_UPSTREAM_MAX_CONNS: "8"
           }
         })
       },
@@ -12440,6 +12451,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;
 }
@@ -12550,9 +12573,7 @@ function handleAppApiRequest(req, res) {
     return true;
   }
   const transport = targetUrl.protocol === "https:" ? import_https.default : import_http2.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,
@@ -12582,7 +12603,7 @@ function handleAppApiRequest(req, res) {
   req.pipe(proxyReq);
   return true;
 }
-var import_http2, import_https, STRIP_FETCH_PROXY_HEADERS, FETCH_PROXY_CORS_HEADERS;
+var import_http2, import_https, STRIP_FETCH_PROXY_HEADERS, FETCH_PROXY_CORS_HEADERS, APP_API_HEADER_REWRITES;
 var init_fetch_proxy_handler = __esm({
   "src/host/fetch-proxy-handler.ts"() {
     "use strict";
@@ -12615,6 +12636,14 @@ var init_fetch_proxy_handler = __esm({
       "access-control-expose-headers": "*",
       "access-control-max-age": "3600"
     };
+    APP_API_HEADER_REWRITES = /* @__PURE__ */ new Set([
+      "host",
+      "origin",
+      "referer",
+      "sec-fetch-site",
+      "sec-fetch-mode",
+      "sec-fetch-dest"
+    ]);
   }
 });
 
@@ -12771,6 +12800,186 @@ var init_open_url = __esm({
   }
 });
 
+// src/host/websocket-proxy.ts
+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;
+}
+var import_ws, WEBSOCKET_PROXY_PATH, STRIP_UPSTREAM_HEADERS;
+var init_websocket_proxy = __esm({
+  "src/host/websocket-proxy.ts"() {
+    "use strict";
+    import_ws = require("ws");
+    WEBSOCKET_PROXY_PATH = "/__websocket-proxy";
+    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"
+    ]);
+  }
+});
+
 // src/host/bridge-host.ts
 var bridge_host_exports = {};
 __export(bridge_host_exports, {
@@ -12804,7 +13013,7 @@ function unrefTimer(timer) {
     timer.unref();
   }
 }
-var import_child_process4, import_fs3, import_http3, import_path3, import_ws, 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, SootSimBridgeHost;
+var import_child_process4, import_fs3, import_http3, import_path3, import_ws2, 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, SootSimBridgeHost;
 var init_bridge_host = __esm({
   "src/host/bridge-host.ts"() {
     "use strict";
@@ -12812,7 +13021,7 @@ var init_bridge_host = __esm({
     import_fs3 = __toESM(require("fs"), 1);
     import_http3 = require("http");
     import_path3 = __toESM(require("path"), 1);
-    import_ws = require("ws");
+    import_ws2 = require("ws");
     init_dev_server_scanner();
     init_bridge_constants();
     init_cli_version();
@@ -12821,6 +13030,7 @@ var init_bridge_host = __esm({
     init_agent_host();
     init_fetch_proxy_handler();
     init_open_url();
+    init_websocket_proxy();
     WRITE_COMMAND_TYPES = /* @__PURE__ */ new Set(["tap", "keyboard"]);
     FORCE_CLOSE_GRACE_MS = 2e3;
     FORCE_CLOSE_TERMINATE_MS = 1e3;
@@ -13006,8 +13216,14 @@ var init_bridge_host = __esm({
 `);
             });
             this.httpServer = server;
-            this.wss = new import_ws.WebSocketServer({ server });
+            this.wss = new import_ws2.WebSocketServer({ noServer: true });
             this.wireWebSocketServer();
+            server.on("upgrade", (req, socket, head) => {
+              if (handleWebSocketProxyUpgrade(req, socket, head)) return;
+              this.wss?.handleUpgrade(req, socket, head, (ws) => {
+                this.wss?.emit("connection", ws, req);
+              });
+            });
             resolve7();
           });
         });
@@ -13171,7 +13387,7 @@ var init_bridge_host = __esm({
                   config: next
                 });
                 for (const peer of this.sims.values()) {
-                  if (peer.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+                  if (peer.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
                   try {
                     peer.ws.send(payload);
                   } catch {
@@ -13227,7 +13443,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_ws.WebSocket.OPEN) {
+                if (entry.ws.readyState === import_ws2.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));
@@ -13255,7 +13471,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_ws.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -13270,7 +13486,7 @@ var init_bridge_host = __esm({
                   return;
                 }
                 if (msg.type === "bridge:list-sims") {
-                  if (ws.readyState === import_ws.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -13285,7 +13501,7 @@ var init_bridge_host = __esm({
                     throw new Error("bridge:open requires a url");
                   }
                   await this.openUrl(msg.url, { newWindow: msg.newWindow === true });
-                  if (ws.readyState === import_ws.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -13301,7 +13517,7 @@ var init_bridge_host = __esm({
                     force: msg.force === true
                   });
                   if (!outcome.granted) {
-                    if (ws.readyState === import_ws.WebSocket.OPEN) {
+                    if (ws.readyState === import_ws2.WebSocket.OPEN) {
                       ws.send(
                         JSON.stringify({
                           id: msg.id,
@@ -13317,7 +13533,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_ws.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -13336,7 +13552,7 @@ var init_bridge_host = __esm({
                 if (shouldAcquireLease(msg)) {
                   const outcome = this.tryAcquireLease(ws, targetSim);
                   if (!outcome.granted) {
-                    if (ws.readyState === import_ws.WebSocket.OPEN) {
+                    if (ws.readyState === import_ws2.WebSocket.OPEN) {
                       ws.send(
                         JSON.stringify({
                           id: msg.id,
@@ -13362,7 +13578,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_ws.WebSocket.OPEN) {
+                  if (ws.readyState === import_ws2.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
                         id: msg.id,
@@ -13377,7 +13593,7 @@ var init_bridge_host = __esm({
                   unrefTimer(closeTimer);
                 }
               } catch (err) {
-                if (ws.readyState === import_ws.WebSocket.OPEN) {
+                if (ws.readyState === import_ws2.WebSocket.OPEN) {
                   ws.send(
                     JSON.stringify({
                       id: msg.id,
@@ -13402,7 +13618,7 @@ var init_bridge_host = __esm({
               }
               for (const [sentId, entry] of this.cliBySentId) {
                 if (entry.simId !== sim.id) continue;
-                if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
+                if (entry.ws.readyState === import_ws2.WebSocket.OPEN) {
                   entry.ws.send(
                     JSON.stringify({
                       id: entry.originalId,
@@ -13608,7 +13824,7 @@ var init_bridge_host = __esm({
           runtimeDir: this.activeRuntimeDirPath
         });
         for (const sim of this.sims.values()) {
-          if (sim.ws.readyState === import_ws.WebSocket.OPEN) {
+          if (sim.ws.readyState === import_ws2.WebSocket.OPEN) {
             try {
               sim.ws.send(payload);
             } catch {
@@ -13933,7 +14149,7 @@ var init_bridge_host = __esm({
       sweepDeadWebSockets() {
         if (!this.wss) return;
         for (const ws of this.wss.clients) {
-          if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          if (ws.readyState !== import_ws2.WebSocket.OPEN) continue;
           const alive = this.wsIsAlive.get(ws);
           if (alive === false) {
             try {
@@ -13954,7 +14170,7 @@ var init_bridge_host = __esm({
         }
       }
       closeSimSocketFromHost(ws) {
-        if (ws.readyState !== import_ws.WebSocket.OPEN) return;
+        if (ws.readyState !== import_ws2.WebSocket.OPEN) return;
         try {
           ws.close(SOOTSIM_BRIDGE_SIM_CLOSE_CODE, SOOTSIM_BRIDGE_SIM_CLOSE_REASON);
         } catch {
@@ -13965,7 +14181,7 @@ var init_bridge_host = __esm({
           return;
         }
         const terminateTimer = setTimeout(() => {
-          if (ws.readyState === import_ws.WebSocket.CLOSED) return;
+          if (ws.readyState === import_ws2.WebSocket.CLOSED) return;
           try {
             ws.terminate();
           } catch {
@@ -14114,7 +14330,7 @@ var init_bridge_host = __esm({
         try {
           readyState = sim.ws.readyState;
         } catch {
-          readyState = import_ws.WebSocket.CLOSED;
+          readyState = import_ws2.WebSocket.CLOSED;
         }
         const lease = this.getActiveLease(sim);
         return {
@@ -14127,7 +14343,7 @@ var init_bridge_host = __esm({
           lastSeenAt: sim.lastSeenAt,
           lastActiveAt: sim.lastActiveAt || void 0,
           isPrimary: sim.id === this.primarySimId,
-          readyState: readyState === import_ws.WebSocket.OPEN ? "open" : readyState === import_ws.WebSocket.CLOSING ? "closing" : "closed",
+          readyState: readyState === import_ws2.WebSocket.OPEN ? "open" : readyState === import_ws2.WebSocket.CLOSING ? "closing" : "closed",
           attachedCliCount: this.getAttachedCliCount(sim.id),
           lockedBy: lease ? lease.cliLabel || lease.cliIdentityKey : void 0,
           lockedByKind: lease ? lease.kind : void 0,
@@ -14244,18 +14460,18 @@ var init_bridge_host = __esm({
       getOpenSim(simId) {
         if (simId) {
           const sim = this.sims.get(simId);
-          if (sim?.ws.readyState === import_ws.WebSocket.OPEN) return sim;
+          if (sim?.ws.readyState === import_ws2.WebSocket.OPEN) return sim;
           return null;
         }
         const primary = this.primarySimId != null ? this.sims.get(this.primarySimId) : null;
-        if (primary?.ws.readyState === import_ws.WebSocket.OPEN && primary.url) return primary;
+        if (primary?.ws.readyState === import_ws2.WebSocket.OPEN && primary.url) return primary;
         let pagelessFallback = null;
         for (const sim of this.sims.values()) {
-          if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          if (sim.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
           if (sim.url) return sim;
           pagelessFallback ??= sim;
         }
-        if (primary?.ws.readyState === import_ws.WebSocket.OPEN) return primary;
+        if (primary?.ws.readyState === import_ws2.WebSocket.OPEN) return primary;
         return pagelessFallback;
       }
       async waitForSim(simId, options = {}) {
@@ -14271,7 +14487,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_ws.WebSocket.OPEN;
+        const currentAlive = current?.ws.readyState === import_ws2.WebSocket.OPEN;
         if (!current || !currentAlive || !current.url) return true;
         const isPrimaryCandidate = sim.origin?.includes(":5173");
         const currentIsPrimary = current.origin?.includes(":5173");
@@ -14279,7 +14495,7 @@ var init_bridge_host = __esm({
       }
       broadcastSimAssignments() {
         for (const sim of this.sims.values()) {
-          if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          if (sim.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
           sim.ws.send(
             JSON.stringify({
               type: "bridge:welcome",
@@ -14291,7 +14507,7 @@ var init_bridge_host = __esm({
       }
       broadcastSimClientStates() {
         for (const sim of this.sims.values()) {
-          if (sim.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+          if (sim.ws.readyState !== import_ws2.WebSocket.OPEN) continue;
           const lease = this.getActiveLease(sim);
           const message = {
             type: "bridge:client-state",
@@ -14356,7 +14572,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_ws.WebSocket.OPEN) continue;
+          if (ws.readyState !== import_ws2.WebSocket.OPEN) continue;
           const key = this.cliIdentityKeyBySocket.get(ws);
           keys.add(key ?? `ws-unknown-${keys.size}`);
         }
@@ -14369,7 +14585,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_ws.WebSocket.OPEN) continue;
+          if (ws.readyState !== import_ws2.WebSocket.OPEN) continue;
           const key = this.cliIdentityKeyBySocket.get(ws);
           if (key && key === selfKey) continue;
           keys.add(key ?? `ws-unknown-${keys.size}`);
@@ -14394,7 +14610,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_ws.WebSocket.OPEN) {
+        if (existing && existing !== sim && existing.ws.readyState === import_ws2.WebSocket.OPEN) {
           return false;
         }
         const restorable = this.getRestorableSimState(nextId);
@@ -14772,7 +14988,7 @@ function createBridge(wsPort, opts = {}) {
   let nextId = 1;
   const commandTimeoutMs = opts.commandTimeoutMs ?? 15e3;
   const pending = /* @__PURE__ */ new Map();
-  const ws = new import_ws2.WebSocket(`ws://localhost:${wsPort}`);
+  const ws = new import_ws3.WebSocket(`ws://localhost:${wsPort}`);
   const identity = opts.simId ? {
     key: `sim:${opts.simId}`,
     source: "explicit-sim-id",
@@ -14925,14 +15141,14 @@ function createBridge(wsPort, opts = {}) {
     },
     close() {
       try {
-        if (ws.readyState === import_ws2.WebSocket.OPEN) {
+        if (ws.readyState === import_ws3.WebSocket.OPEN) {
           ws.send(JSON.stringify({ type: "bridge:bye", id: 0 }));
         }
       } catch {
       }
       ws.close();
       const terminateTimer = setTimeout(() => {
-        if (ws.readyState !== import_ws2.WebSocket.CLOSED) {
+        if (ws.readyState !== import_ws3.WebSocket.CLOSED) {
           ws.terminate();
         }
       }, 250);
@@ -15002,11 +15218,11 @@ async function callInBridge(bridge, path9, ...args) {
 async function callInBridgeWrite(bridge, path9, ...args) {
   return bridge.send({ type: "call", path: path9, args, acquireLock: true });
 }
-var import_ws2, BridgeSimLockedError;
+var import_ws3, BridgeSimLockedError;
 var init_ws_bridge = __esm({
   "cli/ws-bridge.ts"() {
     "use strict";
-    import_ws2 = require("ws");
+    import_ws3 = require("ws");
     init_bridge_constants();
     init_home_paths();
     init_current_sim();
@@ -16806,25 +17022,15 @@ var init_bridge_flow_runner = __esm({
       }
       async startProfile() {
         await this.evaluate(`((sessionKey) => {
-      const host = window.__sootsimRenderHost
-      if (host?.startPerfSession) {
-        host.startPerfSession(sessionKey)
-        window[sessionKey] = {
-          active: true,
-          mode: 'render-worker',
-          startedAt: performance.now(),
-        }
-        return
-      }
-
       const perf = window.__sootsimPerf
       const a11y = window.__sootsimA11y
-      perf?.enableFrameStats?.()
+      perf?.enableFrameStats?.(true)
       perf?.resetFrameStats?.()
       a11y?.resetProfile?.()
       window[sessionKey] = {
         active: true,
-        mode: 'main-thread',
+        mode: window.__sootsimRenderHost ? 'render-worker' : 'main-thread',
+        lastSamples: [],
         startedAt: performance.now(),
       }
     })(${JSON.stringify(CLI_PERF_SESSION_GLOBAL)})`);
@@ -16833,13 +17039,24 @@ var init_bridge_flow_runner = __esm({
       async stopProfile() {
         const result = await this.evaluate(`(async (sessionKey) => {
       const host = window.__sootsimRenderHost
-      if (host?.stopPerfSession) {
-        const stopped = await host.stopPerfSession(sessionKey)
-        if (!stopped || !Array.isArray(stopped.samples)) {
-          return { error: 'no render-worker perf samples available' }
+      if (host?.flushSamples) {
+        const perf = window.__sootsimPerf
+        const session = window[sessionKey] || {}
+        const priorSamples = session.active && Array.isArray(session.lastSamples)
+          ? session.lastSamples
+          : []
+        const flushedSamples = await host.flushSamples()
+        await perf?.disableFrameStats?.()
+        const samples = priorSamples.concat(flushedSamples)
+        window[sessionKey] = {
+          ...session,
+          active: false,
+          mode: 'render-worker',
+          lastSamples: samples,
+          stoppedAt: performance.now(),
         }
-        const samples = stopped.samples
-        const frameTimes = samples.map((sample) => Number(sample?.[1]) || 0).filter((value) => value > 0)
+
+        const frameTimes = samples.map((sample) => Number(sample?.[1]) || 0)
         const sorted = [...frameTimes].sort((a, b) => a - b)
         const worstFrames = samples
           .slice()
@@ -16855,16 +17072,16 @@ var init_bridge_flow_runner = __esm({
 
         return {
           mode: 'render-worker',
-          frames: Number(stopped.frameCount) || frameTimes.length,
-          totalMs: Number(stopped.totalMs) || frameTimes.reduce((sum, value) => sum + value, 0),
-          avgMs: Number(stopped.avgMs) || (frameTimes.length ? frameTimes.reduce((sum, value) => sum + value, 0) / frameTimes.length : 0),
-          maxMs: Number(stopped.maxMs) || (sorted[sorted.length - 1] || 0),
-          layoutTotalMs: Number(stopped.layoutTotalMs) || samples.reduce((sum, sample) => sum + (Number(sample?.[2]) || 0), 0),
-          renderTotalMs: Number(stopped.renderTotalMs) || samples.reduce((sum, sample) => sum + (Number(sample?.[3]) || 0), 0),
-          copyTotalMs: Number(stopped.copyTotalMs) || samples.reduce((sum, sample) => sum + (Number(sample?.[4]) || 0), 0),
-          layoutAvgMs: Number(stopped.layoutAvgMs) || 0,
-          renderAvgMs: Number(stopped.renderAvgMs) || 0,
-          copyAvgMs: Number(stopped.copyAvgMs) || 0,
+          frames: frameTimes.length,
+          totalMs: frameTimes.reduce((sum, value) => sum + value, 0),
+          avgMs: frameTimes.length ? frameTimes.reduce((sum, value) => sum + value, 0) / frameTimes.length : 0,
+          maxMs: sorted[sorted.length - 1] || 0,
+          layoutTotalMs: samples.reduce((sum, sample) => sum + (Number(sample?.[2]) || 0), 0),
+          renderTotalMs: samples.reduce((sum, sample) => sum + (Number(sample?.[3]) || 0), 0),
+          copyTotalMs: samples.reduce((sum, sample) => sum + (Number(sample?.[4]) || 0), 0),
+          layoutAvgMs: frameTimes.length ? samples.reduce((sum, sample) => sum + (Number(sample?.[2]) || 0), 0) / frameTimes.length : 0,
+          renderAvgMs: frameTimes.length ? samples.reduce((sum, sample) => sum + (Number(sample?.[3]) || 0), 0) / frameTimes.length : 0,
+          copyAvgMs: frameTimes.length ? samples.reduce((sum, sample) => sum + (Number(sample?.[4]) || 0), 0) / frameTimes.length : 0,
           p50: sorted[Math.floor(sorted.length * 0.5)] || 0,
           p95: sorted[Math.floor(sorted.length * 0.95)] || 0,
           p99: sorted[Math.floor(sorted.length * 0.99)] || 0,
@@ -16878,11 +17095,11 @@ var init_bridge_flow_runner = __esm({
       const a11y = window.__sootsimA11y
       if (!perf && !a11y) return { error: 'no perf globals available' }
 
-      const frameStats = perf?.getFrameStats?.() || {}
+      const stoppedStats = await perf?.disableFrameStats?.()
+      const frameStats = stoppedStats || await perf?.getFrameStats?.() || {}
       const profile = a11y?.profile?.() || {}
       const recent = Array.isArray(frameStats.recentFrames) ? frameStats.recentFrames : []
       const sorted = [...recent].sort((a, b) => a - b)
-      perf?.disableFrameStats?.()
 
       return {
         mode: 'main-thread',

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.85 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.87 | (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;