sootsim 0.1.227 → 0.1.229

package/dist-lib/detox/index.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.227 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.229 | (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;
@@ -36,8 +36,8 @@ __export(detox_exports, {
   cleanup: () => cleanup,
   device: () => device,
   element: () => element,
-  expect: () => sootExpect,
-  waitFor: () => sootWaitFor
+  expect: () => sootsimExpect,
+  waitFor: () => sootsimWaitFor
 });
 module.exports = __toCommonJS(detox_exports);
 var fs = __toESM(require("fs"), 1);
@@ -46,7 +46,108 @@ var import_playwright = require("playwright");
 
 // ../../scripts/lib/reap-browser.ts
 var import_node_child_process = require("node:child_process");
+var discoveredChromePids = /* @__PURE__ */ new WeakMap();
+var reapPids = /* @__PURE__ */ new Set();
+var installed = false;
+function currentRuntime() {
+  return { platform: process.platform, env: process.env };
+}
+function softwareChromeAllowed(runtime = currentRuntime()) {
+  return runtime.platform === "linux" && runtime.env.GITHUB_ACTIONS === "true" && runtime.env.RUNNER_OS === "Linux";
+}
+function isSoftwareRendererArgument(value) {
+  const arg = String(value);
+  return /^--disable-gpu(?:=.*)?$/i.test(arg) || /^--enable-unsafe-swiftshader(?:=.*)?$/i.test(arg) || /^--use-angle=(?:swiftshader|swiftshader-webgl)$/i.test(arg) || /^--use-gl=swiftshader$/i.test(arg);
+}
+function softwareRendererArgumentInText(command) {
+  const unsafe = command.match(
+    /(?:^|\s)(--disable-gpu(?:=[^\s]+)?|--enable-unsafe-swiftshader(?:=[^\s]+)?|--use-angle=(?:swiftshader|swiftshader-webgl)|--use-gl=swiftshader)(?=\s|$)/i
+  );
+  return unsafe?.[1] ?? null;
+}
+function expectedAngle(platform) {
+  if (platform === "darwin") return "metal";
+  if (platform === "linux") return "vulkan";
+  return "default";
+}
+function assertGpuBrowserCommand(command, runtime = currentRuntime()) {
+  if (softwareChromeAllowed(runtime)) return;
+  const unsafe = softwareRendererArgumentInText(command);
+  if (unsafe) {
+    throw new Error(
+      `[reap-browser] refused software-rendering Chrome process argument ${unsafe}`
+    );
+  }
+  const angle = expectedAngle(runtime.platform);
+  const args = command.split(/\s+/);
+  if (!args.includes(`--use-angle=${angle}`) || !args.includes("--enable-gpu")) {
+    throw new Error(
+      `[reap-browser] Chrome process did not retain the required ${angle} GPU arguments`
+    );
+  }
+  if (runtime.platform === "darwin" && command.includes("/Applications/Google Chrome.app/")) {
+    throw new Error(
+      "[reap-browser] refused the user's installed Google Chrome; use Playwright channel chromium"
+    );
+  }
+}
+function collectGpuRendererStrings(info) {
+  if (!info || typeof info !== "object") return [];
+  const record = info;
+  const gpu = record.gpu;
+  if (!gpu || typeof gpu !== "object") return [];
+  const gpuRecord = gpu;
+  const values = [];
+  const aux = gpuRecord.auxAttributes;
+  if (aux && typeof aux === "object") {
+    for (const value of Object.values(aux)) {
+      if (typeof value === "string") values.push(value);
+    }
+  }
+  const devices = gpuRecord.devices;
+  if (Array.isArray(devices)) {
+    for (const device2 of devices) {
+      if (!device2 || typeof device2 !== "object") continue;
+      for (const value of Object.values(device2)) {
+        if (typeof value === "string") values.push(value);
+      }
+    }
+  }
+  return values;
+}
+function browserProcessPid(info) {
+  if (!info || typeof info !== "object") return null;
+  const record = info;
+  if (!Array.isArray(record.processInfo)) return null;
+  for (const entry of record.processInfo) {
+    if (!entry || typeof entry !== "object") continue;
+    const processInfo = entry;
+    if (processInfo.type === "browser" && typeof processInfo.id === "number" && Number.isInteger(processInfo.id) && processInfo.id > 0) {
+      return processInfo.id;
+    }
+  }
+  return null;
+}
+function assertGpuRendererInfo(info, runtime = currentRuntime()) {
+  if (softwareChromeAllowed(runtime)) return;
+  const renderers = collectGpuRendererStrings(info);
+  const summary = renderers.join(" | ");
+  if (!summary || /swiftshader|llvmpipe|software rasterizer/i.test(summary)) {
+    throw new Error(
+      `[reap-browser] Chrome reported a software renderer${summary ? `: ${summary}` : ""}`
+    );
+  }
+  if (runtime.platform === "darwin" && !/metal/i.test(summary)) {
+    throw new Error(
+      `[reap-browser] Chrome did not report an ANGLE Metal renderer: ${summary}`
+    );
+  }
+}
 function rootChromePid(b) {
+  if (b && typeof b === "object") {
+    const discovered = discoveredChromePids.get(b);
+    if (discovered !== void 0) return discovered;
+  }
   const w = b;
   if (w && typeof w.process === "function") {
     try {
@@ -76,8 +177,96 @@ function killTree(pid) {
   } catch {
   }
 }
-var reapPids = /* @__PURE__ */ new Set();
-var installed = false;
+function browserControl(b) {
+  const candidate = b;
+  if (!candidate || typeof candidate !== "object") return null;
+  if (typeof candidate.newBrowserCDPSession === "function" || typeof candidate.process === "function") {
+    return candidate;
+  }
+  if (typeof candidate.browser !== "function") return null;
+  try {
+    const browser = candidate.browser();
+    return browser ? browserControl(browser) : null;
+  } catch {
+    return null;
+  }
+}
+function registerChromePid(browser, control, pid) {
+  if (browser && typeof browser === "object") discoveredChromePids.set(browser, pid);
+  discoveredChromePids.set(control, pid);
+  reapPids.add(pid);
+  installReaper();
+}
+async function discoverChromePid(browser) {
+  const known = rootChromePid(browser);
+  if (known !== null) return known;
+  const control = browserControl(browser);
+  if (!control || typeof control.newBrowserCDPSession !== "function") return null;
+  const session = await control.newBrowserCDPSession();
+  try {
+    const pid = browserProcessPid(await session.send("SystemInfo.getProcessInfo"));
+    if (pid === null) return null;
+    registerChromePid(browser, control, pid);
+    return pid;
+  } finally {
+    await session.detach?.();
+  }
+}
+async function rejectLaunchedBrowser(browser) {
+  const root = rootChromePid(browser);
+  if (root !== null) {
+    reapPids.delete(root);
+    killTree(root);
+    return;
+  }
+  const candidate = browser;
+  if (candidate && typeof candidate.close === "function") {
+    try {
+      await candidate.close();
+    } catch {
+    }
+  }
+}
+async function validateLaunchedGpuBrowser(browser, runtime, rendererTarget) {
+  if (softwareChromeAllowed(runtime)) return;
+  const root = rootChromePid(browser);
+  const launchedControl = browserControl(browser);
+  if (root !== null && launchedControl) {
+    registerChromePid(browser, launchedControl, root);
+  }
+  if (root !== null && (runtime.platform === "darwin" || runtime.platform === "linux")) {
+    const command = (0, import_node_child_process.execFileSync)("ps", ["-p", String(root), "-o", "command="], {
+      encoding: "utf8"
+    }).trim();
+    assertGpuBrowserCommand(command, runtime);
+  }
+  const rendererBrowser = rendererTarget ? await rendererTarget(browser) : browser;
+  const control = browserControl(rendererBrowser);
+  if (control && typeof control.newBrowserCDPSession === "function") {
+    const session = await control.newBrowserCDPSession();
+    try {
+      const pid = browserProcessPid(await session.send("SystemInfo.getProcessInfo"));
+      if (pid === null) {
+        throw new Error("[reap-browser] Chrome did not report its browser process id");
+      }
+      registerChromePid(browser, control, pid);
+      if (rendererBrowser && typeof rendererBrowser === "object") {
+        discoveredChromePids.set(rendererBrowser, pid);
+      }
+      if (runtime.platform === "darwin" || runtime.platform === "linux") {
+        const command = (0, import_node_child_process.execFileSync)("ps", ["-p", String(pid), "-o", "command="], {
+          encoding: "utf8"
+        }).trim();
+        assertGpuBrowserCommand(command, runtime);
+      }
+      assertGpuRendererInfo(await session.send("SystemInfo.getInfo"), runtime);
+      return;
+    } finally {
+      await session.detach?.();
+    }
+  }
+  throw new Error("[reap-browser] could not validate the launched Chrome GPU renderer");
+}
 function installReaper() {
   if (installed) return;
   installed = true;
@@ -96,16 +285,24 @@ function installReaper() {
 }
 async function launchReapedScoped(launch) {
   const browser = await launch();
-  const root = rootChromePid(browser);
+  let root = rootChromePid(browser);
+  if (root === null) {
+    try {
+      root = await discoverChromePid(browser);
+    } catch {
+      root = null;
+    }
+  }
   const mine = /* @__PURE__ */ new Set();
   if (root != null) {
     mine.add(root);
     reapPids.add(root);
     installReaper();
   }
-  const evented = browser;
+  const evented = browserControl(browser) ?? browser;
   if (typeof evented.on === "function") {
-    evented.on("disconnected", () => {
+    const disconnectEvent = typeof evented.newBrowserCDPSession === "function" ? "disconnected" : "close";
+    evented.on(disconnectEvent, () => {
       for (const pid of mine) reapPids.delete(pid);
     });
   }
@@ -119,8 +316,8 @@ async function launchReapedScoped(launch) {
   return { browser, reapNow };
 }
 var gpuChromeMissing = false;
-function gpuChromeArgs() {
-  const angle = process.platform === "darwin" ? "metal" : process.platform === "linux" ? "vulkan" : "default";
+function gpuChromeArgs(platform = process.platform) {
+  const angle = expectedAngle(platform);
   return [
     `--use-angle=${angle}`,
     "--enable-gpu",
@@ -129,9 +326,38 @@ function gpuChromeArgs() {
     "--ignore-gpu-blocklist"
   ];
 }
-function gpuChromeLaunchOptions(opts = {}) {
+function gpuChromeLaunchOptions(opts = {}, runtime = currentRuntime()) {
   const callerArgs = Array.isArray(opts.args) ? opts.args : [];
+  const unsafe = callerArgs.find(isSoftwareRendererArgument);
+  if (unsafe !== void 0) {
+    throw new Error(
+      `[reap-browser] refused software-rendering Chrome launch argument ${String(unsafe)}`
+    );
+  }
+  if (opts.executablePath !== void 0) {
+    throw new Error(
+      "[reap-browser] executablePath bypasses Playwright Chrome for Testing and is not allowed"
+    );
+  }
+  if (opts.ignoreDefaultArgs === true) {
+    throw new Error(
+      "[reap-browser] ignoreDefaultArgs=true bypasses required Chrome launch defaults"
+    );
+  }
+  const managedGpuArgs = /* @__PURE__ */ new Set([
+    "--enable-gpu",
+    "--enable-gpu-rasterization",
+    "--enable-zero-copy",
+    "--ignore-gpu-blocklist"
+  ]);
+  const unmanagedCallerArgs = callerArgs.filter((arg) => {
+    const value = String(arg);
+    return !managedGpuArgs.has(value) && !value.startsWith("--use-angle=");
+  });
   const callerIgnored = Array.isArray(opts.ignoreDefaultArgs) ? opts.ignoreDefaultArgs : [];
+  const ignoredDefaults = [
+    .../* @__PURE__ */ new Set([...callerIgnored, "--disable-gpu", "--enable-unsafe-swiftshader"])
+  ];
   return {
     ...opts,
     // playwright's `chromium` channel is the full Google Chrome for Testing
@@ -139,22 +365,19 @@ function gpuChromeLaunchOptions(opts = {}) {
     // com.google.chrome.for.testing, so automation cannot become the target of
     // Dock open/quit events intended for the user's com.google.Chrome browser.
     channel: "chromium",
-    args: [...gpuChromeArgs(), ...callerArgs],
-    ignoreDefaultArgs: [...callerIgnored, "--enable-unsafe-swiftshader"]
+    args: [...unmanagedCallerArgs, ...gpuChromeArgs(runtime.platform)],
+    ignoreDefaultArgs: ignoredDefaults
   };
 }
-function preferGpuChrome(launch, opts) {
+function preferGpuChrome(launch, opts, rendererTarget) {
   return async () => {
-    const allowSoftwareFallback = process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true";
+    const runtime = currentRuntime();
+    const allowSoftwareFallback = softwareChromeAllowed(runtime);
+    const gpuOptions = gpuChromeLaunchOptions(opts, runtime);
     if (!gpuChromeMissing) {
+      let browser;
       try {
-        const callerArgs = Array.isArray(opts.args) ? opts.args : [];
-        if (!allowSoftwareFallback && callerArgs.some(
-          (arg) => arg === "--enable-unsafe-swiftshader" || /^--use-angle=(?:swiftshader|swiftshader-webgl)$/i.test(String(arg))
-        )) {
-          throw new Error("[reap-browser] refused local SwiftShader launch arguments");
-        }
-        return await launch(gpuChromeLaunchOptions(opts));
+        browser = await launch(gpuOptions);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         const missing = /not found at|not installed|Chromium distribution|Executable doesn't exist|No such file/i.test(
@@ -169,15 +392,29 @@ function preferGpuChrome(launch, opts) {
         }
         gpuChromeMissing = true;
         console.warn(
-          "[reap-browser] CI Chrome for Testing not found, falling back to chromium_headless_shell software rendering."
+          "[reap-browser] GitHub Actions Linux Chrome for Testing not found, falling back to chromium_headless_shell software rendering."
         );
+        return launch(softwareFallbackChromeLaunchOptions(opts));
       }
+      try {
+        await validateLaunchedGpuBrowser(browser, runtime, rendererTarget);
+      } catch (err) {
+        await rejectLaunchedBrowser(browser);
+        throw err;
+      }
+      return browser;
     }
-    return launch(opts);
+    return launch(softwareFallbackChromeLaunchOptions(opts));
   };
 }
-async function launchReapedChromeScoped(launch, opts = {}) {
-  return launchReapedScoped(preferGpuChrome(launch, opts));
+function softwareFallbackChromeLaunchOptions(opts) {
+  const fallback = { ...opts };
+  delete fallback.channel;
+  delete fallback.executablePath;
+  return fallback;
+}
+async function launchReapedChromeScoped(launch, opts = {}, rendererTarget) {
+  return launchReapedScoped(preferGpuChrome(launch, opts, rendererTarget));
 }
 
 // detox/gestures.ts
@@ -324,36 +561,36 @@ async function readSootsimPageMetrics(page) {
 async function readSootsimInteractiveViewport(page) {
   return (await readSootsimPageMetrics(page)).interactiveWindow;
 }
-async function sootsimToPage(page, sootX, sootY) {
+async function sootsimToPage(page, sootsimX, sootsimY) {
   const metrics = await readSootsimPageMetrics(page);
   const scaleX = metrics.canvas.width / metrics.window.width;
   const scaleY = metrics.canvas.height / metrics.window.height;
   return {
-    x: metrics.canvas.left + sootX * scaleX,
-    y: metrics.canvas.top + sootY * scaleY
+    x: metrics.canvas.left + sootsimX * scaleX,
+    y: metrics.canvas.top + sootsimY * scaleY
   };
 }
 async function dragScrollNode(page, node, pixels, direction) {
-  const startSootX = node.absolutePosition.x + node.layout.width / 2;
-  const startSootY = node.absolutePosition.y + node.layout.height / 2;
-  let endSootX = startSootX;
-  let endSootY = startSootY;
+  const startSootSimX = node.absolutePosition.x + node.layout.width / 2;
+  const startSootSimY = node.absolutePosition.y + node.layout.height / 2;
+  let endSootSimX = startSootSimX;
+  let endSootSimY = startSootSimY;
   switch (direction) {
     case "down":
-      endSootY -= pixels;
+      endSootSimY -= pixels;
       break;
     case "up":
-      endSootY += pixels;
+      endSootSimY += pixels;
       break;
     case "left":
-      endSootX += pixels;
+      endSootSimX += pixels;
       break;
     case "right":
-      endSootX -= pixels;
+      endSootSimX -= pixels;
       break;
   }
-  const startPage = await sootsimToPage(page, startSootX, startSootY);
-  const endPage = await sootsimToPage(page, endSootX, endSootY);
+  const startPage = await sootsimToPage(page, startSootSimX, startSootSimY);
+  const endPage = await sootsimToPage(page, endSootSimX, endSootSimY);
   const steps = Math.max(16, Math.ceil(pixels / 8));
   await page.mouse.move(startPage.x, startPage.y);
   await page.mouse.down();
@@ -519,11 +756,11 @@ function describeNodeVisibility(node, viewport) {
   });
 }
 function createExpect(findNode, getPage2) {
-  return function sootExpect2(el) {
-    return new SootExpectation(el._matcher, findNode, getPage2, false);
+  return function sootsimExpect2(el) {
+    return new SootSimExpectation(el._matcher, findNode, getPage2, false);
   };
 }
-var SootExpectation = class _SootExpectation {
+var SootSimExpectation = class _SootSimExpectation {
   matcher;
   findNode;
   getPage;
@@ -535,7 +772,12 @@ var SootExpectation = class _SootExpectation {
     this.negated = negated;
   }
   get not() {
-    return new _SootExpectation(this.matcher, this.findNode, this.getPage, !this.negated);
+    return new _SootSimExpectation(
+      this.matcher,
+      this.findNode,
+      this.getPage,
+      !this.negated
+    );
   }
   async toExist() {
     const node = await this.findNode(this.matcher);
@@ -700,11 +942,11 @@ var SootExpectation = class _SootExpectation {
   }
 };
 function createWaitFor(findNode, getPage2) {
-  return function sootWaitFor2(el) {
-    return new SootWaitForChain(el._matcher, findNode, getPage2);
+  return function sootsimWaitFor2(el) {
+    return new SootSimWaitForChain(el._matcher, findNode, getPage2);
   };
 }
-var SootWaitForChain = class {
+var SootSimWaitForChain = class {
   matcher;
   findNode;
   getPage;
@@ -727,7 +969,7 @@ var SootWaitForChain = class {
         throw new Error(`waitFor toExist failed: ${JSON.stringify(this.matcher)}`);
       }
     };
-    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
   }
   toBeVisible() {
     this.assertionFn = async () => {
@@ -741,7 +983,7 @@ var SootWaitForChain = class {
         );
       }
     };
-    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
   }
   toBeNotVisible() {
     this.assertionFn = async () => {
@@ -751,7 +993,7 @@ var SootWaitForChain = class {
         throw new Error(`waitFor toBeNotVisible failed: ${JSON.stringify(this.matcher)}`);
       }
     };
-    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
   }
   toHaveText(expectedText) {
     this.assertionFn = async () => {
@@ -768,7 +1010,7 @@ var SootWaitForChain = class {
         );
       }
     };
-    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
   }
   toHaveValue(value) {
     this.assertionFn = async () => {
@@ -779,10 +1021,10 @@ var SootWaitForChain = class {
         throw new Error(`waitFor toHaveValue: expected "${value}" in "${actual}"`);
       }
     };
-    return new SootWaitForAction(this.assertionFn, this.findNode, this.getPage);
+    return new SootSimWaitForAction(this.assertionFn, this.findNode, this.getPage);
   }
 };
-var SootWaitForAction = class {
+var SootSimWaitForAction = class {
   assertionFn;
   findNode;
   getPage;
@@ -816,7 +1058,7 @@ var SootWaitForAction = class {
     }
   }
   whileElement(matcher) {
-    return new SootWaitForScrollAction(
+    return new SootSimWaitForScrollAction(
       this.assertionFn,
       this.findNode,
       this.getPage,
@@ -824,7 +1066,7 @@ var SootWaitForAction = class {
     );
   }
 };
-var SootWaitForScrollAction = class {
+var SootSimWaitForScrollAction = class {
   assertionFn;
   findNode;
   getPage;
@@ -1385,7 +1627,7 @@ async function dispatchSootsimEventInPage(type, detail) {
     { detail, type }
   );
 }
-function createSootElement(matcher) {
+function createSootSimElement(matcher) {
   const el = {
     _matcher: matcher,
     async tap(point) {
@@ -1394,8 +1636,8 @@ function createSootElement(matcher) {
       const node = await findNodeByMatcher(matcher);
       if (!node) throw new Error(`element not found for tap: ${JSON.stringify(matcher)}`);
       const defaultPoint = point ? null : await getDefaultTapPoint(page, node);
-      const targetSootX = typeof point?.x === "number" ? node.absolutePosition.x + point.x : defaultPoint?.x ?? node.absolutePosition.x + node.layout.width / 2;
-      const targetSootY = typeof point?.y === "number" ? node.absolutePosition.y + point.y : defaultPoint?.y ?? node.absolutePosition.y + node.layout.height / 2;
+      const targetSootSimX = typeof point?.x === "number" ? node.absolutePosition.x + point.x : defaultPoint?.x ?? node.absolutePosition.x + node.layout.width / 2;
+      const targetSootSimY = typeof point?.y === "number" ? node.absolutePosition.y + point.y : defaultPoint?.y ?? node.absolutePosition.y + node.layout.height / 2;
       await page.evaluate(
         async ({ x, y }) => {
           const interactTap = window.SootSim?.bridges?.interact?.tap;
@@ -1409,7 +1651,7 @@ function createSootElement(matcher) {
           }
           await tap(x, y);
         },
-        { x: targetSootX, y: targetSootY }
+        { x: targetSootSimX, y: targetSootSimY }
       );
       await page.waitForTimeout(50);
       if (_synchronizationEnabled) {
@@ -1465,12 +1707,12 @@ function createSootElement(matcher) {
         throw new Error(
           `target element not found: ${JSON.stringify(targetElement._matcher)}`
         );
-      const startSootX = srcNode.absolutePosition.x + srcNode.layout.width * normalizedStartX;
-      const startSootY = srcNode.absolutePosition.y + srcNode.layout.height * normalizedStartY;
-      const endSootX = tgtNode.absolutePosition.x + tgtNode.layout.width * normalizedEndX;
-      const endSootY = tgtNode.absolutePosition.y + tgtNode.layout.height * normalizedEndY;
-      const startPage = await sootsimToPage(page, startSootX, startSootY);
-      const endPage = await sootsimToPage(page, endSootX, endSootY);
+      const startSootSimX = srcNode.absolutePosition.x + srcNode.layout.width * normalizedStartX;
+      const startSootSimY = srcNode.absolutePosition.y + srcNode.layout.height * normalizedStartY;
+      const endSootSimX = tgtNode.absolutePosition.x + tgtNode.layout.width * normalizedEndX;
+      const endSootSimY = tgtNode.absolutePosition.y + tgtNode.layout.height * normalizedEndY;
+      const startPage = await sootsimToPage(page, startSootSimX, startSootSimY);
+      const endPage = await sootsimToPage(page, endSootSimX, endSootSimY);
       const steps = speed === "slow" ? 20 : 10;
       await page.mouse.move(startPage.x, startPage.y);
       await page.mouse.down();
@@ -1568,23 +1810,23 @@ function createSootElement(matcher) {
         throw new Error(`element not found for swipe: ${JSON.stringify(matcher)}`);
       const page = getPage();
       const { absolutePosition, layout } = node;
-      const startSootX = absolutePosition.x + layout.width * 0.5;
-      const startSootY = absolutePosition.y + layout.height * 0.5;
-      let endSootX = startSootX;
-      let endSootY = startSootY;
+      const startSootSimX = absolutePosition.x + layout.width * 0.5;
+      const startSootSimY = absolutePosition.y + layout.height * 0.5;
+      let endSootSimX = startSootSimX;
+      let endSootSimY = startSootSimY;
       const dist = direction === "up" || direction === "down" ? layout.height * percentage : layout.width * percentage;
       switch (direction) {
         case "up":
-          endSootY -= dist;
+          endSootSimY -= dist;
           break;
         case "down":
-          endSootY += dist;
+          endSootSimY += dist;
           break;
         case "left":
-          endSootX -= dist;
+          endSootSimX -= dist;
           break;
         case "right":
-          endSootX += dist;
+          endSootSimX += dist;
           break;
       }
       const steps = speed === "slow" ? 20 : speed === "fast" ? 8 : 12;
@@ -1598,10 +1840,10 @@ function createSootElement(matcher) {
           await drag(fromX, fromY, toX, toY, steps2, stepMs);
         },
         {
-          fromX: startSootX,
-          fromY: startSootY,
-          toX: endSootX,
-          toY: endSootY,
+          fromX: startSootSimX,
+          fromY: startSootSimY,
+          toX: endSootSimX,
+          toY: endSootSimY,
           steps,
           stepMs: stepDelay
         }
@@ -1695,7 +1937,7 @@ function createSootElement(matcher) {
   return el;
 }
 function element(matcher) {
-  return createSootElement(matcher);
+  return createSootSimElement(matcher);
 }
 var device = {
   _currentUrl: "",
@@ -2061,8 +2303,8 @@ var device = {
     return getPage();
   }
 };
-var sootExpect = createExpect(findNodeByMatcher, getPage);
-var sootWaitFor = createWaitFor(findNodeByMatcher, getPage);
+var sootsimExpect = createExpect(findNodeByMatcher, getPage);
+var sootsimWaitFor = createWaitFor(findNodeByMatcher, getPage);
 async function cleanup() {
   await closeBrowser();
 }

package/dist-lib/dev-bundle-resolution.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.227 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.229 | (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;
@@ -55,7 +55,7 @@ function applyPreviewProdBundle(parsed) {
 function normalizeNativeDevBundleUrl(bundleUrl) {
   try {
     const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
-    const parsed = new URL(bundleUrl, "http://soot.local");
+    const parsed = new URL(bundleUrl, "http://sootsim.local");
     parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
     if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
     parsed.searchParams.delete("transform.bytecode");

package/dist-lib/home-paths.cjs

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