peachsim 0.1.627 → 0.1.628

package/cli/commands/show-touches-mode.ts

@@ -0,0 +1,33 @@
+// peach mode show-touches — toggle OS touch indicators (Show Single Touches / Show taps)
+// in the running peach sim.
+
+import { rnxExit } from '../run-rnx'
+import { runShellBooleanMode, type ShellBooleanModeOptions } from './shell-boolean-mode'
+
+export async function runShowTouchesMode(args: string[], opts: ShellBooleanModeOptions) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+peach mode show-touches — toggle touch indicator overlays
+
+usage:
+  peach mode show-touches [on|off|toggle]
+
+arguments:
+  on        enable touch indicators
+  off       disable touch indicators
+  toggle    flip the current state (default)
+
+examples:
+  peach mode show-touches
+  peach mode show-touches on
+  peach mode show-touches off
+`)
+    rnxExit(0)
+  }
+
+  await runShellBooleanMode(args, opts, {
+    modeKey: 'showTouches',
+    displayName: 'show-touches',
+    actionId: 'toggle-touches',
+  })
+}

package/cli/commands/skills.ts

@@ -9,10 +9,26 @@ import * as fs from 'fs'
 import * as os from 'os'
 import * as path from 'path'
 import { fileURLToPath } from 'url'
+import { getCliVersion } from '../../src/cli-version'
+import { rnxHomeDir } from '../../src/home-paths'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { rnxExit } from '../run-rnx'
 
+declare const __PEACH_BUNDLED_SKILLS__: Record<string, string>
+
 function getSkillsDir(): string {
+  // the standalone binary carries its skills instead of a package directory;
+  // write them once per cli version so installs can link to real files.
+  if (typeof __PEACH_BUNDLED_SKILLS__ !== 'undefined') {
+    const dir = path.join(rnxHomeDir(), 'skills', getCliVersion())
+    for (const [file, body] of Object.entries(__PEACH_BUNDLED_SKILLS__)) {
+      const target = path.join(dir, file)
+      if (fs.existsSync(target)) continue
+      fs.mkdirSync(path.dirname(target), { recursive: true })
+      fs.writeFileSync(target, body)
+    }
+    return dir
+  }
   try {
     const pkgPath = fileURLToPath(
       import.meta.resolve(`${rnxPublicBrand.packageName}/package.json`),

package/cli/commands/test.ts

@@ -984,7 +984,14 @@ export async function runTest(
     return runCloudTest(args, opts)
   }
 
-  const selected = resolveTestCommand(args)
+  // a missing or unknown target is the caller's mistake: one line, no stack.
+  let selected: ReturnType<typeof resolveTestCommand>
+  try {
+    selected = resolveTestCommand(args)
+  } catch (error) {
+    console.error(`  error: ${error instanceof Error ? error.message : String(error)}`)
+    return 1
+  }
   const app = appFromArgs(args)
   const appTarget = app
     ? await resolveTestAppTarget(app)

package/cli/commands/welcome.ts

@@ -4,14 +4,14 @@ import { printBrand } from '../ui'
 import { runOpenCommand } from './control'
 import { runSetup } from './setup'
 
-export async function runWelcome(): Promise<number> {
+export async function runWelcome(port: number | undefined): Promise<number> {
   if (!isOnboardingComplete() && canPromptForPrivacyChoice()) {
-    await runSetup([], { launchConnectRN: true })
+    await runSetup([], { launchConnectRN: true, port })
     return 0
   }
 
   printBrand('Run any React Native app in a local simulator.')
   console.log(`\n  Opening ConnectRN`)
-  await runOpenCommand(['ConnectRN', '--no-describe', '--quiet'])
+  await runOpenCommand(['ConnectRN', '--no-describe', '--quiet'], { port })
   return 0
 }

package/cli/drivers/playwright-sim-host.ts

@@ -446,16 +446,17 @@ const cleanupProfile = () => {
     const request = readBrowserCompositeCaptureRequest(value);
     const session = await source.page.context().newCDPSession(source.page);
     try {
+      const { clip, originX, originY } = resolveBrowserCompositeCdpClip(
+        request,
+        await session.send('Page.getLayoutMetrics'),
+      );
       const result = await session.send('Page.captureScreenshot', {
         format: 'png',
         fromSurface: true,
         captureBeyondViewport: true,
-        clip: resolveBrowserCompositeCdpClip(
-          request,
-          await session.send('Page.getLayoutMetrics'),
-        ),
+        clip,
       });
-      return 'data:image/png;base64,' + result.data;
+      return { dataUrl: 'data:image/png;base64,' + result.data, originX, originY };
     } finally {
       await session.detach();
     }

package/cli/help-core.ts

@@ -96,8 +96,13 @@ Run \`peach <command> --help\` for leaf availability and usage.`
 export function renderRnxHelp(options: RnxHelpOptions): string {
   const command = options.command ?? null
   const commandArgs = options.commandArgs ?? []
+  // the preview selectors and backend lists describe the factory's browser
+  // backend; the public cli runs the node backend and never sees them.
+  const factory = options.backend === 'browser'
   if (!command) {
-    return `${renderCliIndexHelp(HELP_CONTEXT, formatFlagHelp()).trimEnd()}
+    const index = renderCliIndexHelp(HELP_CONTEXT, formatFlagHelp()).trimEnd()
+    if (!factory) return index
+    return `${index}
 
 browser preview selectors:
   peach web                     select the existing Factory web preview
@@ -108,7 +113,7 @@ ${renderRootAvailability(options.backend)}`
   }
 
   let body: string | null
-  if (command === 'web' || command === 'ios' || command === 'android') {
+  if (factory && (command === 'web' || command === 'ios' || command === 'android')) {
     body = renderPreviewHelp(command)
   } else if (options.group === command && !options.prefer) {
     body = renderCliGroupHelp(command, HELP_CONTEXT, formatFlagHelp())
@@ -130,11 +135,11 @@ ${renderRootAvailability(options.backend)}`
   const registration = getRnxCommandRegistration(command)
   if (!registration) return body
   const current = getRnxCommandAvailability(command, commandArgs, options.backend)
+  if (!factory && current.available) return body
   const currentLine = current.available
     ? `${options.backend} backend: available`
     : `${options.backend} backend: ${current.reason}`
-  const factoryLeaves =
-    options.backend === 'browser' ? renderFactoryBrowserLeaves(command) : null
+  const factoryLeaves = factory ? renderFactoryBrowserLeaves(command) : null
   return `${body.trimEnd()}
 
 ${factoryLeaves ? `${factoryLeaves}\n\n` : ''}${backendLabel(command, commandArgs)}

package/cli/internal-child.ts

@@ -18,6 +18,12 @@ import * as vm from 'node:vm'
 
 export const RNX_INTERNAL_COMMAND = '__internal'
 
+// playwright's installer forks its downloader script with process.execPath,
+// which here is this binary. the installer child sets this for its whole
+// process tree, and bin.ts then runs a forked `.js` argument as a script
+// instead of reading it as a peach command.
+export const RNX_FORKED_SCRIPT_ENV = 'PEACH_RUNS_FORKED_SCRIPTS'
+
 export const RNX_INTERNAL_CHILDREN = {
   playwrightProbe: 'playwright-probe',
   playwrightInstall: 'playwright-install',
@@ -113,8 +119,14 @@ function playwrightInstall(args: string[]): void {
   if (!cliPath) {
     throw new Error('internal playwright-install needs the package CLI path')
   }
-  process.argv = [process.argv[0], cliPath, ...cliArgs]
-  requireFromCwd()(cliPath)
+  process.env[RNX_FORKED_SCRIPT_ENV] = '1'
+  runScript(cliPath, cliArgs)
+}
+
+/** run a javascript file as node would, with argv shaped for its own parser. */
+export function runScript(scriptPath: string, args: string[]): void {
+  process.argv = [process.argv[0], scriptPath, ...args]
+  createRequire(scriptPath)(scriptPath)
 }
 
 /** the detached browser host. its source is CJS that resolves playwright from

package/cli/levenshtein.ts

@@ -0,0 +1,27 @@
+export function levenshtein(a: string, b: string): number {
+  if (a === b) return 0
+  if (!a.length) return b.length
+  if (!b.length) return a.length
+  // standard two-row dp: prev[] is the previous row, cur[] is the row being
+  // computed; swap pointers per outer iteration. the earlier in-place rolling
+  // version overwrote prev[j-1] twice per cell and never set prev[0]=i, so
+  // distance(`kitten`,`sitting`) returned 8 instead of 3 and the fuzzy-suggest
+  // ranking was effectively random.
+  let prev = new Array<number>(b.length + 1)
+  let cur = new Array<number>(b.length + 1)
+  for (let j = 0; j <= b.length; j++) prev[j] = j
+  for (let i = 1; i <= a.length; i++) {
+    cur[0] = i
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(
+        prev[j] + 1,
+        cur[j - 1] + 1,
+        prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+      )
+    }
+    const tmp = prev
+    prev = cur
+    cur = tmp
+  }
+  return prev[b.length]
+}

package/cli/main.ts

@@ -3,7 +3,8 @@
 // when none of its hidden entry points claimed the process.
 
 import { rnxPublicBrand } from '../src/public-brand'
-import { parseArgs, TOP_LEVEL_RUNTIME_COMMANDS } from './parse-args'
+import { levenshtein } from './levenshtein'
+import { COMMANDS, parseArgs, TOP_LEVEL_RUNTIME_COMMANDS } from './parse-args'
 import { RnxExit } from './run-rnx'
 import { rnxSelfInvocation } from './self-invocation'
 import { IS_STANDALONE } from './standalone'
@@ -37,18 +38,29 @@ function handleTopLevelError(err: unknown): never {
     msg.startsWith('peach bridge exited before becoming ready') ||
     msg.startsWith(`${rnxPublicBrand.commandName} open: requested bridge port`) ||
     msg.startsWith('background daemon setup is unavailable') ||
-    msg.startsWith('peach bridge did not start within')
+    msg.startsWith('peach bridge did not start within') ||
+    msg.startsWith('could not resolve a native bundle for ')
   if (isKnownCliFailure && !process.env.SOOTSIM_VERBOSE) {
     process.stderr.write(`  ${msg}\n`)
     process.exit(1)
   }
-  if (err instanceof Error && err.stack) {
-    process.stderr.write(`${err.stack}\n`)
-  } else {
-    process.stderr.write(`${msg}\n`)
-  }
+  // bun can render an async-thrown error's stack with a bare `Error` header, so
+  // the message always goes first.
+  process.stderr.write(`  ${msg}\n`)
+  if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}\n`)
   process.exit(1)
 }
+function printUnknownCommand(attempted: string) {
+  const closest = [...COMMANDS]
+    .map((name) => ({ name, distance: levenshtein(attempted, name) }))
+    .sort((a, b) => a.distance - b.distance)[0]
+  console.error(`  unknown command: ${attempted}`)
+  if (closest && closest.distance <= 2) {
+    console.error(`  did you mean \`${rnxPublicBrand.commandName} ${closest.name}\`?`)
+  }
+  console.error(`  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`)
+}
+
 process.on('unhandledRejection', handleTopLevelError)
 process.on('uncaughtException', handleTopLevelError)
 
@@ -73,7 +85,11 @@ const isCliUpdateWorker =
   parsed.commandArgs[0] === '--check-worker'
 const isBareWelcome = !parsed.command && parsed.commandArgs.length === 0
 const isReadOnlyInvocation =
-  parsed.version || parsed.help || parsed.commandArgs.includes('--dry-run')
+  parsed.version ||
+  parsed.help ||
+  parsed.commandArgs.includes('--help') ||
+  parsed.commandArgs.includes('-h') ||
+  parsed.commandArgs.includes('--dry-run')
 
 if (isCliUpdateWorker) {
   if (IS_STANDALONE) {
@@ -264,7 +280,7 @@ if (device || theme) {
 // returning runs open ConnectRN directly; app discovery belongs inside it.
 if (!parsed.command && parsed.commandArgs.length === 0) {
   const { runWelcome } = await import('./commands/welcome')
-  await exitWithFlush(await runWelcome())
+  await exitWithFlush(await runWelcome(port))
 }
 
 // route to command. an empty command at this point only happens if the
@@ -280,10 +296,7 @@ if (!command) {
   if (parsed.commandArgs.length > 0) {
     const attempted =
       parsed.commandArgs.find((a) => !a.startsWith('-')) ?? parsed.commandArgs[0]
-    console.error(`  unknown command: ${attempted}`)
-    console.error(
-      `  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`,
-    )
+    printUnknownCommand(attempted)
     await exitWithFlush(1)
   }
   const { printHelp } = await import('./help')
@@ -608,7 +621,7 @@ try {
 
       case 'setup': {
         const { runSetup } = await import('./commands/setup')
-        await runSetup(parsed.commandArgs)
+        await runSetup(parsed.commandArgs, { port })
         break
       }
 
@@ -685,10 +698,7 @@ try {
       }
 
       default: {
-        console.error(`  unknown command: ${command}`)
-        console.error(
-          `  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`,
-        )
+        printUnknownCommand(command)
         await exitWithFlush(1)
       }
     }

package/cli/ws-bridge.ts

@@ -145,9 +145,10 @@ function resolveDefaultDevBridgeLockfile(): DevBridgeLockfile | null {
     }
   }
 
+  // another checkout's bridge on its own offset belongs to that checkout's
+  // world; only the canonical bridge is shared, and past it the daemon serves.
   return (
-    lockfiles.find((lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT) ??
-    lockfiles[0]
+    lockfiles.find((lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT) ?? null
   )
 }
 

package/detox/index.ts

@@ -369,6 +369,52 @@ function reapOwnedBrowser(): void {
   } catch {}
 }
 
+// an open picture-in-picture window keeps the browser context alive and
+// context.close() never settles (expo-pip has no exit api, and the OS
+// window outlives its video element). exit PiP in every page first; the
+// page's leavepictureinpicture handler stops the capture tracks and
+// removes the video. bounded and best-effort so a wedged page cannot eat
+// the close budget.
+const CONTEXT_MEDIA_QUIESCE_TIMEOUT_MS = 2_500
+
+async function quiesceContextMedia(context: BrowserContext): Promise<void> {
+  const pages = context.pages()
+  if (pages.length === 0) return
+  const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+  await Promise.race([
+    Promise.all(
+      pages.map((page) =>
+        page
+          .evaluate(() => {
+            const doc = globalThis.document
+            if (!doc) return
+            if (
+              doc.pictureInPictureElement &&
+              typeof doc.exitPictureInPicture === 'function'
+            ) {
+              void doc.exitPictureInPicture().catch(() => {})
+            }
+            doc.querySelectorAll('video').forEach((v) => {
+              try {
+                if (
+                  v.srcObject &&
+                  typeof (v.srcObject as MediaStream).getTracks === 'function'
+                ) {
+                  ;(v.srcObject as MediaStream).getTracks().forEach((t) => t.stop())
+                  v.srcObject = null
+                }
+                v.pause()
+                v.remove()
+              } catch {}
+            })
+          })
+          .catch(() => {}),
+      ),
+    ),
+    sleep(CONTEXT_MEDIA_QUIESCE_TIMEOUT_MS),
+  ]).catch(() => {})
+}
+
 async function closeContext() {
   if (_browserCompromised) {
     throw new Error(`sootsim browser is compromised: ${_browserCompromised}`)
@@ -377,6 +423,7 @@ async function closeContext() {
   const context = _context
   const closingContextId = contextIdentity
   try {
+    await quiesceContextMedia(context)
     await withLifecycleTimeout('context.close()', closingContextId, () => context.close())
     _context = null
     _page = null
@@ -715,7 +762,9 @@ async function focusElementForTextEntry(el: SootSimElement): Promise<void> {
   // would edit around a caret the tap then moves, so wait for its focus.
   await pollUntil(
     () =>
-      page.evaluate(async () => (await window.__sootsimTest!.getFocusedNode?.())?.nodeId ?? null),
+      page.evaluate(
+        async () => (await window.__sootsimTest!.getFocusedNode?.())?.nodeId ?? null,
+      ),
     (focusedNodeId) => focusedNodeId === node.nodeId,
     {
       timeoutMs: 5000,
@@ -1535,6 +1584,14 @@ function createSootSimElement(matcher: Matcher): SootSimElement {
         visible: node.layout.width > 0 && node.layout.height > 0,
         enabled: !node.accessibilityState?.disabled,
         ...node,
+        frame: node.absolutePosition
+          ? {
+              x: node.absolutePosition.x,
+              y: node.absolutePosition.y,
+              width: node.absolutePosition.width ?? node.frame?.width ?? 0,
+              height: node.absolutePosition.height ?? node.frame?.height ?? 0,
+            }
+          : node.frame,
       }
     },
 
@@ -1552,6 +1609,131 @@ export function element(matcher: Matcher): SootSimElement {
 }
 
 // device object -- app lifecycle
+export interface DetoxUserNotificationParams {
+  trigger: {
+    type: string
+    [key: string]: unknown
+  }
+  title?: unknown
+  subtitle?: unknown
+  body?: unknown
+  badge?: unknown
+  category?: unknown
+  'content-available'?: unknown
+  payload?: Record<string, unknown>
+  'user-text'?: unknown
+  'action-identifier'?: unknown
+  [key: string]: unknown
+}
+
+// detox's documented sendUserNotification data, converted the way detox ios
+// builds it (DetoxUserNotificationDispatcher.payload): the user info is the
+// custom `payload`, with the top-level title, subtitle, and body written into
+// its aps alert and badge, category, and content-available written into its
+// aps. a top-level key that is absent removes the payload's own value, as
+// assigning nil to a swift dictionary does; every other aps key survives.
+function detoxNotificationToApnsPayload(params: DetoxUserNotificationParams): {
+  payload: Record<string, unknown>
+  actionId?: string
+  userText?: string
+} {
+  const trigger = objectOrEmpty(objectOrEmpty(params).trigger)
+  const supported = ['push', 'calendar', 'location', 'timeInterval']
+  if (typeof trigger.type !== 'string' || !supported.includes(trigger.type)) {
+    throw new Error(
+      `Missing trigger or invalid trigger type. A 'trigger' key must exist, with one of the following types: '${supported.join("', '")}'`,
+    )
+  }
+  if (trigger.type !== 'push') {
+    throw new Error(
+      `sootsim device.sendUserNotification: trigger type '${trigger.type}' is not simulated, only 'push'`,
+    )
+  }
+  const assign = (record: Record<string, unknown>, key: string, value: unknown) => {
+    if (value === undefined) delete record[key]
+    else record[key] = value
+  }
+  const payload = { ...objectOrEmpty(params.payload) }
+  const aps = { ...objectOrEmpty(payload.aps) }
+  const alert = { ...objectOrEmpty(aps.alert) }
+  assign(alert, 'title', params.title)
+  assign(alert, 'subtitle', params.subtitle)
+  assign(alert, 'body', params.body)
+  aps.alert = alert
+  assign(aps, 'badge', params.badge)
+  assign(aps, 'category', params.category)
+  assign(aps, 'content-available', params['content-available'])
+  payload.aps = aps
+  return {
+    payload,
+    actionId:
+      typeof params['action-identifier'] === 'string'
+        ? params['action-identifier']
+        : undefined,
+    userText: typeof params['user-text'] === 'string' ? params['user-text'] : undefined,
+  }
+}
+
+function objectOrEmpty(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? { ...value }
+    : {}
+}
+
+interface PreparedRemotePush {
+  payload: Record<string, unknown>
+  actionId?: string
+  userText?: string
+}
+
+async function postPreparedRemotePush(
+  prepared: PreparedRemotePush,
+  launch: boolean,
+): Promise<void> {
+  const { payload, actionId, userText } = prepared
+  const page = getPage()
+  await page.evaluate(
+    ({ request }) => {
+      const bridges = (
+        window as unknown as {
+          SootSim?: {
+            bridges?: {
+              shellHost?: { postNativeUIRequest?: (request: unknown) => unknown }
+            }
+          }
+        }
+      ).SootSim?.bridges
+      // the shell host queues requests until the shell worker connects, so a
+      // post here never silently drops. (mainShell.postNativeUIRequest would
+      // swallow a not-yet-connected shell and report success.)
+      const target = bridges?.shellHost
+      const post = target?.postNativeUIRequest
+      if (typeof post !== 'function') {
+        throw new Error(
+          'sootsim device.sendUserNotification: simulator shell unavailable — call device.launchApp() first',
+        )
+      }
+      post.call(target, request)
+    },
+    {
+      request: {
+        kind: 'notification.remote-push',
+        payload,
+        launch,
+        ...(actionId !== undefined ? { actionId } : {}),
+        ...(userText !== undefined ? { userText } : {}),
+      },
+    },
+  )
+}
+
+async function postRemotePushToSimulator(
+  params: DetoxUserNotificationParams,
+  launch: boolean,
+): Promise<void> {
+  await postPreparedRemotePush(detoxNotificationToApnsPayload(params), launch)
+}
+
 export const device = {
   _currentUrl: '',
   _platform: DETOX_PLATFORM as 'ios' | 'android',
@@ -1561,6 +1743,9 @@ export const device = {
     newInstance?: boolean
     url?: string
     launchArgs?: Record<string, any>
+    // launch from a notification, like detox launchApp({ userNotification }):
+    // dispatched during launch, so the app receives its tap response.
+    userNotification?: DetoxUserNotificationParams
     // when set, the new BrowserContext records video at this dir. used by
     // captureProofMenuStages for the multi-stage animation diff path. must
     // be set at launchApp time because playwright recordVideo can't be
@@ -1601,6 +1786,9 @@ export const device = {
       )
       _suspendedAppId = null
       await waitForSootsimTree(page, 10000)
+      if (opts?.userNotification) {
+        await postRemotePushToSimulator(opts.userNotification, true)
+      }
       return
     }
 
@@ -1649,16 +1837,17 @@ export const device = {
         const request = readBrowserCompositeCaptureRequest(value)
         const session = await source.page.context().newCDPSession(source.page)
         try {
+          const { clip, originX, originY } = resolveBrowserCompositeCdpClip(
+            request,
+            await session.send('Page.getLayoutMetrics'),
+          )
           const result = await session.send('Page.captureScreenshot', {
             format: 'png',
             fromSurface: true,
             captureBeyondViewport: true,
-            clip: resolveBrowserCompositeCdpClip(
-              request,
-              await session.send('Page.getLayoutMetrics'),
-            ),
+            clip,
           })
-          return 'data:image/png;base64,' + result.data
+          return { dataUrl: 'data:image/png;base64,' + result.data, originX, originY }
         } finally {
           await session.detach()
         }
@@ -1683,6 +1872,25 @@ export const device = {
       operation: 'launchApp',
     })
 
+    if (opts?.userNotification) {
+      // detox dispatches the launch notification before the app's js runs.
+      // the shell and tenant channels queue it until they connect, so it is
+      // posted once, as soon as the shell accepts requests.
+      const prepared = detoxNotificationToApnsPayload(opts.userNotification)
+      await pollUntil(
+        () =>
+          postPreparedRemotePush(prepared, true).then(
+            () => true,
+            () => false,
+          ),
+        Boolean,
+        {
+          timeoutMs: 60000,
+          label: 'SootSim shell to accept launch notification',
+        },
+      )
+    }
+
     await waitForSootsimTree(_page!, 30000)
     await waitForSootsimSurfaceMetrics(_page!, 30000)
     await waitForSootsimShellReady(_page!, 30000)
@@ -1728,6 +1936,13 @@ export const device = {
     await waitForSootsimWorkletsIdle(page, 3000)
   },
 
+  // detox device.sendUserNotification on ios: the notification goes straight
+  // to the app's notification center delegate. an active app gets willPresent;
+  // otherwise the app gets the tap response.
+  async sendUserNotification(params: DetoxUserNotificationParams) {
+    await postRemotePushToSimulator(params, false)
+  },
+
   async takeScreenshot(name: string): Promise<string> {
     return writeSootsimScreenshot(name)
   },
@@ -2832,8 +3047,20 @@ export const device = {
     // no-op for sootsim
   },
 
+  // set the simulated device location at the platform level, the same step
+  // native detox's setLocation takes: on iOS it drives the simulator location
+  // (AppleSimUtils/simctl location set) and CLLocationManager delivers the fix
+  // asynchronously. here the platform is the harness browser, so grant page
+  // geolocation and override the context fix; the guest location seam observes
+  // it through navigator.geolocation exactly like the app observes Core
+  // Location. app permission state is untouched, matching native.
   async setLocation(lat: number, lon: number) {
-    // no-op
+    const page = getPage()
+    const context = _context ?? page.context()
+    await context.grantPermissions(['geolocation'], {
+      origin: new URL(page.url()).origin,
+    })
+    await context.setGeolocation({ latitude: lat, longitude: lon })
   },
 
   async setStatusBar(config: StatusBarConfig) {

package/dist-lib/agent-daemon-client.cjs

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

package/dist-lib/agent-events.cjs

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

package/dist-lib/agent-identity.cjs

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