rnxsim 0.1.392 → 0.1.394

package/cli/cloud-client.ts

@@ -1,8 +1,16 @@
 import { createHash, randomUUID } from 'node:crypto'
 import { closeSync, fstatSync, openSync, readFileSync } from 'node:fs'
-import { extname, resolve } from 'node:path'
-import { assertSelfContainedMetroArtifactAssets } from '../../contrast-bundler/src/metroAssetArtifact'
+import { dirname, extname, join, resolve } from 'node:path'
 import {
+  embedMetroAssetFiles,
+  type MetroAssetVariant,
+} from '../../contrast-bundler/src/metroAssetArtifact'
+import {
+  buildRnxCloudArtifact,
+  type RnxCloudArtifactReceipt,
+} from '../../contrast-bundler/src/metroCloudArtifact'
+import {
+  isRnxCloudCommandType,
   RNX_CLOUD_MAX_ARTIFACT_BYTES,
   type RnxCloudCreateReceipt,
 } from '../src/cloud-contract'
@@ -27,6 +35,8 @@ interface CreateCloudSimulatorOptions {
   bundlePath: string
   device: string
   authorization: string
+  /** the `--assets-dest` directory Metro wrote beside the bundle. */
+  assetsPath?: string
   apiOrigin?: string
 }
 
@@ -61,9 +71,7 @@ function resolveCloudOrigin(value?: string): string {
   return normalizeCloudOrigin(source)
 }
 
-async function readImmutableBundle(
-  bundlePath: string,
-): Promise<{ bytes: Buffer; sha256: string }> {
+function readImmutableBundleSource(bundlePath: string): string {
   const filepath = resolve(bundlePath)
   if (extname(filepath) !== '.js') {
     throw new Error('rnx ios --cloud requires one local Metro .js bundle')
@@ -77,11 +85,6 @@ async function readImmutableBundle(
     if (before.size <= 0n) {
       throw new Error('rnx ios --cloud bundle is empty')
     }
-    if (before.size > BigInt(MAX_RNX_CLOUD_BUNDLE_BYTES)) {
-      throw new Error(
-        `rnx ios --cloud bundle exceeds the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit`,
-      )
-    }
     const bytes = readFileSync(descriptor)
     const after = fstatSync(descriptor, { bigint: true })
     if (
@@ -102,16 +105,61 @@ async function readImmutableBundle(
     if (source.includes('\0') || !source.includes('__d(') || !source.includes('__r(')) {
       throw new Error('rnx ios --cloud requires a Metro JavaScript bundle')
     }
-    await assertSelfContainedMetroArtifactAssets(source)
-    return {
-      bytes,
-      sha256: createHash('sha256').update(bytes).digest('hex'),
-    }
+    return source
   } finally {
     closeSync(descriptor)
   }
 }
 
+// `react-native bundle --assets-dest <dir>` and `expo export:embed` write every
+// scale variant with getAssetDestPathIOS: the descriptor's httpServerLocation
+// without its leading slash, each `../` collapsed to `_`, then the asset name
+// with its scale suffix. reading that layout is what lets an ordinary Metro
+// build reach the cloud with no per-app script.
+function metroAssetDestPath(assetsPath: string, variant: MetroAssetVariant): string {
+  const { descriptor, scale } = variant
+  const suffix = scale === 1 ? '' : `@${scale}x`
+  return join(
+    assetsPath,
+    descriptor.httpServerLocation.slice(1).replace(/\.\.\//g, '_'),
+    `${descriptor.name}${suffix}.${descriptor.type}`,
+  )
+}
+
+/**
+ * turns the Metro production bundle a caller built into the immutable artifact
+ * the runner executes: every asset scale is read from the asset graph and
+ * embedded, module identity is normalized, and the JavaScript is minified.
+ */
+async function produceCloudArtifact(
+  bundlePath: string,
+  assetsPath: string,
+): Promise<{ bytes: Buffer; sha256: string; receipt: RnxCloudArtifactReceipt }> {
+  const source = readImmutableBundleSource(bundlePath)
+  const embedded = await embedMetroAssetFiles(source, async (variant) => {
+    const file = metroAssetDestPath(assetsPath, variant)
+    try {
+      return readFileSync(file)
+    } catch {
+      throw new Error(
+        `rnx ios --cloud could not read ${file} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}. Build the bundle with --assets-dest, or pass --assets <dir>.`,
+      )
+    }
+  })
+  const artifact = await buildRnxCloudArtifact(embedded.code)
+  const bytes = Buffer.from(artifact.code, 'utf8')
+  if (bytes.length > MAX_RNX_CLOUD_BUNDLE_BYTES) {
+    throw new Error(
+      `rnx ios --cloud artifact is ${bytes.length} bytes and exceeds the ${MAX_RNX_CLOUD_BUNDLE_BYTES}-byte limit`,
+    )
+  }
+  return {
+    bytes,
+    sha256: createHash('sha256').update(bytes).digest('hex'),
+    receipt: artifact.receipt,
+  }
+}
+
 function readCreateResponse(
   value: unknown,
   expectedBytes: number,
@@ -155,9 +203,16 @@ function readCreateResponse(
 
 export async function createCloudSimulator(
   options: CreateCloudSimulatorOptions,
-): Promise<{ receipt: RnxCloudCreateReceipt; session: CloudSession }> {
+): Promise<{
+  receipt: RnxCloudCreateReceipt
+  session: CloudSession
+  artifact: RnxCloudArtifactReceipt
+}> {
   const apiOrigin = resolveCloudOrigin(options.apiOrigin)
-  const artifact = await readImmutableBundle(options.bundlePath)
+  const artifact = await produceCloudArtifact(
+    options.bundlePath,
+    resolve(options.assetsPath ?? dirname(options.bundlePath)),
+  )
   let response: Response
   try {
     response = await fetch(`${apiOrigin}/v1/sims`, {
@@ -193,7 +248,7 @@ export async function createCloudSimulator(
     claimId: created.receipt.claim.id,
     token: created.token,
   })
-  return { receipt: created.receipt, session }
+  return { receipt: created.receipt, session, artifact: artifact.receipt }
 }
 
 export function resolveCloudSessionForParsed(
@@ -219,40 +274,7 @@ function cloudCommand(command: {
   for (const [key, value] of Object.entries(command)) {
     if (key !== 'id' && key !== 'simId') clean[key] = value
   }
-  if (command.type === 'query') {
-    const query = command.query
-    if (
-      !isRecord(query) ||
-      (query.kind !== 'tree' && query.kind !== 'find' && query.kind !== 'count')
-    ) {
-      throw new Error('RNX Cloud supports only structured tree, node, and count queries')
-    }
-    return clean
-  }
-  if (command.type === 'waitFor') {
-    const options = command.waitForOptions
-    const condition = isRecord(options) ? options.condition : null
-    if (
-      !isRecord(condition) ||
-      (condition.type !== 'ready' &&
-        condition.type !== 'present' &&
-        condition.type !== 'absent')
-    ) {
-      throw new Error('RNX Cloud supports only ready and selector waits')
-    }
-    return clean
-  }
-  if (command.type === 'state') return clean
-  if (command.type === 'capture' || command.type === 'captureRegions') return clean
-  if (command.type === 'setAppearance' || command.type === 'openUrl') return clean
-  if (
-    command.type === 'screenshot' &&
-    command.crop === undefined &&
-    command.captureFilter === undefined &&
-    (command.layers === undefined || command.layers === 'tenant')
-  ) {
-    return clean
-  }
+  if (isRnxCloudCommandType(command.type)) return clean
   throw new Error(`RNX Cloud does not support bridge command type ${command.type}`)
 }
 

package/cli/cloud-dispatch.ts

@@ -47,7 +47,7 @@ function supportsCloudRead(
   if (command === 'state') return firstVerb(positional) === null
   if (command === 'get') {
     const verb = firstVerb(positional)
-    return verb === 'tree' || verb === 'node' || verb === 'count'
+    return verb === 'tree' || verb === 'node' || verb === 'count' || verb === 'memory'
   }
   if (command === 'wait') {
     const verb = firstVerb(positional)
@@ -77,6 +77,7 @@ function supportsCloudRead(
       ].includes(arg),
     )
   }
+  if (command === 'do' || command === 'reset') return true
   return false
 }
 

package/cli/commands/inspect/core.ts

@@ -1095,8 +1095,16 @@ export async function inspectWaitReady(
     }
   }
   const probe = result.probe
+  // a guest app that redboxes still paints: its ErrorBoundary is a real tree
+  // with real nodes, so the engine's own readiness condition matches and every
+  // caller reads exit 0 as "the app is up". an app that has errored is not
+  // ready, so a guest error is disqualifying here rather than merely printed
+  // on the failure path. `errors` (a console.error count) is deliberately not
+  // used because apps can log errors benignly. `suppressedEntryError` remains
+  // excluded because it never gates readiness by contract.
+  const externalError = probe?.externalError ?? ''
   const status: WaitReadyStatus = {
-    ready: result.matched,
+    ready: result.matched && !externalError,
     elapsedMs: result.elapsedMs,
     nodes: probe?.nodes ?? 0,
     targets: probe?.targets ?? 0,
@@ -1107,7 +1115,7 @@ export async function inspectWaitReady(
     loadingText: probe?.loadingText ?? '',
     externalReady: probe?.externalReady ?? null,
     externalStatus: probe?.externalStatus ?? '',
-    externalError: probe?.externalError ?? '',
+    externalError,
     suppressedEntryError: probe?.suppressedEntryError ?? '',
     errors: probe?.errors ?? 0,
     bridgeError: result.error ?? '',
@@ -1835,6 +1843,29 @@ export interface MemoryReport {
 // picture and raster image — answers through its stats channel.
 // performance.memory is chrome-only, null on webkit.
 export async function inspectMemory(bridge: InspectBridge): Promise<MemoryReport> {
+  if (bridge.plane === 'cloud') {
+    const value: unknown = await bridge.send({ type: 'memory' })
+    const rawWasmHeapBytes =
+      typeof value === 'object' && value !== null
+        ? Reflect.get(value, 'wasmHeapBytes')
+        : null
+    const wasmHeapBytes = typeof rawWasmHeapBytes === 'number' ? rawWasmHeapBytes : null
+    return {
+      tenant: {
+        nodesRegistered: null,
+        nodesDetached: null,
+        detachedTypes: null,
+        objects: null,
+        activeNativeAnimations: null,
+        imageLoader: null,
+        workerHeap: null,
+        wasmHeapBytes,
+      },
+      shell: null,
+      compositor: null,
+      hostHeap: null,
+    }
+  }
   const result = (await bridge.send({
     type: 'evaluate',
     code: `(async () => {

package/cli/commands/platform.ts

@@ -26,8 +26,15 @@ function isDeviceModel(value: string): value is DeviceModel {
   return value in devices
 }
 
-function cloudBundleFromArgs(args: string[]): string | null {
+const CLOUD_USAGE =
+  'usage: rnx ios --cloud <local bundle.js> [--assets <dir>] [--device <model>]'
+
+function cloudInputFromArgs(args: string[]): {
+  bundlePath: string
+  assetsPath: string | null
+} {
   const positional: string[] = []
+  let assetsPath: string | null = null
   for (let index = 0; index < args.length; index++) {
     const arg = args[index]
     if (arg === '--cloud') continue
@@ -35,6 +42,16 @@ function cloudBundleFromArgs(args: string[]): string | null {
       index++
       continue
     }
+    if (arg === '--assets') {
+      assetsPath = args[++index] ?? null
+      if (!assetsPath) throw new Error('rnx ios --cloud --assets requires a directory')
+      continue
+    }
+    if (arg.startsWith('--assets=')) {
+      assetsPath = arg.slice('--assets='.length) || null
+      if (!assetsPath) throw new Error('rnx ios --cloud --assets requires a directory')
+      continue
+    }
     if (
       arg === '--sim' ||
       arg === '--session' ||
@@ -50,10 +67,8 @@ function cloudBundleFromArgs(args: string[]): string | null {
     }
     positional.push(arg)
   }
-  if (positional.length !== 1) {
-    throw new Error('usage: rnx ios --cloud <local bundle.js> [--device <model>]')
-  }
-  return positional[0] ?? null
+  if (positional.length !== 1 || !positional[0]) throw new Error(CLOUD_USAGE)
+  return { bundlePath: positional[0], assetsPath }
 }
 
 export async function runPlatformCommand(
@@ -107,8 +122,7 @@ export async function runPlatformCommand(
       return 1
     }
     try {
-      const bundlePath = cloudBundleFromArgs(args)
-      if (!bundlePath) throw new Error('rnx ios --cloud requires a local bundle.js')
+      const input = cloudInputFromArgs(args)
       const {
         publishCloudSessionToShell,
         readCloudSession,
@@ -125,7 +139,8 @@ export async function runPlatformCommand(
         await import('../cloud-client')
       const { header } = authHeaderOrExit('ios --cloud')
       const created = await createCloudSimulator({
-        bundlePath,
+        bundlePath: input.bundlePath,
+        assetsPath: input.assetsPath ?? undefined,
         device: selectedDevice,
         authorization: header,
       })
@@ -136,11 +151,21 @@ export async function runPlatformCommand(
         throw error
       }
       const receipt = created.receipt
+      const produced = created.artifact
       console.log(`  cloud sim: ${receipt.simId}`)
       console.log(`  artifact: ${receipt.artifact.id} (${receipt.artifact.bytes} bytes)`)
+      console.log(
+        `  source bundle: sha256:${produced.source.sha256} (${produced.source.bytes} bytes)`,
+      )
+      console.log(
+        `  normalized modules: ${produced.modules}; javascript ${produced.javascript.sourceBytes} -> ${produced.javascript.minifiedBytes} bytes`,
+      )
+      console.log(
+        `  embedded assets: ${produced.assets.descriptors} descriptors, ${produced.assets.variants} scales, ${produced.assets.bytes} bytes (${produced.assets.encodedBytes} encoded)`,
+      )
       console.log(`  claim expires: ${receipt.claim.expiresAt}`)
       console.log(
-        '  reads: describe, find, get tree|node|count, wait ready|selector, logs, state, screenshot',
+        '  commands: describe, find, get tree|node|count|memory, wait ready|selector, do, reset, logs, state, screenshot',
       )
       return 0
     } catch (error) {

package/detox/attempt-events.cjs

@@ -0,0 +1,23 @@
+const fs = require('node:fs')
+const path = require('node:path')
+
+function attemptEventsPath() {
+  const enabled =
+    process.env.CONFORMANCE_PROOF === '1' || Boolean(process.env.CONFORMANCE_PROOF_DIR)
+  if (!enabled) return null
+  const root = path.resolve(
+    process.cwd(),
+    process.env.CONFORMANCE_PROOF_DIR || 'artifacts/conformance-proof/latest',
+  )
+  return path.join(root, 'events.jsonl')
+}
+
+function writeAttemptEvent(event) {
+  const output = attemptEventsPath()
+  if (output === null) return false
+  fs.mkdirSync(path.dirname(output), { recursive: true })
+  fs.appendFileSync(output, `${JSON.stringify(event)}\n`)
+  return true
+}
+
+module.exports = { attemptEventsPath, writeAttemptEvent }

package/detox/element-types.ts

@@ -21,8 +21,17 @@ export interface SootSimElement {
   typeText(text: string): Promise<void>
   replaceText(text: string): Promise<void>
   clearText(): Promise<void>
-  scroll(pixels: number, direction: 'up' | 'down' | 'left' | 'right'): Promise<void>
-  scrollTo(edge: 'top' | 'bottom' | 'left' | 'right'): Promise<void>
+  scroll(
+    pixels: number,
+    direction: 'up' | 'down' | 'left' | 'right',
+    startPositionX?: number,
+    startPositionY?: number,
+  ): Promise<void>
+  scrollTo(
+    edge: 'top' | 'bottom' | 'left' | 'right',
+    startPositionX?: number,
+    startPositionY?: number,
+  ): Promise<void>
   swipe(
     direction: 'up' | 'down' | 'left' | 'right',
     speed?: 'fast' | 'slow',

package/detox/expectations.ts

@@ -22,13 +22,15 @@ async function scrollMatcherElement(
   matcher: Matcher,
   pixels: number,
   direction: 'up' | 'down' | 'left' | 'right',
+  startPositionX?: number,
+  startPositionY?: number,
 ): Promise<number> {
   const node = await findNode(matcher)
   if (!node) {
     throw new Error(`scroll container not found: ${JSON.stringify(matcher)}`)
   }
   const before = scrollOffsetOf(node)
-  await dragScrollNode(page, node, pixels, direction)
+  await dragScrollNode(page, node, pixels, direction, startPositionX, startPositionY)
   const after = scrollOffsetOf(await findNode(matcher))
   return Math.abs(after.x - before.x) + Math.abs(after.y - before.y)
 }
@@ -500,8 +502,8 @@ class SootSimWaitForScrollAction {
   async scroll(
     pixels: number,
     direction: 'up' | 'down' | 'left' | 'right',
-    _startPositionX?: number,
-    _startPositionY?: number,
+    startPositionX?: number,
+    startPositionY?: number,
   ): Promise<void> {
     const page = this.getPage()
     let lastError: Error | null = null
@@ -523,6 +525,8 @@ class SootSimWaitForScrollAction {
         this.matcher,
         pixels,
         direction,
+        startPositionX,
+        startPositionY,
       )
       stalledSteps = travelled < 0.5 ? stalledSteps + 1 : 0
     }

package/detox/gestures.ts

@@ -27,6 +27,17 @@ type WorkletCallbackStats = {
   shellSent: number
 }
 
+export function resolveScrollStartPosition(
+  value: number | undefined,
+  label: string,
+): number {
+  const normalized = value === undefined || Number.isNaN(value) ? 0.5 : value
+  if (!Number.isFinite(normalized) || normalized < 0 || normalized > 1) {
+    throw new Error(`${label} must be between 0 and 1`)
+  }
+  return normalized
+}
+
 type ShellGestureSeamDebug = {
   attached?: Array<{
     viewTag?: unknown
@@ -307,9 +318,19 @@ export async function dragScrollNode(
   },
   pixels: number,
   direction: 'up' | 'down' | 'left' | 'right',
+  startPositionX?: number,
+  startPositionY?: number,
 ): Promise<void> {
-  const startSootSimX = node.absolutePosition.x + node.layout.width / 2
-  const startSootSimY = node.absolutePosition.y + node.layout.height / 2
+  const normalizedStartX = resolveScrollStartPosition(
+    startPositionX,
+    'scroll startPositionX',
+  )
+  const normalizedStartY = resolveScrollStartPosition(
+    startPositionY,
+    'scroll startPositionY',
+  )
+  const startSootSimX = node.absolutePosition.x + node.layout.width * normalizedStartX
+  const startSootSimY = node.absolutePosition.y + node.layout.height * normalizedStartY
   let endSootSimX = startSootSimX
   let endSootSimY = startSootSimY
 

package/detox/index.ts

@@ -13,6 +13,7 @@ import {
   dragScrollNode,
   readSootsimInteractiveViewport,
   readSootsimViewport,
+  resolveScrollStartPosition,
   sootsimToPage,
   waitForSootsimGestureHandler,
 } from './gestures'
@@ -23,6 +24,7 @@ import {
   type MotionChangeDefinition,
   type MotionChangeMeasurement,
 } from './motion-change.cjs'
+import { describeSootsimBridgeFailure, navigateSootsimPage } from './navigation-lifecycle'
 import { REQUIRED_IDENTICAL_PROOF_FRAMES, framesIdentical } from './proof-frame.cjs'
 import type { SootSimElement } from './element-types'
 import type { Browser, BrowserContext, Page } from 'playwright'
@@ -45,7 +47,10 @@ let _context: BrowserContext | null = null
 let _page: Page | null = null
 let _synchronizationEnabled = false
 let _suspendedAppId: string | null = null
-const pageDiagnostics = new WeakMap<Page, string[]>()
+let browserIdentity = 0
+let contextIdentity = 0
+let nextBrowserIdentity = 0
+let nextContextIdentity = 0
 
 const STATUS_BAR_OVERRIDE_EVENT = 'sootsim:statusBarOverride'
 
@@ -67,59 +72,6 @@ function getPage(): Page {
   return _page
 }
 
-function recordPageDiagnostic(page: Page, message: string) {
-  const entries = pageDiagnostics.get(page)
-  if (!entries) return
-  entries.push(message)
-  if (entries.length > 40) entries.shift()
-}
-
-function attachPageDiagnostics(page: Page) {
-  if (pageDiagnostics.has(page)) return
-  pageDiagnostics.set(page, [])
-  page.on('console', (message) => {
-    recordPageDiagnostic(page, `[console:${message.type()}] ${message.text()}`)
-  })
-  page.on('pageerror', (error) => {
-    recordPageDiagnostic(page, `[pageerror] ${error.message}`)
-  })
-  page.on('requestfailed', (request) => {
-    const failure = request.failure()
-    recordPageDiagnostic(
-      page,
-      `[requestfailed] ${request.method()} ${request.url()} ${failure?.errorText ?? ''}`,
-    )
-  })
-}
-
-async function describeSootsimBridgeFailure(page: Page, cause: unknown) {
-  let pageState: unknown = null
-  try {
-    pageState = await page.evaluate(() => ({
-      bodyText: document.body?.innerText?.slice(0, 500) ?? '',
-      globals: Object.keys(window)
-        .filter((key) => key.startsWith('__sootsim') || key === 'SootSim')
-        .sort(),
-      readyState: document.readyState,
-      title: document.title,
-      url: window.location.href,
-    }))
-  } catch (error) {
-    pageState = {
-      evaluateError: error instanceof Error ? error.message : String(error),
-    }
-  }
-
-  return new Error(
-    [
-      `timed out waiting for sootsim test bridge`,
-      `cause: ${cause instanceof Error ? cause.message : String(cause)}`,
-      `page: ${JSON.stringify(pageState)}`,
-      `recent page diagnostics:\n${(pageDiagnostics.get(page) ?? []).join('\n') || '(none)'}`,
-    ].join('\n'),
-  )
-}
-
 async function waitForSootsimTree(page: Page, timeout = 30000): Promise<void> {
   try {
     await page.waitForFunction(() => !!window.__sootsimTest?.waitForTree, {
@@ -324,6 +276,7 @@ async function closeContext() {
   const context = _context
   _context = null
   _page = null
+  contextIdentity = 0
   _synchronizationEnabled = false
   if (context) await context.close()
 }
@@ -334,6 +287,7 @@ async function closeBrowser() {
   const reapBrowserNow = _reapBrowserNow
   _browser = null
   _reapBrowserNow = null
+  browserIdentity = 0
   await closeContext()
   try {
     await browser.close()
@@ -943,15 +897,24 @@ function createSootSimElement(matcher: Matcher): SootSimElement {
       }
     },
 
-    async scroll(pixels: number, direction: 'up' | 'down' | 'left' | 'right') {
+    async scroll(
+      pixels: number,
+      direction: 'up' | 'down' | 'left' | 'right',
+      startPositionX?: number,
+      startPositionY?: number,
+    ) {
       const node = await findNodeByMatcher(matcher)
       if (!node)
         throw new Error(`element not found for scroll: ${JSON.stringify(matcher)}`)
       const page = getPage()
-      await dragScrollNode(page, node, pixels, direction)
+      await dragScrollNode(page, node, pixels, direction, startPositionX, startPositionY)
     },
 
-    async scrollTo(edge: 'top' | 'bottom' | 'left' | 'right') {
+    async scrollTo(
+      edge: 'top' | 'bottom' | 'left' | 'right',
+      startPositionX?: number,
+      startPositionY?: number,
+    ) {
       const node = await findNodeByMatcher(matcher)
       if (!node)
         throw new Error(`element not found for scrollTo: ${JSON.stringify(matcher)}`)
@@ -968,8 +931,16 @@ function createSootSimElement(matcher: Matcher): SootSimElement {
         )
       }
 
-      const hitX = node.absolutePosition.x + node.layout.width / 2
-      const hitY = node.absolutePosition.y + node.layout.height / 2
+      const normalizedStartX = resolveScrollStartPosition(
+        startPositionX,
+        'scrollTo startPositionX',
+      )
+      const normalizedStartY = resolveScrollStartPosition(
+        startPositionY,
+        'scrollTo startPositionY',
+      )
+      const hitX = node.absolutePosition.x + node.layout.width * normalizedStartX
+      const hitY = node.absolutePosition.y + node.layout.height * normalizedStartY
       const page = getPage()
       const result = await page.evaluate(
         async ({ edge, hitX, hitY, targetId }) => {
@@ -1348,6 +1319,7 @@ export const device = {
       )
       _browser = launched.browser
       _reapBrowserNow = launched.reapNow
+      browserIdentity = ++nextBrowserIdentity
     }
 
     if (!_page || opts?.newInstance || opts?.delete || opts?.recordVideoDir) {
@@ -1365,12 +1337,16 @@ export const device = {
       }
       _context = await _browser.newContext(contextOpts)
       _page = await _context.newPage()
-      attachPageDiagnostics(_page)
+      contextIdentity = ++nextContextIdentity
     }
 
     const url = opts?.url || BASE_URL
     device._currentUrl = url
-    await _page!.goto(url, { waitUntil: 'load', timeout: 30000 })
+    await navigateSootsimPage(_page!, url, {
+      browserId: browserIdentity,
+      contextId: contextIdentity,
+      operation: 'launchApp',
+    })
 
     await waitForSootsimTree(_page!, 30000)
     await waitForSootsimSurfaceMetrics(_page!, 30000)
@@ -1406,7 +1382,11 @@ export const device = {
 
   async openURL(url: { url: string; sourceApp?: string }) {
     const page = getPage()
-    await page.goto(url.url, { waitUntil: 'load', timeout: 30000 })
+    await navigateSootsimPage(page, url.url, {
+      browserId: browserIdentity,
+      contextId: contextIdentity,
+      operation: 'openURL',
+    })
     await waitForSootsimTree(page, 10000)
     await waitForSootsimSurfaceMetrics(page, 10000)
     await waitForSootsimShellReady(page, 10000)