sootsim 0.0.4 → 0.1.36

package/dist-lib/vite-base.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.0.4 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.36 | (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;
@@ -62,6 +62,9 @@ function cacheDir() {
 function daemonLockfilePath() {
   return import_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
 }
+function configFilePath() {
+  return import_path.default.join(sootsimHomeDir(), CONFIG_FILE);
+}
 function ensureSootsimHome() {
   import_fs.default.mkdirSync(sootsimHomeDir(), { recursive: true });
   import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
@@ -169,7 +172,7 @@ function removeDaemonLockfile() {
   } catch {
   }
 }
-var import_fs, import_os, import_path, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES;
+var import_fs, import_os, import_path, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES;
 var init_home_paths = __esm({
   "src/home-paths.ts"() {
     "use strict";
@@ -179,11 +182,230 @@ var init_home_paths = __esm({
     SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
     ACTIVE_RUNTIME_FILE = "active";
     DAEMON_LOCKFILE = "daemon.json";
+    CONFIG_FILE = "config.json";
     DAEMON_HEARTBEAT_STALE_MS = 3e4;
     DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
   }
 });
 
+// src/runtime-delivery.ts
+function readConfig() {
+  try {
+    const parsed = JSON.parse(import_fs2.default.readFileSync(configFilePath(), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function resolveRuntimeCdnOrigin(input) {
+  const config = readConfig();
+  const value = input || process.env[RUNTIME_CDN_ORIGIN_ENV] || config.cdnOrigin || DEFAULT_RUNTIME_CDN_ORIGIN;
+  return value.replace(/\/+$/, "");
+}
+function resolveRuntimeChannel(input) {
+  const config = readConfig();
+  return input || process.env[RUNTIME_CHANNEL_ENV] || config.runtimeChannel || "stable";
+}
+function runtimeManifestUrl(cdnOrigin) {
+  const url = new URL(`${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/manifest.json`);
+  url.searchParams.set("t", String(Date.now()));
+  return url.toString();
+}
+function runtimeTarballUrl(version, cdnOrigin) {
+  return `${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/sootsim-runtime-${version}.tar.gz`;
+}
+async function fetchRuntimeManifest(cdnOrigin) {
+  const url = runtimeManifestUrl(cdnOrigin);
+  const res = await fetch(url, { headers: { Accept: "application/json" } });
+  if (!res.ok) {
+    throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`);
+  }
+  return await res.json();
+}
+function resolveRuntimeVersion(manifest, opts = {}) {
+  const channel = resolveRuntimeChannel(opts.channel);
+  const version = opts.version || manifest.channels[channel]?.latest;
+  if (!version) {
+    throw new Error(
+      `no version specified and channel '${channel}' has no latest entry in the manifest`
+    );
+  }
+  const entry = manifest.versions[version];
+  if (!entry) {
+    throw new Error(
+      `version ${version} not found in manifest; available: ${Object.keys(manifest.versions).slice(-10).join(", ") || "(none)"}`
+    );
+  }
+  return { version, channel, entry };
+}
+async function installRuntime(opts = {}) {
+  ensureSootsimHome();
+  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
+  const manifest = await fetchRuntimeManifest(cdnOrigin);
+  const { version, channel, entry } = resolveRuntimeVersion(manifest, opts);
+  const destDir = runtimeDir(version);
+  const setActive = opts.setActive !== false;
+  if (!opts.force && import_fs2.default.existsSync(import_path2.default.join(destDir, "index.html"))) {
+    if (setActive) writeActiveRuntime(version);
+    return {
+      version,
+      channel,
+      cdnOrigin,
+      runtimeDir: destDir,
+      installed: false,
+      activated: setActive,
+      manifest
+    };
+  }
+  const tarUrl = entry.tarball || runtimeTarballUrl(version, cdnOrigin);
+  const tarCachePath = import_path2.default.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`);
+  process.stderr.write(`sootsim: downloading runtime ${version}\u2026
+`);
+  await downloadToFile(tarUrl, tarCachePath);
+  process.stderr.write(`sootsim: extracting runtime ${version}\u2026
+`);
+  const actualSha = await sha256File(tarCachePath);
+  if (actualSha !== entry.sha256) {
+    import_fs2.default.rmSync(tarCachePath, { force: true });
+    throw new Error(
+      `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
+    );
+  }
+  const tmpDir = import_path2.default.join(import_path2.default.dirname(destDir), `.installing-${version}-${process.pid}`);
+  import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
+  import_fs2.default.mkdirSync(tmpDir, { recursive: true });
+  try {
+    await extractTarball(tarCachePath, tmpDir);
+    if (!import_fs2.default.existsSync(import_path2.default.join(tmpDir, "index.html"))) {
+      throw new Error(`extracted tarball for runtime ${version} is missing index.html`);
+    }
+    import_fs2.default.rmSync(destDir, { recursive: true, force: true });
+    import_fs2.default.renameSync(tmpDir, destDir);
+  } catch (err) {
+    import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
+    throw err;
+  }
+  if (setActive) writeActiveRuntime(version);
+  return {
+    version,
+    channel,
+    cdnOrigin,
+    runtimeDir: destDir,
+    installed: true,
+    activated: setActive,
+    manifest
+  };
+}
+async function updateRuntimeToLatest(opts = {}) {
+  ensureSootsimHome();
+  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
+  const channel = resolveRuntimeChannel(opts.channel);
+  const manifest = await fetchRuntimeManifest(cdnOrigin);
+  const latestVersion = manifest.channels[channel]?.latest;
+  if (!latestVersion) {
+    return {
+      checked: true,
+      updated: false,
+      reason: `channel '${channel}' has no latest runtime`,
+      activeVersion: readActiveRuntime()
+    };
+  }
+  const entry = manifest.versions[latestVersion];
+  if (!entry) {
+    return {
+      checked: true,
+      updated: false,
+      reason: `manifest is missing version ${latestVersion}`,
+      activeVersion: readActiveRuntime(),
+      latestVersion
+    };
+  }
+  const activeVersion = readActiveRuntime();
+  const activeDir = activeVersion ? runtimeDir(activeVersion) : null;
+  const activeInstalled = activeDir ? import_fs2.default.existsSync(import_path2.default.join(activeDir, "index.html")) : false;
+  const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
+  if (!shouldInstall) {
+    return {
+      checked: true,
+      updated: false,
+      reason: "active runtime is current",
+      activeVersion,
+      latestVersion
+    };
+  }
+  const install = await installRuntime({
+    version: latestVersion,
+    channel,
+    cdnOrigin,
+    setActive: false
+  });
+  return {
+    checked: true,
+    updated: true,
+    activeVersion: latestVersion,
+    latestVersion,
+    install
+  };
+}
+async function downloadToFile(url, destPath) {
+  const res = await fetch(url);
+  if (!res.ok || !res.body) {
+    throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
+  }
+  import_fs2.default.mkdirSync(import_path2.default.dirname(destPath), { recursive: true });
+  const tmp = `${destPath}.partial`;
+  try {
+    await (0, import_promises.pipeline)(
+      import_stream.Readable.fromWeb(res.body),
+      import_fs2.default.createWriteStream(tmp)
+    );
+    import_fs2.default.renameSync(tmp, destPath);
+  } catch (err) {
+    try {
+      import_fs2.default.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function sha256File(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = import_crypto.default.createHash("sha256");
+    const stream = import_fs2.default.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve2(hash.digest("hex")));
+  });
+}
+function extractTarball(tarPath, destDir) {
+  return new Promise((resolve2, reject) => {
+    const child = (0, import_child_process.spawn)("tar", ["-xzf", tarPath, "-C", destDir], {
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve2();
+      else reject(new Error(`tar exited with code ${code}`));
+    });
+  });
+}
+var import_child_process, import_crypto, import_fs2, import_path2, import_stream, import_promises, DEFAULT_RUNTIME_CDN_ORIGIN, RUNTIME_CDN_ORIGIN_ENV, RUNTIME_CHANNEL_ENV;
+var init_runtime_delivery = __esm({
+  "src/runtime-delivery.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_crypto = __toESM(require("crypto"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    import_path2 = __toESM(require("path"), 1);
+    import_stream = require("stream");
+    import_promises = require("stream/promises");
+    init_home_paths();
+    DEFAULT_RUNTIME_CDN_ORIGIN = "https://sootbean.com";
+    RUNTIME_CDN_ORIGIN_ENV = "SOOTSIM_CDN_ORIGIN";
+    RUNTIME_CHANNEL_ENV = "SOOTSIM_RUNTIME_CHANNEL";
+  }
+});
+
 // src/config.ts
 function hasOwnKeys(value) {
   return !!value && Object.keys(value).length > 0;
@@ -220,11 +442,13 @@ function normalizeNativeDevBundleUrl(bundleUrl) {
   try {
     const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
     const parsed = new URL(bundleUrl, "http://soot.local");
+    parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
     if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
     if (!parsed.searchParams.has("dev")) parsed.searchParams.set("dev", "true");
     if (!parsed.searchParams.has("minify")) {
       parsed.searchParams.set("minify", "false");
     }
+    parsed.searchParams.delete("transform.bytecode");
     if (isAbsolute) return parsed.toString();
     return `${parsed.pathname}${parsed.search}${parsed.hash}`;
   } catch {
@@ -637,10 +861,10 @@ function tcpPing(port, timeout = TCP_GATE_MS) {
     sock.connect(port, "localhost");
   });
 }
-function httpGet(port, path7, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(port, path8, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve2) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path7, method, timeout, headers },
+      { hostname: "localhost", port, path: path8, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -761,9 +985,9 @@ function applyManifest(result, manifestRes, buildIconProxyUrl) {
     if (client.name) result.projectName = client.name;
     if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
     if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
-    const launchUrl = manifest?.launchAsset?.url;
-    if (launchUrl && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
-      result.bundleUrl = withRuntimeConfig(result.port, launchUrl);
+    const launchUrl2 = manifest?.launchAsset?.url;
+    if (launchUrl2 && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
+      result.bundleUrl = withRuntimeConfig(result.port, launchUrl2);
     }
     const rawIconUrl = client.iconUrl || client.ios?.iconUrl || client.icon || client.ios?.icon;
     if (rawIconUrl) {
@@ -830,13 +1054,13 @@ async function probePort(port, buildIconProxyUrl) {
       const manifest = JSON.parse(manifestRes.body);
       const client = manifest?.extra?.expoClient || {};
       if (client.name) {
-        const launchUrl = manifest?.launchAsset?.url || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
+        const launchUrl2 = manifest?.launchAsset?.url || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
         knownNonPatched.add(port);
         return applyManifest(
           {
             port,
             framework: "one",
-            bundleUrl: withRuntimeConfig(port, launchUrl),
+            bundleUrl: withRuntimeConfig(port, launchUrl2),
             hmrUrl: `ws://localhost:${port}/hot`,
             lastSeen: Date.now()
           },
@@ -945,18 +1169,18 @@ async function scanDevServers(opts = {}) {
   }
   return results.filter((r) => !isSootSelfServer(r));
 }
-var import_child_process, import_http, import_net, import_util, execP, TIMEOUT_MS, TCP_GATE_MS, FALLBACK_PORTS, cwdByPid, knownNonPatched, knownNonExpo, portCache, NEGATIVE_CACHE_TTL_MS, WEAK_RESULT_CACHE_TTL_MS;
+var import_child_process2, import_http, import_net, import_util, execP, TIMEOUT_MS, TCP_GATE_MS, FALLBACK_PORTS, cwdByPid, knownNonPatched, knownNonExpo, portCache, NEGATIVE_CACHE_TTL_MS, WEAK_RESULT_CACHE_TTL_MS;
 var init_dev_server_scanner = __esm({
   "scripts/dev-server-scanner.ts"() {
     "use strict";
-    import_child_process = require("child_process");
+    import_child_process2 = require("child_process");
     import_http = __toESM(require("http"), 1);
     import_net = __toESM(require("net"), 1);
     import_util = require("util");
     init_config();
     init_native_dev_bundle_url();
     init_demo_app_registry();
-    execP = (0, import_util.promisify)(import_child_process.exec);
+    execP = (0, import_util.promisify)(import_child_process2.exec);
     TIMEOUT_MS = 250;
     TCP_GATE_MS = 120;
     FALLBACK_PORTS = [
@@ -1582,6 +1806,7 @@ async function startSession(opts) {
     ];
     if (opts.codexBin) wrapperArgs.push("--codex-bin", opts.codexBin);
     if (opts.claudeBin) wrapperArgs.push("--claude-bin", opts.claudeBin);
+    if (opts.freshThread) wrapperArgs.push("--fresh-thread");
     if (claudeSessionUuid) {
       wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
     }
@@ -2215,6 +2440,161 @@ var init_agent_host = __esm({
   }
 });
 
+// src/host/open-url.ts
+function expandHome(candidate) {
+  return candidate.startsWith("~/") ? (0, import_path3.join)((0, import_os2.homedir)(), candidate.slice(2)) : candidate;
+}
+function firstExisting(candidates) {
+  for (const candidate of candidates) {
+    const expanded = expandHome(candidate);
+    if ((0, import_fs3.existsSync)(expanded)) return expanded;
+  }
+  return null;
+}
+function lookupExecutable(command, platform) {
+  try {
+    const tool = platform === "win32" ? "where" : "which";
+    const out = (0, import_child_process3.execFileSync)(tool, [command], {
+      encoding: "utf8",
+      timeout: 1500,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out ? out.split(/\r?\n/)[0] : null;
+  } catch {
+    return null;
+  }
+}
+function resolveChromiumBinary(platform = process.platform) {
+  const envCandidate = process.env.CHROME_PATH || process.env.CHROMIUM_PATH;
+  if (envCandidate && (0, import_fs3.existsSync)(envCandidate)) return envCandidate;
+  const direct = platform === "darwin" ? firstExisting(MAC_CHROMIUM_CANDIDATES) : platform === "win32" ? firstExisting(WINDOWS_CHROMIUM_CANDIDATES) : firstExisting(LINUX_CHROMIUM_CANDIDATES);
+  if (direct) return direct;
+  const commands = platform === "win32" ? WINDOWS_CHROMIUM_COMMANDS : UNIX_CHROMIUM_COMMANDS;
+  for (const command of commands) {
+    const found = lookupExecutable(command, platform);
+    if (found) return found;
+  }
+  return null;
+}
+function buildOpenUrlCommand(url, options = {}) {
+  if (!url) throw new Error("openUrl requires a url");
+  const platform = options.platform ?? process.platform;
+  if (options.newWindow) {
+    return buildChromiumUrlCommand(url, { ...options, platform, newWindow: true });
+  }
+  if (platform === "darwin") {
+    return {
+      command: "open",
+      args: options.background === false ? [url] : ["-g", url],
+      via: "system"
+    };
+  }
+  if (platform === "win32") {
+    return {
+      command: "cmd",
+      args: ["/c", "start", "", url],
+      via: "system"
+    };
+  }
+  return {
+    command: "xdg-open",
+    args: [url],
+    via: "system"
+  };
+}
+function buildChromiumUrlCommand(url, options = {}) {
+  if (!url) throw new Error("openUrl requires a url");
+  const platform = options.platform ?? process.platform;
+  const chromiumBinary = "chromiumBinary" in options ? options.chromiumBinary : resolveChromiumBinary(platform);
+  if (!chromiumBinary) {
+    throw new Error("browser launch requires Chrome, Chromium, Edge, Brave, or Arc");
+  }
+  const args = [];
+  if (options.headless) {
+    args.push("--headless=new");
+  } else if (options.newWindow !== false) {
+    args.push("--new-window");
+  }
+  args.push(url);
+  return {
+    command: chromiumBinary,
+    args,
+    via: "chromium",
+    target: chromiumBinary
+  };
+}
+async function spawnLaunch(command, args, detached) {
+  return new Promise((resolve2, reject) => {
+    const child = (0, import_child_process3.spawn)(command, args, {
+      detached,
+      stdio: "ignore"
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      if (detached) child.unref();
+      resolve2(child.pid);
+    });
+  });
+}
+async function launchUrl(url, options = {}) {
+  const command = buildOpenUrlCommand(url, options);
+  const pid = await spawnLaunch(command.command, command.args, options.detached ?? true);
+  return {
+    ...command,
+    pid,
+    attachUrl: url
+  };
+}
+async function openUrl(url, options = {}) {
+  await launchUrl(url, options);
+}
+var import_child_process3, import_fs3, import_os2, import_path3, MAC_CHROMIUM_CANDIDATES, LINUX_CHROMIUM_CANDIDATES, WINDOWS_CHROMIUM_CANDIDATES, UNIX_CHROMIUM_COMMANDS, WINDOWS_CHROMIUM_COMMANDS;
+var init_open_url = __esm({
+  "src/host/open-url.ts"() {
+    "use strict";
+    import_child_process3 = require("child_process");
+    import_fs3 = require("fs");
+    import_os2 = require("os");
+    import_path3 = require("path");
+    MAC_CHROMIUM_CANDIDATES = [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "~/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "~/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      "~/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+      "/Applications/Arc.app/Contents/MacOS/Arc",
+      "~/Applications/Arc.app/Contents/MacOS/Arc"
+    ];
+    LINUX_CHROMIUM_CANDIDATES = [
+      "/usr/bin/google-chrome",
+      "/usr/bin/chromium",
+      "/usr/bin/chromium-browser",
+      "/usr/bin/microsoft-edge",
+      "/usr/bin/brave-browser",
+      "/snap/bin/chromium"
+    ];
+    WINDOWS_CHROMIUM_CANDIDATES = [
+      "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+      "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+      "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+      "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+      "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+      "C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+    ];
+    UNIX_CHROMIUM_COMMANDS = [
+      "google-chrome",
+      "chromium",
+      "chromium-browser",
+      "microsoft-edge",
+      "brave-browser"
+    ];
+    WINDOWS_CHROMIUM_COMMANDS = ["chrome", "msedge", "brave"];
+  }
+});
+
 // src/host/bridge-host.ts
 var bridge_host_exports = {};
 __export(bridge_host_exports, {
@@ -2226,20 +2606,24 @@ function shouldAcquireLease(msg) {
   if (msg.readOnly === true) return false;
   return WRITE_COMMAND_TYPES.has(msg.type);
 }
-var import_child_process2, import_fs2, import_http2, import_path2, import_ws, WRITE_COMMAND_TYPES, DAEMON_HEARTBEAT_INTERVAL_MS, HTTP_MIME_TYPES, SootSimBridgeHost;
+var import_child_process4, import_fs4, import_http2, import_path4, import_ws, WRITE_COMMAND_TYPES, 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";
-    import_child_process2 = require("child_process");
-    import_fs2 = __toESM(require("fs"), 1);
+    import_child_process4 = require("child_process");
+    import_fs4 = __toESM(require("fs"), 1);
     import_http2 = require("http");
-    import_path2 = __toESM(require("path"), 1);
+    import_path4 = __toESM(require("path"), 1);
     import_ws = require("ws");
     init_bridge_constants();
     init_home_paths();
+    init_runtime_delivery();
     init_agent_host();
+    init_open_url();
     WRITE_COMMAND_TYPES = /* @__PURE__ */ new Set(["tap", "keyboard", "close"]);
     DAEMON_HEARTBEAT_INTERVAL_MS = 5e3;
+    DEFAULT_RUNTIME_UPDATE_INTERVAL_MS = 60 * 60 * 1e3;
+    RUNTIME_UPDATE_INTERVAL_ENV = "SOOTSIM_RUNTIME_UPDATE_INTERVAL_MS";
     HTTP_MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".js": "application/javascript",
@@ -2285,6 +2669,10 @@ var init_bridge_host = __esm({
       static CLI_IDLE_TIMEOUT_MS = 6e4;
       static CLI_LEASE_TTL_MS = 6e5;
       static USER_ACTIVE_LEASE_TTL_MS = 8e3;
+      // explicit user actions (clicking Boot, focusing the tab to take it over)
+      // hold the tab longer than passive canvas interaction so reconnecting clis
+      // can't immediately reclaim while the user gets oriented.
+      static USER_BOOT_LEASE_TTL_MS = 6e4;
       static BROWSER_RECONNECT_TTL_MS = 3e4;
       preferredPort;
       portFallbackCount;
@@ -2292,14 +2680,15 @@ var init_bridge_host = __esm({
       effectivePort = 0;
       startedAt = 0;
       heartbeatTimer = null;
+      runtimeUpdateTimer = null;
+      runtimeUpdateInFlight = null;
       activeRuntimeVersion = null;
       activeRuntimeDirPath = null;
       constructor(opts = {}) {
         this.preferredPort = opts.port || DEFAULT_SOOTSIM_BRIDGE_PORT;
         this.port = this.preferredPort;
         this.shouldWriteLockfile = opts.writeLockfile === true;
-        const defaultFallback = this.shouldWriteLockfile ? 1 : 10;
-        this.portFallbackCount = Math.max(1, opts.portFallbackCount ?? defaultFallback);
+        this.portFallbackCount = Math.max(1, opts.portFallbackCount ?? 10);
         this.openUrlHandler = opts.openUrl;
         this.agentHost = new AgentHost({ getExcludePorts: opts.agentScanExcludes });
       }
@@ -2389,6 +2778,8 @@ var init_bridge_host = __esm({
           const origin = req.headers.origin;
           const role = origin ? "browser" : "cli";
           let browser = null;
+          ws.on("error", () => {
+          });
           this.agentHost.registerSocket(ws);
           if (role === "browser") {
             browser = {
@@ -2532,15 +2923,18 @@ var init_bridge_host = __esm({
                   }
                 }
                 const hadLease = !!browser.cliLease;
-                browser.cliLease = void 0;
-                if (booted.length > 0 || hadLease) {
-                  process.stderr.write(
-                    `sootsim booted ${booted.length} cli client(s)${hadLease ? " + cleared lease" : ""} from [${browser.id}]
+                browser.cliLease = {
+                  kind: "user-active",
+                  cliSessionKey: "__user-active__",
+                  cliLabel: "active user",
+                  expiresAt: Date.now() + _SootSimBridgeHost.USER_BOOT_LEASE_TTL_MS
+                };
+                process.stderr.write(
+                  `sootsim booted ${booted.length} cli client(s)${hadLease ? " (overrode prior lease)" : ""}; held tab for user [${browser.id}]
 `
-                  );
-                  this.recordBrowserAction(browser.id, "browser booted cli clients");
-                  this.broadcastBrowserClientStates();
-                }
+                );
+                this.recordBrowserAction(browser.id, "browser booted cli clients");
+                this.broadcastBrowserClientStates();
                 return;
               }
               const internalPending = this.pendingCommands.get(msg.id);
@@ -2613,7 +3007,7 @@ var init_bridge_host = __esm({
                   if (typeof msg.url !== "string" || !msg.url) {
                     throw new Error("bridge:open requires a url");
                   }
-                  await this.openUrl(msg.url);
+                  await this.openUrl(msg.url, { newWindow: msg.newWindow === true });
                   if (ws.readyState === import_ws.WebSocket.OPEN) {
                     ws.send(
                       JSON.stringify({
@@ -2777,9 +3171,11 @@ var init_bridge_host = __esm({
             }
           }, DAEMON_HEARTBEAT_INTERVAL_MS);
           this.heartbeatTimer.unref();
+          this.startRuntimeUpdater();
         }
         void this.agentHost.seedOnBoot();
       }
+      bootstrapping = true;
       buildLockfileSnapshot() {
         return {
           schema: 1,
@@ -2790,7 +3186,8 @@ var init_bridge_host = __esm({
           activeRuntime: this.activeRuntimeVersion,
           activeRuntimeDir: this.activeRuntimeDirPath,
           startedAt: this.startedAt,
-          heartbeatAt: Date.now()
+          heartbeatAt: Date.now(),
+          bootstrapping: this.bootstrapping
         };
       }
       writeLockfileSnapshot() {
@@ -2800,6 +3197,61 @@ var init_bridge_host = __esm({
         this.activeRuntimeVersion = readActiveRuntime();
         this.activeRuntimeDirPath = activeRuntimeDir();
       }
+      resolveRuntimeUpdateIntervalMs() {
+        const raw = Number(process.env[RUNTIME_UPDATE_INTERVAL_ENV]);
+        if (Number.isFinite(raw) && raw > 0) return Math.max(100, Math.round(raw));
+        return DEFAULT_RUNTIME_UPDATE_INTERVAL_MS;
+      }
+      startRuntimeUpdater() {
+        if (!this.shouldWriteLockfile || this.runtimeUpdateTimer) return;
+        void this.runRuntimeUpdate("startup");
+        const intervalMs = this.resolveRuntimeUpdateIntervalMs();
+        this.runtimeUpdateTimer = setInterval(() => {
+          void this.runRuntimeUpdate("periodic");
+        }, intervalMs);
+        this.runtimeUpdateTimer.unref();
+      }
+      runRuntimeUpdate(reason) {
+        if (this.runtimeUpdateInFlight) return this.runtimeUpdateInFlight;
+        this.runtimeUpdateInFlight = (async () => {
+          try {
+            if (reason === "startup") {
+              process.stderr.write("sootsim: checking for runtime updates\u2026\n");
+            }
+            const result = await updateRuntimeToLatest();
+            if (!result.updated || !result.latestVersion) {
+              if (reason === "startup") {
+                process.stderr.write(
+                  `sootsim: runtime ${this.activeRuntimeVersion ?? "(none)"} is current
+`
+                );
+              }
+              return;
+            }
+            const active = this.setActiveRuntime(result.latestVersion);
+            process.stderr.write(`sootsim runtime updated to ${active.version} (${reason})
+`);
+          } catch (err) {
+            process.stderr.write(
+              `sootsim runtime update failed (${reason}): ${err instanceof Error ? err.message : String(err)}
+`
+            );
+          } finally {
+            this.runtimeUpdateInFlight = null;
+            if (reason === "startup" && this.bootstrapping) {
+              this.bootstrapping = false;
+              if (this.shouldWriteLockfile && this.httpServer) {
+                try {
+                  this.writeLockfileSnapshot();
+                } catch {
+                }
+              }
+              process.stderr.write("sootsim: ready\n");
+            }
+          }
+        })();
+        return this.runtimeUpdateInFlight;
+      }
       /** update the active runtime on disk + in memory. the caller guarantees
        *  the version directory exists. pushes a runtime:changed message to all
        *  connected browsers so electron (or any renderer) can reload. */
@@ -2957,47 +3409,50 @@ var init_bridge_host = __esm({
             return;
           }
         }
-        const resolved = import_path2.default.resolve(baseDir, "." + rel);
-        const baseWithSep = baseDir.endsWith(import_path2.default.sep) ? baseDir : baseDir + import_path2.default.sep;
+        const resolved = import_path4.default.resolve(baseDir, "." + rel);
+        const baseWithSep = baseDir.endsWith(import_path4.default.sep) ? baseDir : baseDir + import_path4.default.sep;
         if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
           res.writeHead(403);
           res.end("forbidden");
           return;
         }
-        import_fs2.default.realpath(resolved, (realErr, realResolved) => {
+        import_fs4.default.realpath(resolved, (realErr, realResolved) => {
           const servePath = realErr ? resolved : realResolved;
-          const servePathWithSep = servePath.endsWith(import_path2.default.sep) ? servePath : servePath + import_path2.default.sep;
+          const servePathWithSep = servePath.endsWith(import_path4.default.sep) ? servePath : servePath + import_path4.default.sep;
           if (!realErr) {
             const realBaseWithSep = (() => {
               try {
-                const rb = import_fs2.default.realpathSync(baseDir);
-                return rb.endsWith(import_path2.default.sep) ? rb : rb + import_path2.default.sep;
+                const rb = import_fs4.default.realpathSync(baseDir);
+                return rb.endsWith(import_path4.default.sep) ? rb : rb + import_path4.default.sep;
               } catch {
                 return baseWithSep;
               }
             })();
-            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path2.default.sep !== realBaseWithSep) {
+            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path4.default.sep !== realBaseWithSep) {
               res.writeHead(403);
               res.end("forbidden");
               return;
             }
           }
-          import_fs2.default.stat(servePath, (err, stats) => {
+          import_fs4.default.stat(servePath, (err, stats) => {
             if (err || !stats?.isFile()) {
-              const ext2 = import_path2.default.extname(rel).toLowerCase();
+              const ext2 = import_path4.default.extname(rel).toLowerCase();
               if (ext2 && ext2 !== ".html") {
                 res.writeHead(404);
                 res.end("not found");
                 return;
               }
-              const indexPath = import_path2.default.join(baseDir, "index.html");
-              import_fs2.default.readFile(indexPath, (err2, data) => {
+              const indexPath = import_path4.default.join(baseDir, "index.html");
+              import_fs4.default.readFile(indexPath, (err2, data) => {
                 if (err2) {
                   res.writeHead(404);
                   res.end("not found");
                   return;
                 }
-                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.writeHead(200, {
+                  "Content-Type": "text/html; charset=utf-8",
+                  "Cache-Control": "no-store"
+                });
                 if (method === "HEAD") {
                   res.end();
                   return;
@@ -3006,14 +3461,17 @@ var init_bridge_host = __esm({
               });
               return;
             }
-            const ext = import_path2.default.extname(servePath).toLowerCase();
+            const ext = import_path4.default.extname(servePath).toLowerCase();
             const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
-            res.writeHead(200, { "Content-Type": contentType });
+            res.writeHead(200, {
+              "Content-Type": contentType,
+              "Cache-Control": "no-store"
+            });
             if (method === "HEAD") {
               res.end();
               return;
             }
-            const stream = import_fs2.default.createReadStream(servePath);
+            const stream = import_fs4.default.createReadStream(servePath);
             stream.pipe(res);
             stream.on("error", () => {
               try {
@@ -3096,7 +3554,7 @@ var init_bridge_host = __esm({
         const target = `${filePath}${loc}`;
         const trySpawn = (cmd, args) => new Promise((resolve2) => {
           try {
-            const child = (0, import_child_process2.spawn)(cmd, args, { detached: true, stdio: "ignore" });
+            const child = (0, import_child_process4.spawn)(cmd, args, { detached: true, stdio: "ignore" });
             let settled = false;
             child.on("error", () => {
               if (settled) return;
@@ -3123,26 +3581,12 @@ var init_bridge_host = __esm({
         if (await trySpawn("code", ["-g", target])) return;
         await this.openUrl(filePath);
       }
-      async openUrl(url) {
+      async openUrl(url, options = {}) {
         if (this.openUrlHandler) {
-          await this.openUrlHandler(url);
-          return;
-        }
-        if (process.platform === "darwin") {
-          const child2 = (0, import_child_process2.spawn)("open", ["-g", url], { detached: true, stdio: "ignore" });
-          child2.unref();
+          await this.openUrlHandler(url, options);
           return;
         }
-        if (process.platform === "win32") {
-          const child2 = (0, import_child_process2.spawn)("cmd", ["/c", "start", "", url], {
-            detached: true,
-            stdio: "ignore"
-          });
-          child2.unref();
-          return;
-        }
-        const child = (0, import_child_process2.spawn)("xdg-open", [url], { detached: true, stdio: "ignore" });
-        child.unref();
+        await openUrl(url, options);
       }
       async close() {
         if (this.cliIdleTimer) {
@@ -3153,6 +3597,10 @@ var init_bridge_host = __esm({
           clearInterval(this.heartbeatTimer);
           this.heartbeatTimer = null;
         }
+        if (this.runtimeUpdateTimer) {
+          clearInterval(this.runtimeUpdateTimer);
+          this.runtimeUpdateTimer = null;
+        }
         if (this.shouldWriteLockfile) {
           try {
             removeDaemonLockfile();
@@ -3289,11 +3737,14 @@ var init_bridge_host = __esm({
         if (existing && existing.kind === "cli") {
           return;
         }
+        const now = Date.now();
+        const refreshed = now + _SootSimBridgeHost.USER_ACTIVE_LEASE_TTL_MS;
+        const expiresAt = existing && existing.kind === "user-active" ? Math.max(existing.expiresAt, refreshed) : refreshed;
         browser.cliLease = {
           kind: "user-active",
           cliSessionKey: "__user-active__",
           cliLabel: "active user",
-          expiresAt: Date.now() + _SootSimBridgeHost.USER_ACTIVE_LEASE_TTL_MS
+          expiresAt
         };
         this.broadcastBrowserClientStates();
       }
@@ -3508,6 +3959,10 @@ var init_bridge_host = __esm({
           clearInterval(this.cliIdleTimer);
           this.cliIdleTimer = null;
         }
+        if (this.runtimeUpdateTimer) {
+          clearInterval(this.runtimeUpdateTimer);
+          this.runtimeUpdateTimer = null;
+        }
         const wss = this.wss;
         const httpServer = this.httpServer;
         this.wss = null;
@@ -3532,45 +3987,49 @@ var init_bridge_host = __esm({
 // src/vite-plugin.ts
 var vite_plugin_exports = {};
 __export(vite_plugin_exports, {
+  engineShellWorkerPlugins: () => engineShellWorkerPlugins,
   fixJsxRuntimeExports: () => fixJsxRuntimeExports,
+  keyboardControllerBindingsRedirect: () => keyboardControllerBindingsRedirect,
+  reanimatedNativeSeamRedirect: () => reanimatedNativeSeamRedirect,
   sootsim: () => sootsim,
   workerReactBridgePlugin: () => workerReactBridgePlugin,
+  workletsBabelTransform: () => workletsBabelTransform,
   wsBridgePlugin: () => wsBridgePlugin
 });
 module.exports = __toCommonJS(vite_plugin_exports);
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path3 = __toESM(require("path"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var import_url = require("url");
 var import_vite = require("vite");
 init_bridge_constants();
-var sootsimRoot = import_path3.default.resolve(import_path3.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url)), "..");
-var workspaceRoot = import_path3.default.resolve(sootsimRoot, "..", "..");
-var workspaceNodeModules = import_path3.default.resolve(workspaceRoot, "node_modules");
-var workspaceTamaguiDir = import_path3.default.resolve(workspaceNodeModules, "@tamagui");
-var engineRoot = import_path3.default.resolve(workspaceRoot, "packages/sootsim-engine");
-var rnShimPath = import_path3.default.resolve(engineRoot, "src/react-native/index.ts");
-var reactBridgePath = import_path3.default.resolve(engineRoot, "src/react-bridge.ts");
+var sootsimRoot = import_path5.default.resolve(import_path5.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url)), "..");
+var workspaceRoot = import_path5.default.resolve(sootsimRoot, "..", "..");
+var workspaceNodeModules = import_path5.default.resolve(workspaceRoot, "node_modules");
+var workspaceTamaguiDir = import_path5.default.resolve(workspaceNodeModules, "@tamagui");
+var engineRoot = import_path5.default.resolve(workspaceRoot, "packages/sootsim-engine");
+var rnShimPath = import_path5.default.resolve(engineRoot, "src/react-native/index.ts");
+var reactBridgePath = import_path5.default.resolve(engineRoot, "src/react-bridge.ts");
 var sootsimBrowserSourceAliases = [
   {
     find: "sootsim/backend-origin",
-    replacement: import_path3.default.resolve(sootsimRoot, "src/backend-origin.ts")
+    replacement: import_path5.default.resolve(sootsimRoot, "src/backend-origin.ts")
   },
   {
     find: "sootsim/bridge-constants",
-    replacement: import_path3.default.resolve(sootsimRoot, "src/bridge-constants.ts")
+    replacement: import_path5.default.resolve(sootsimRoot, "src/bridge-constants.ts")
   },
   {
     find: "sootsim/dev-bundle-resolution",
-    replacement: import_path3.default.resolve(sootsimRoot, "src/dev-bundle-resolution.ts")
+    replacement: import_path5.default.resolve(sootsimRoot, "src/dev-bundle-resolution.ts")
   }
 ];
-var compatRoot = import_path3.default.resolve(sootsimRoot, "..", "compat");
-var compatStubsDir = import_path3.default.resolve(compatRoot, "src/stubs");
-var nativeAutoStubPath = import_path3.default.resolve(compatStubsDir, "native-auto-stub.ts");
-var rnDeepStubDefault = import_path3.default.resolve(compatStubsDir, "react-native-internals.ts");
+var compatRoot = import_path5.default.resolve(sootsimRoot, "..", "compat");
+var compatStubsDir = import_path5.default.resolve(compatRoot, "src/stubs");
+var nativeAutoStubPath = import_path5.default.resolve(compatStubsDir, "native-auto-stub.ts");
+var rnDeepStubDefault = import_path5.default.resolve(compatStubsDir, "react-native-internals.ts");
 function getInternalTamaguiPackages() {
   try {
-    const scoped = import_fs3.default.readdirSync(workspaceTamaguiDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => `@tamagui/${entry.name}`);
+    const scoped = import_fs5.default.readdirSync(workspaceTamaguiDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => `@tamagui/${entry.name}`);
     return ["tamagui", ...scoped].sort();
   } catch {
     return ["tamagui"];
@@ -3578,19 +4037,19 @@ function getInternalTamaguiPackages() {
 }
 var internalTamaguiPackages = getInternalTamaguiPackages();
 var rnLibraryStubs = {
-  "react-native/Libraries/Pressability/usePressability": import_path3.default.resolve(
+  "react-native/Libraries/Pressability/usePressability": import_path5.default.resolve(
     compatStubsDir,
     "rn-libraries/usePressability.ts"
   ),
-  "react-native/Libraries/Pressability/Pressability": import_path3.default.resolve(
+  "react-native/Libraries/Pressability/Pressability": import_path5.default.resolve(
     compatStubsDir,
     "rn-libraries/Pressability.ts"
   ),
-  "react-native/Libraries/Renderer/shims/ReactFabric": import_path3.default.resolve(
+  "react-native/Libraries/Renderer/shims/ReactFabric": import_path5.default.resolve(
     compatStubsDir,
     "rn-libraries/ReactFabric.ts"
   ),
-  "react-native/Libraries/Renderer/shims/ReactNative": import_path3.default.resolve(
+  "react-native/Libraries/Renderer/shims/ReactNative": import_path5.default.resolve(
     compatStubsDir,
     "rn-libraries/ReactNative.ts"
   )
@@ -3601,11 +4060,18 @@ var builtinStubs = {
   "react-native-gesture-handler/ReanimatedSwipeable": "reanimated-swipeable.ts",
   // NOTE: 'soot-swipeable' is a real workspace package (packages/soot-swipeable),
   // resolved naturally by vite — no builtin stub entry needed.
-  "react-native-reanimated": "react-native-reanimated.ts",
+  // react-native-reanimated is mostly pure-JS; only the native seam (turbomodule
+  // + platform functions) is redirected. wired below as `reanimatedNativeSeamRedirect`.
   "react-native-screens": "react-native-screens.ts",
   "@react-native-masked-view/masked-view": "masked-view.ts",
   "react-native-svg": "react-native-svg.ts",
-  "react-native-keyboard-controller": "react-native-keyboard-controller.ts",
+  // react-native-keyboard-controller is mostly pure-JS — KeyboardAwareScrollView,
+  // KeyboardStickyView, hooks, animated module, and KeyboardAvoidingView all sit
+  // on top of reanimated worklets + scrollTo over a thin native-binding seam
+  // (`bindings.ts` / `bindings.native.ts`) plus RN's platform findNodeHandle.
+  // per the project policy of not shimming pure-JS libs, we let the package
+  // resolve from node_modules and redirect only those native/platform seams.
+  // wired below as `keyboardControllerBindingsRedirect`.
   "react-native-teleport": "react-native-teleport.tsx",
   "react-native-ios-context-menu": "react-native-ios-context-menu.ts",
   "react-native-ios-utilities": "react-native-ios-utilities.ts",
@@ -3625,8 +4091,18 @@ var builtinStubs = {
   "@callstack/react-native-bottom-tabs": "react-native-bottom-tabs.ts",
   "@expo/ui/swift-ui": "expo-ui.ts",
   "@expo/ui": "expo-ui.ts",
-  "react-native-worklets": "react-native-worklets.ts",
+  // worklets stub lives in a package-shaped directory (with package.json)
+  // so upstream code that does `require('react-native-worklets/package.json')`
+  // (e.g. reanimated's assertWorkletsVersion) can read a real version field.
+  "react-native-worklets": "react-native-worklets-pkg/index.ts",
+  "react-native-worklets/package.json": "react-native-worklets-pkg/package.json",
   "react-native-webview": "react-native-webview.ts",
+  // pager-view, video — bundle source paths reach codegenNativeCommands /
+  // requireNativeComponent from `react-native` deep imports that resolve to
+  // undefined, so the JS-only stubs MUST replace the package at build time.
+  "react-native-pager-view": "react-native-pager-view.ts",
+  "react-native-video": "react-native-video.ts",
+  "expo-video": "expo-video.ts",
   "expo-haptics": "expo-haptics.ts",
   "expo-crypto": "expo-crypto.ts",
   "expo-clipboard": "expo-clipboard.ts",
@@ -3675,14 +4151,14 @@ function isNativePackage(source) {
 }
 function moduleExistsIn(pkgName, dir) {
   try {
-    return import_fs3.default.existsSync(import_path3.default.join(dir, "node_modules", pkgName));
+    return import_fs5.default.existsSync(import_path5.default.join(dir, "node_modules", pkgName));
   } catch {
     return false;
   }
 }
 function sootsim(options = {}) {
-  const appDir = options.app ? import_path3.default.resolve(options.app) : "";
-  const extraSources = (options.sources || []).map((s) => import_path3.default.resolve(s));
+  const appDir = options.app ? import_path5.default.resolve(options.app) : "";
+  const extraSources = (options.sources || []).map((s) => import_path5.default.resolve(s));
   const ownedPackages = /* @__PURE__ */ new Set([...coreOwnedPackages, ...options.ownedPackages || []]);
   function isAppSource(filePath) {
     if (filePath.includes("/node_modules/")) return false;
@@ -3695,6 +4171,13 @@ function sootsim(options = {}) {
     sootsimConfigPlugin(appDir, extraSources),
     fixJsxRuntimeExports(),
     nodeModulesJsxTransform(),
+    // must run before metroNativeResolve — that plugin resolves relative
+    // imports like `./bindings` to absolute file paths via the platform-
+    // extension lookup, and once it returns a resolved id, downstream
+    // resolveId hooks don't see the source string anymore.
+    keyboardControllerBindingsRedirect(),
+    reanimatedNativeSeamRedirect(),
+    workletsBabelTransform(isAppSource),
     metroNativeResolve(isAppSource),
     reactNativeRequirePlugin(isAppSource),
     externalAppResolvePlugin(appDir, isAppSource, ownedPackages),
@@ -3703,6 +4186,129 @@ function sootsim(options = {}) {
     stubMissingImages(isAppSource)
   ];
 }
+function engineShellWorkerPlugins() {
+  return [
+    workerReactBridgePlugin(),
+    fixJsxRuntimeExports(),
+    reanimatedNativeSeamRedirect(),
+    keyboardControllerBindingsRedirect(),
+    workletsBabelTransform(() => true)
+  ];
+}
+function keyboardControllerBindingsRedirect() {
+  const target = import_path5.default.resolve(compatStubsDir, "react-native-keyboard-controller.ts");
+  const findNodeHandleTarget = "\0sootsim:rnkc-find-node-handle-native";
+  const nativePlatformBasenames = /* @__PURE__ */ new Set(["findNodeHandle", "reanimated"]);
+  const nativeExts = [
+    ".ios.tsx",
+    ".ios.ts",
+    ".ios.jsx",
+    ".ios.js",
+    ".native.tsx",
+    ".native.ts",
+    ".native.jsx",
+    ".native.js",
+    ".native.mjs"
+  ];
+  const resolveNativePlatformFile = (source, importer) => {
+    const base = import_path5.default.resolve(import_path5.default.dirname(importer), source);
+    for (const ext of nativeExts) {
+      const candidate = base + ext;
+      try {
+        if (import_fs5.default.existsSync(candidate)) return candidate;
+      } catch {
+      }
+    }
+    for (const ext of nativeExts) {
+      const candidate = import_path5.default.join(base, "index" + ext);
+      try {
+        if (import_fs5.default.existsSync(candidate)) return candidate;
+      } catch {
+      }
+    }
+    return null;
+  };
+  return {
+    name: "sootsim-keyboard-controller-bindings-redirect",
+    enforce: "pre",
+    resolveId(source, importer) {
+      if (!importer) return null;
+      if (!importer.includes("/react-native-keyboard-controller/")) return null;
+      const basename = source.split("/").pop() ?? "";
+      if (nativePlatformBasenames.has(basename)) {
+        return resolveNativePlatformFile(source, importer) ?? (basename === "findNodeHandle" ? findNodeHandleTarget : null);
+      }
+      if (basename !== "bindings" && basename !== "bindings.native") return null;
+      if (importer === target) return null;
+      return target;
+    },
+    load(id) {
+      if (id === findNodeHandleTarget) {
+        return `export { findNodeHandle } from ${JSON.stringify(rnShimPath)};`;
+      }
+      return null;
+    }
+  };
+}
+var reanimatedNativeSeamFiles = /* @__PURE__ */ new Set([
+  "NativeReanimatedModule",
+  "scrollTo",
+  "measure",
+  "setNativeProps",
+  "dispatchCommand",
+  "setGestureState"
+]);
+var reanimatedFabricUtilsRedirectPath = import_path5.default.resolve(
+  compatStubsDir,
+  "react-native-reanimated-fabric-utils.ts"
+);
+var reanimatedValidateWorkletsVersionPath = import_path5.default.resolve(
+  compatStubsDir,
+  "react-native-reanimated-validate-worklets-version.ts"
+);
+function reanimatedNativeSeamRedirect() {
+  const target = import_path5.default.resolve(compatStubsDir, "react-native-reanimated.ts");
+  return {
+    name: "sootsim-reanimated-native-seam-redirect",
+    enforce: "pre",
+    resolveId(source, importer) {
+      if (source === "react-native-worklets/package.json") {
+        return "\0sootsim:react-native-worklets-package-json";
+      }
+      if (!importer) return null;
+      if (source === "react-native-reanimated/scripts/validate-worklets-version" || source === "react-native-reanimated/scripts/validate-worklets-version.js") {
+        return reanimatedValidateWorkletsVersionPath;
+      }
+      if (!importer.includes("/react-native-reanimated/")) return null;
+      if (importer === target) return null;
+      const basename = (source.split("/").pop() ?? "").replace(
+        /\.(native|web|ios|android)$/,
+        ""
+      );
+      if (basename === "fabricUtils" && importer !== reanimatedFabricUtilsRedirectPath) {
+        return reanimatedFabricUtilsRedirectPath;
+      }
+      if (!reanimatedNativeSeamFiles.has(basename)) return null;
+      if (process.env.SOOTSIM_REANIMATED_REDIRECT_DEBUG) {
+        console.log(
+          "[reanimatedRedirect]",
+          basename,
+          "<-",
+          source,
+          "from",
+          importer.slice(-80)
+        );
+      }
+      return target;
+    },
+    load(id) {
+      if (id === "\0sootsim:react-native-worklets-package-json") {
+        return `export default ${JSON.stringify({ version: "0.0.0-sootsim", name: "react-native-worklets" })}`;
+      }
+      return null;
+    }
+  };
+}
 function wsBridgePlugin() {
   let bridgeHost = null;
   return {
@@ -3733,12 +4339,12 @@ function sootsimConfigPlugin(appDir, extraSources) {
       for (const src of extraSources) fsAllow.push(src);
       if (appDir) {
         fsAllow.push(appDir);
-        const appNodeModules = import_path3.default.join(appDir, "node_modules");
-        if (import_fs3.default.existsSync(appNodeModules)) fsAllow.push(appNodeModules);
+        const appNodeModules = import_path5.default.join(appDir, "node_modules");
+        if (import_fs5.default.existsSync(appNodeModules)) fsAllow.push(appNodeModules);
       }
       const stubAliases = Object.entries(builtinStubs).sort((a, b) => b[0].length - a[0].length).map(([find, file]) => ({
         find,
-        replacement: import_path3.default.resolve(compatStubsDir, file)
+        replacement: import_path5.default.resolve(compatStubsDir, file)
       }));
       const dedupe = ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"];
       if (!appDir) {
@@ -3920,10 +4526,10 @@ function workerReactBridgePlugin() {
     async resolveId(source, importer, options) {
       if (source !== "react" || !importer) return null;
       if (options?.scan || options?.ssr) return null;
-      const shouldRedirect = importer.includes("/sootsim/src/") || importer.includes("/sootsim-engine/src/") || importer.includes("/compat/src/") || importer.includes("react-reconciler");
-      if (!shouldRedirect) return null;
       if (importer.includes("react-bridge")) return null;
       if (importer.includes("stub-registry")) return null;
+      const shouldRedirect = importer.includes("/sootsim/src/") || importer.includes("/sootsim-engine/src/") || importer.includes("/compat/src/") || importer.includes("react-reconciler") || importer.includes("/node_modules/");
+      if (!shouldRedirect) return null;
       return { id: reactBridgePath, external: false };
     }
   };
@@ -3971,6 +4577,94 @@ function fixJsxRuntimeExports() {
     }
   };
 }
+var REANIMATED_AUTOWORKLETIZATION_KEYWORDS = [
+  "worklet",
+  "useAnimatedGestureHandler",
+  "useAnimatedScrollHandler",
+  "useFrameCallback",
+  "useAnimatedStyle",
+  "useAnimatedProps",
+  "createAnimatedPropAdapter",
+  "useDerivedValue",
+  "useAnimatedReaction",
+  "useWorkletCallback",
+  "withTiming",
+  "withSpring",
+  "withDecay",
+  "withRepeat",
+  "runOnUI",
+  "executeOnUIRuntimeSync"
+];
+var REANIMATED_REGEX = new RegExp(REANIMATED_AUTOWORKLETIZATION_KEYWORDS.join("|"));
+var REANIMATED_IGNORED_PATHS_REGEX = /node_modules\/(react|react-dom|react-native|react-native-web)\//;
+var SOOTSIM_ENGINE_SRC_PATH = "/packages/sootsim-engine/src/";
+var SOOTSIM_ENGINE_TEST_FIXTURE_PATH = "/packages/sootsim-engine/src/test-fixtures/";
+var REANIMATED_IMPORT_REGEX = /(?:from\s+['"]react-native-reanimated(?:\/[^'"]*)?['"]|require\(\s*['"]react-native-reanimated(?:\/[^'"]*)?['"]\s*\))/;
+function shouldApplyWorkletsPlugin(id, code) {
+  if (!/\.(tsx?|jsx?|mjs|cjs)$/.test(id)) return false;
+  if (REANIMATED_IGNORED_PATHS_REGEX.test(id)) return false;
+  if (id.includes(SOOTSIM_ENGINE_SRC_PATH) && !id.includes(SOOTSIM_ENGINE_TEST_FIXTURE_PATH) && !REANIMATED_IMPORT_REGEX.test(code))
+    return false;
+  return REANIMATED_REGEX.test(code);
+}
+function workletsBabelTransform(_isAppSource = () => false) {
+  let pluginPathPromise = null;
+  let babelCorePromise = null;
+  return {
+    name: "sootsim-worklets-babel-transform",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!shouldApplyWorkletsPlugin(id, code)) return null;
+      try {
+        if (process.env.SOOTSIM_WORKLETS_BABEL_DEBUG) {
+          console.log("[worklets-babel] transforming", id.slice(-80));
+        }
+        if (!babelCorePromise) {
+          babelCorePromise = import("@babel/core");
+        }
+        if (!pluginPathPromise) {
+          pluginPathPromise = (async () => {
+            const sootsimResolveBase = import_path5.default.resolve(workspaceRoot);
+            return import_path5.default.resolve(
+              sootsimResolveBase,
+              "node_modules",
+              "react-native-worklets",
+              "plugin"
+            );
+          })();
+        }
+        const [{ transformAsync }, pluginPath] = await Promise.all([
+          babelCorePromise,
+          pluginPathPromise
+        ]);
+        const isTSX = id.endsWith(".tsx");
+        const isTS = isTSX || id.endsWith(".ts");
+        const result = await transformAsync(code, {
+          filename: id,
+          babelrc: false,
+          configFile: false,
+          sourceMaps: true,
+          presets: isTS ? [
+            [
+              "@babel/preset-typescript",
+              { isTSX, allExtensions: isTSX, allowDeclareFields: true }
+            ]
+          ] : [],
+          plugins: [
+            ["@babel/plugin-syntax-jsx"],
+            [pluginPath, { processNestedWorklets: true }]
+          ]
+        });
+        if (!result?.code) return null;
+        return { code: result.code, map: result.map ?? null };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`[sootsim-worklets-babel] transform failed for ${id}: ${message}`);
+        return null;
+      }
+    }
+  };
+}
 function nodeModulesJsxTransform() {
   return {
     name: "sootsim-node-modules-jsx",
@@ -4008,14 +4702,14 @@ function metroNativeResolve(isAppSource) {
     for (const ext of platformExts) {
       const candidate = base + ext;
       try {
-        if (import_fs3.default.existsSync(candidate)) return candidate;
+        if (import_fs5.default.existsSync(candidate)) return candidate;
       } catch {
       }
     }
     for (const ext of platformExts) {
-      const candidate = import_path3.default.join(base, "index" + ext);
+      const candidate = import_path5.default.join(base, "index" + ext);
       try {
-        if (import_fs3.default.existsSync(candidate)) return candidate;
+        if (import_fs5.default.existsSync(candidate)) return candidate;
       } catch {
       }
     }
@@ -4030,9 +4724,9 @@ function metroNativeResolve(isAppSource) {
       if (!source.startsWith(".")) return null;
       if (platformExts.some((ext) => source.endsWith(ext))) return null;
       const hasBaseExt = allExts.some((ext) => source.endsWith(ext));
-      const dir = import_path3.default.dirname(importer);
+      const dir = import_path5.default.dirname(importer);
       if (hasBaseExt) {
-        const resolved = import_path3.default.resolve(dir, source);
+        const resolved = import_path5.default.resolve(dir, source);
         for (const ext of allExts) {
           if (source.endsWith(ext)) {
             const found = tryResolve(resolved.slice(0, -ext.length));
@@ -4041,7 +4735,7 @@ function metroNativeResolve(isAppSource) {
           }
         }
       } else {
-        const found = tryResolve(import_path3.default.resolve(dir, source));
+        const found = tryResolve(import_path5.default.resolve(dir, source));
         if (found) return found;
       }
       return null;
@@ -4098,7 +4792,7 @@ function reactNativeRequirePlugin(isAppSource) {
 }
 function externalAppResolvePlugin(appDir, isAppSource, ownedPackages) {
   if (!appDir) return { name: "sootsim-external-app-resolve" };
-  const appVirtualImporter = import_path3.default.join(appDir, "_virtual_.js");
+  const appVirtualImporter = import_path5.default.join(appDir, "_virtual_.js");
   return {
     name: "sootsim-external-app-resolve",
     enforce: "pre",
@@ -4108,7 +4802,7 @@ function externalAppResolvePlugin(appDir, isAppSource, ownedPackages) {
         return null;
       if (ownedPackages.has(source) || ownedPackages.has(getPackageName(source)))
         return null;
-      if (!isAppSource(importer) && !importer.includes(import_path3.default.join(appDir, "node_modules")))
+      if (!isAppSource(importer) && !importer.includes(import_path5.default.join(appDir, "node_modules")))
         return null;
       if (source === "react-native" || source.startsWith("react-native/")) return null;
       const resolved = await this.resolve(source, appVirtualImporter, {
@@ -4210,8 +4904,12 @@ function stubMissingImages(isAppSource) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  engineShellWorkerPlugins,
   fixJsxRuntimeExports,
+  keyboardControllerBindingsRedirect,
+  reanimatedNativeSeamRedirect,
   sootsim,
   workerReactBridgePlugin,
+  workletsBabelTransform,
   wsBridgePlugin
 });