rnxsim 0.1.317 → 0.1.319

package/cli/bin.ts

@@ -420,12 +420,6 @@ if (TOP_LEVEL_RUNTIME_COMMANDS.has(command)) {
       await exitWithFlush(code)
     }
 
-    case 'inspect': {
-      const { runInspect } = await import('./commands/inspect')
-      await runInspect(commandArgsWithSim, { port, verbose })
-      break
-    }
-
     case 'debug': {
       const { runDebug } = await import('./commands/debug')
       await runDebug(commandArgsWithSim, { port, verbose })
@@ -534,8 +528,7 @@ if (TOP_LEVEL_RUNTIME_COMMANDS.has(command)) {
       break
     }
 
-    case 'upgrade':
-    case 'update': {
+    case 'upgrade': {
       const { runUpgrade } = await import('./commands/upgrade')
       await runUpgrade(parsed.commandArgs)
       break

package/cli/commands/debug.ts

@@ -408,14 +408,7 @@ export async function runDebug(args: string[], opts: DebugOptions) {
   // implementation lives in inspect.ts. forward to runInspect with the raw
   // `debug` prefix intact — runInspect strips it. done before we open a
   // debug-side bridge so we don't hold two bridges at once.
-  const INSPECT_FORWARDED = new Set([
-    'state',
-    'js',
-    'eval',
-    'perf',
-    'memory',
-    'sample-color',
-  ])
+  const INSPECT_FORWARDED = new Set(['state', 'js', 'perf', 'memory', 'sample-color'])
   if (INSPECT_FORWARDED.has(sub)) {
     const { runInspect } = await import('./inspect')
     // pass the raw arg list through so every flag (--sim, --json,

package/cli/commands/detox.ts

@@ -83,14 +83,26 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
       prev === '--config' ||
       prev === '-t' ||
       prev === '--testNamePattern' ||
-      prev === '--grep'
+      prev === '--grep' ||
+      prev === '--maxWorkers' ||
+      prev === '--shard'
     )
       return false
     return true
   })
-  const passthroughJestFlags = args.filter(
-    (a) => a === '--runInBand' || a.startsWith('--maxWorkers='),
-  )
+  const passthroughJestFlags = args.flatMap((arg, index) => {
+    if (
+      arg === '--runInBand' ||
+      arg.startsWith('--maxWorkers=') ||
+      arg.startsWith('--shard=')
+    ) {
+      return [arg]
+    }
+    if ((arg === '--maxWorkers' || arg === '--shard') && args[index + 1]) {
+      return [arg, args[index + 1]]
+    }
+    return []
+  })
 
   // test dir discovery. external test suites set SOOTSIM_TEST_DIR; otherwise
   // we auto-detect the conventional locations.

package/cli/commands/flow.ts

@@ -966,8 +966,7 @@ async function runFlowSession(args: string[]) {
       return
     }
 
-    case 'keep':
-    case 'good': {
+    case 'keep': {
       const result = keepFlowCandidate()
       if (!result.active) {
         console.error('  no active flow draft — run `sootsim maestro start` first')

package/cli/commands/inspect/wait-event.ts

@@ -116,7 +116,7 @@ export async function runWaitEventSubcommand(opts: WaitEventOptions): Promise<vo
   if (!kind) {
     console.error(
       inspectUsage(
-        'wait event',
+        'event',
         '<kind> [--max-ms 5000] [--filter <substring>] [--equals <exact>] [--since now|cursor]',
       ),
     )

package/cli/commands/inspect/wait-selector.ts

@@ -13,7 +13,7 @@ export async function runWaitSelectorSubcommand(opts: {
   const { bridge, args, positional, inspectUsage } = opts
   const testId = positional[1]
   if (!testId) {
-    console.error(inspectUsage('wait selector', '<testid> [--max-ms 5000] [--gone]'))
+    console.error(inspectUsage('selector', '<testid> [--max-ms 5000] [--gone]'))
     process.exit(1)
   }
   const maxMsIdx = args.indexOf('--max-ms')

package/cli/commands/inspect.ts

@@ -1,6 +1,7 @@
 // sootsim inspect — dump node tree, accessibility info, query nodes
 // connects to the sootsim WS bridge (no Playwright)
 
+import { getCliInspectVerbMeta } from '@sootsim/skills/cli'
 import { renderCliCommandHelp, renderCliGroupHelp } from '@sootsim/skills/cli/renderers'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
 import { DEFAULT_SOOTSIM_SHELL_URL } from '../../src/cli-constants'
@@ -615,6 +616,41 @@ export function printShellPerfReport(result: Record<string, any>) {
     printPhase('CanvasKit submission', compositorCadence.canvaskitSubmission)
   }
   const surfaces = Array.isArray(result.auxSurfaces) ? result.auxSurfaces : []
+  const graphiteCaches = result.graphiteCaches
+  const decodedImageCache = result.decodedImageCache
+  if (graphiteCaches || decodedImageCache) {
+    const printCache = (
+      label: string,
+      cache: { bytes?: number; limitBytes?: number; purgeableBytes?: number } | null,
+    ) => {
+      if (typeof cache?.bytes !== 'number' || typeof cache.limitBytes !== 'number') {
+        return
+      }
+      const purgeable =
+        typeof cache.purgeableBytes === 'number'
+          ? ` · ${(cache.purgeableBytes / 1024 / 1024).toFixed(1)}MB purgeable`
+          : ''
+      console.log(
+        `      ${label.padEnd(29)} ${(cache.bytes / 1024 / 1024).toFixed(1)}MB/${(cache.limitBytes / 1024 / 1024).toFixed(1)}MB${purgeable}`,
+      )
+    }
+    console.log(``)
+    console.log(`    device-wide caches:`)
+    printCache('Graphite context resources', graphiteCaches?.contextResources ?? null)
+    printCache('Graphite recorder resources', graphiteCaches?.recorderResources ?? null)
+    printCache('Graphite image provider', graphiteCaches?.imageProvider ?? null)
+    printCache('decoded image pixels', decodedImageCache ?? null)
+    if (graphiteCaches?.imageProvider) {
+      console.log(
+        `      ${''.padEnd(29)} ${graphiteCaches.imageProvider.entries} entries · ${graphiteCaches.imageProvider.uploads} uploads · ${graphiteCaches.imageProvider.evictions} evictions`,
+      )
+    }
+    if (decodedImageCache) {
+      console.log(
+        `      ${''.padEnd(29)} ${decodedImageCache.entries} entries/${decodedImageCache.maxEntries} max`,
+      )
+    }
+  }
   if (surfaces.length > 0) {
     console.log(``)
     console.log(`    surfaces (last 100 frames):`)
@@ -622,14 +658,6 @@ export function printShellPerfReport(result: Record<string, any>) {
       console.log(
         `      ${String(s.surfaceId).padEnd(10)} ${String(s.frames).padStart(4)} paints  avg ${s.avgMs}ms (layout ${s.avgLayoutMs}, render ${s.avgRenderMs}, flush ${s.avgFlushMs})  max ${s.maxMs}ms`,
       )
-      if (
-        typeof s.gpuCacheBytes === 'number' &&
-        typeof s.gpuCacheLimitBytes === 'number'
-      ) {
-        console.log(
-          `      ${''.padEnd(10)} gpu cache ${(s.gpuCacheBytes / 1024 / 1024).toFixed(1)}MB/${(s.gpuCacheLimitBytes / 1024 / 1024).toFixed(1)}MB`,
-        )
-      }
     }
   }
   // two profiles, two workers: the shell paints chrome/overlays, the
@@ -875,9 +903,9 @@ function keyCodeToVisualKey(code: string) {
 }
 
 function getInspectCommandName(subcommand: string, directSubcommand: string | null) {
-  return directSubcommand === subcommand
-    ? `rnxsim ${subcommand}`
-    : `rnxsim inspect ${subcommand}`
+  if (directSubcommand === subcommand) return `rnxsim ${subcommand}`
+  const group = getCliInspectVerbMeta(subcommand)?.group
+  return group ? `rnxsim ${group} ${subcommand}` : `rnxsim ${subcommand}`
 }
 
 function getInspectUsage(
@@ -1062,25 +1090,24 @@ export async function runInspect(args: string[], opts: InspectOptions) {
   const positional = parsed.positional
   const subcommand = positional[0]
   // used by inspectCommand() below to format usage/error strings with the
-  // same prefix the user actually typed. when `inspect` is the entrypoint
-  // (no prefix), we prefix with `inspect` so the instructions are valid.
-  const invocationPrefix: 'get' | 'do' | 'debug' | 'wait' | 'inspect' =
-    verbPrefix === 'get' ||
-    verbPrefix === 'do' ||
-    verbPrefix === 'debug' ||
-    verbPrefix === 'wait'
-      ? verbPrefix
-      : 'inspect'
+  // same prefix the user actually typed. null when they typed a top-level
+  // command, and inspectCommand asks the registry for the group instead.
+  const invocationPrefix: 'get' | 'do' | 'debug' | 'wait' | null = verbPrefix
   const isTopLevel =
     typeof effectiveArgs[0] === 'string' &&
     TOP_LEVEL_RUNTIME_COMMANDS.has(effectiveArgs[0])
   const topLevelCommand = isTopLevel ? effectiveArgs[0] : null
-  const inspectCommand = (name: string) =>
-    opts.internalPerfCommand && name === 'perf'
-      ? `rnxsim perf ${opts.internalPerfCommand}`
-      : isTopLevel && name === effectiveArgs[0]
-        ? `rnxsim ${name}`
-        : `rnxsim ${invocationPrefix} ${name}`
+  // a usage string has to name something the user can actually type. the
+  // registry knows which group each verb belongs to, so an unprefixed
+  // invocation still renders `rnxsim get tree` rather than a bare verb.
+  const inspectCommand = (name: string) => {
+    if (opts.internalPerfCommand && name === 'perf') {
+      return `rnxsim perf ${opts.internalPerfCommand}`
+    }
+    if (isTopLevel && name === effectiveArgs[0]) return `rnxsim ${name}`
+    const group = invocationPrefix ?? getCliInspectVerbMeta(name)?.group
+    return group ? `rnxsim ${group} ${name}` : `rnxsim ${name}`
+  }
   const inspectUsage = (name: string, tail: string) =>
     `  usage: ${inspectCommand(name)}${tail ? ` ${tail}` : ''}`
 
@@ -1118,14 +1145,12 @@ export async function runInspect(args: string[], opts: InspectOptions) {
       }
     }
 
-    // catch-all `sootsim inspect --help` — the inspect command meta +
-    // each group's listing stitched together.
-    const inspectMeta = renderCliCommandHelp('inspect', docContext)
+    // catch-all help — every group's listing stitched together.
     const groupSections = ['do', 'get', 'debug', 'wait']
       .map((g) => renderCliGroupHelp(g, docContext))
       .filter((s): s is string => s != null)
       .join('\n\n')
-    console.log(`${inspectMeta ?? ''}\n\n${groupSections}\n`)
+    console.log(`${groupSections}\n`)
     process.exit(0)
   }
 
@@ -1190,7 +1215,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     'warnings',
     'requests',
     'js',
-    'eval',
     'reload',
     'globals',
     'perf',
@@ -3571,7 +3595,6 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         break
       }
 
-      case 'eval':
       case 'js': {
         const code = positional.slice(1).join(' ')
         if (!code) {
@@ -4501,7 +4524,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     }
   } catch (err: any) {
     const message = err instanceof Error ? err.message : String(err)
-    console.error(`  ${subcommand ?? 'inspect'} failed: ${message}`)
+    console.error(`  ${subcommand ?? 'rnxsim'} failed: ${message}`)
     const unknownSim = /^no sim connected with id ([^;]+)(?:; connected sims: .+)?$/.exec(
       message,
     )

package/cli/commands/maestro.ts

@@ -94,7 +94,7 @@ workspace mode (directory runs):
 
 partial:
   clearKeychain — warn-only, rnx has no keychain surface.
-  when.platform — rnx reports iOS.
+  when.platform — rnx reports iOS for this runner.
   openLink — dispatched into the app via the Linking emulation
     (react-navigation deep links work); no OS-level Safari fallback.
   launchApp.arguments — ignored; rnx has no native process.

package/cli/commands/profile.ts

@@ -18,7 +18,7 @@ function printHelp() {
 rnxsim storage profile — manage isolated storage profiles
 
 usage:
-  rnxsim storage profile ls
+  rnxsim storage profile list
   rnxsim storage profile create <id>
   rnxsim storage profile clear <id>
   rnxsim storage profile delete <id>
@@ -28,7 +28,7 @@ service workers in Electron and Playwright launches. Plain browser-tab launches
 cannot honor profiles and will fail clearly if a profile is requested.
 
 examples:
-  rnxsim storage profile ls
+  rnxsim storage profile list
   rnxsim storage profile create qa
   rnxsim open 8081 --profile qa
   rnxsim open 8081 --profile qa --driver playwright
@@ -43,10 +43,9 @@ export async function runProfile(args: string[], _opts: ProfileOptions): Promise
     return 0
   }
 
-  const subcommand = args[0] ?? 'ls'
+  const subcommand = args[0] ?? 'list'
   try {
     switch (subcommand) {
-      case 'ls':
       case 'list': {
         const profiles = listProfiles()
         for (const profile of profiles) {
@@ -85,8 +84,7 @@ export async function runProfile(args: string[], _opts: ProfileOptions): Promise
         console.log(`  cleared profile: ${id}`)
         return 0
       }
-      case 'delete':
-      case 'rm': {
+      case 'delete': {
         const id = args[1]
         if (!id) {
           console.error('  profile delete expects <id>')

package/cli/commands/runtime.ts

@@ -44,18 +44,14 @@ export async function runRuntime(args: string[], opts: RuntimeOptions = {}) {
     case 'install':
       return runtimeInstall(rest, opts)
     case 'list':
-    case 'ls':
       return runtimeList(rest)
     case 'use':
       return runtimeUse(rest)
     case 'remove':
-    case 'rm':
       return runtimeRemove(rest)
     case 'which':
-    case 'active':
       return runtimeWhich()
     case 'notes':
-    case 'changelog':
       return runtimeNotes(rest)
     default:
       console.error(`  unknown runtime subcommand: ${sub}`)

package/cli/commands/storage.ts

@@ -30,7 +30,7 @@ usage:
   rnxsim storage clear [--full] [--sim <id>] [--json]
 
 subcommands:
-  profile ls
+  profile list
   profile create <id>
   profile clear <id>
   profile delete <id>

package/cli/commands/telemetry.ts

@@ -33,14 +33,12 @@ export async function runTelemetry(args: string[]): Promise<void> {
       return
 
     case 'on':
-    case 'enable':
       writePrivacyPreferences({ ...readPrivacyPreferences(), productAnalytics: true })
       console.log('  product analytics ON')
       console.log(`  config: ${configFilePath()}`)
       return
 
     case 'off':
-    case 'disable':
       writePrivacyPreferences({ ...readPrivacyPreferences(), productAnalytics: false })
       console.log('  product analytics OFF')
       console.log(`  config: ${configFilePath()}`)

package/cli/commands/timeline.ts

@@ -74,16 +74,14 @@ export async function runTimeline(args: string[], opts: TimelineOptions) {
         console.log(JSON.stringify(status, null, json ? 0 : 2))
         break
       }
-      case 'start':
-      case 'enable': {
+      case 'start': {
         if (kinds.length === 0) kinds.push('all')
         await callInBridge(bridge, 'SootSim.bridges.timeline.enable', ...kinds)
         const status = await callInBridge(bridge, 'SootSim.bridges.timeline.status')
         console.log(JSON.stringify(status, null, json ? 0 : 2))
         break
       }
-      case 'stop':
-      case 'disable': {
+      case 'stop': {
         if (kinds.length === 0) kinds.push('all')
         await callInBridge(bridge, 'SootSim.bridges.timeline.disable', ...kinds)
         const status = await callInBridge(bridge, 'SootSim.bridges.timeline.status')

package/cli/parse-args.ts

@@ -33,7 +33,6 @@ const GLOBAL_FLAGS: Record<
 //   - `sootsim get <noun>`        reads
 //   - `sootsim do <action>`       writes
 //   - `sootsim debug <tool>`      instrumentation (handled by runDebug)
-//   - `sootsim inspect <sub>`     full legacy surface, all subcommands
 // `describe` and `find` stay at root as the most common entrypoints.
 // `list` stays at root because it's a sim-management read.
 export const TOP_LEVEL_RUNTIME_COMMANDS = new Set([
@@ -70,7 +69,6 @@ const COMMANDS = new Set([
   'reset',
   'camera',
   'mode',
-  'inspect',
   'debug',
   'timeline',
   'what-happened',
@@ -93,7 +91,6 @@ const COMMANDS = new Set([
   'daemon',
   'runtime',
   'upgrade',
-  'update',
   'version',
   'skill',
   'config',

package/detox/index.ts

@@ -608,6 +608,7 @@ type FastScreenshotData = {
   label: string
   offsetMs: number
   actualMs: number
+  captureRequestedAtMs?: number
   dataUrl: string
   frameIndex?: number
   virtualTimestampMs?: number
@@ -1854,17 +1855,44 @@ export const device = {
   async takeScreenshotStagesFast(
     namePrefix: string,
     stages: Array<{ label: string; offsetMs: number }>,
-    options?: { skipWarmup?: boolean },
-  ): Promise<Array<{ label: string; offsetMs: number; actualMs: number; path: string }>> {
-    const page = getPage()
-    const frames: Array<{
+    options: {
+      anchorAfterTrigger?: boolean
+      skipWarmup?: boolean
+      trigger: () => unknown
+    },
+  ): Promise<{
+    captureAnchorMs: number
+    frames: Array<{
       label: string
       offsetMs: number
       actualMs: number
-      dataUrl: string
-    }> = await page.evaluate(
+      captureRequestedAtMs: number
+      path: string
+    }>
+    triggerCompletedMs: number
+    triggerStartMs: number
+  }> {
+    const page = getPage()
+    const token = `timed-${process.pid}-${Date.now()}-${Math.random()}`
+    const capturePromise: Promise<{
+      captureAnchorMs: number
+      frames: Array<{
+        label: string
+        offsetMs: number
+        actualMs: number
+        captureRequestedAtMs: number
+        dataUrl: string
+      }>
+    }> = page.evaluate(
       async (input) => {
-        const sim = window as {
+        type CaptureState = {
+          anchorPerformanceMs: number | null
+          anchorWallMs: number | null
+          cancelled: boolean
+          ready: boolean
+        }
+        type CaptureWindow = Window & {
+          __sootsimTimedCaptures?: Record<string, CaptureState>
           SootSim?: {
             bridges?: {
               screenshot?: (opts?: unknown) => Promise<string>
@@ -1877,11 +1905,22 @@ export const device = {
             }
           }
         }
-        const screenshot = sim.SootSim?.bridges?.screenshot
-        const live = sim.SootSim?.bridges?.liveComposite
+        const captureWindow = window as unknown as CaptureWindow
+        const screenshot = captureWindow.SootSim?.bridges?.screenshot
+        const live = captureWindow.SootSim?.bridges?.liveComposite
         if (typeof screenshot !== 'function') {
           throw new Error('rnx screenshot bridge is not installed')
         }
+        const registry =
+          captureWindow.__sootsimTimedCaptures ??
+          (captureWindow.__sootsimTimedCaptures = {})
+        const state: CaptureState = {
+          anchorPerformanceMs: null,
+          anchorWallMs: null,
+          cancelled: false,
+          ready: false,
+        }
+        registry[input.token] = state
         // initial warm-up: ensure the worker has produced at least one
         // frame after the menu's portal mount before we start sampling.
         // (a pump at higher cadence was tried and starved tap propagation —
@@ -1890,11 +1929,18 @@ export const device = {
         if (!input.skipWarmup) {
           await screenshot({ format: 'png' })
         }
-        const start = performance.now()
+        state.ready = true
+        while (state.anchorPerformanceMs === null || state.anchorWallMs === null) {
+          if (state.cancelled) throw new Error('rnx timed capture was cancelled')
+          await new Promise((resolve) => setTimeout(resolve, 0))
+        }
+        const captureAnchorMs = state.anchorWallMs
+        const captureAnchorPerformanceMs = state.anchorPerformanceMs
         type Snapshot = {
           label: string
           offsetMs: number
           actualMs: number
+          captureRequestedAtMs: number
           dataUrl: string | null
         }
         // each stage fires at its requested offset and SYNCHRONOUSLY
@@ -1907,7 +1953,8 @@ export const device = {
             (stage) =>
               new Promise<Snapshot>((resolve) => {
                 const fire = async () => {
-                  const actualMs = performance.now() - start
+                  const actualMs = performance.now() - captureAnchorPerformanceMs
+                  const captureRequestedAtMs = Date.now()
                   try {
                     let dataUrl: string | null = null
                     if (live && typeof live.captureFresh === 'function') {
@@ -1935,6 +1982,7 @@ export const device = {
                       label: stage.label,
                       offsetMs: stage.offsetMs,
                       actualMs,
+                      captureRequestedAtMs,
                       dataUrl,
                     })
                   } catch {
@@ -1942,6 +1990,7 @@ export const device = {
                       label: stage.label,
                       offsetMs: stage.offsetMs,
                       actualMs,
+                      captureRequestedAtMs,
                       dataUrl: null,
                     })
                   }
@@ -1950,7 +1999,10 @@ export const device = {
                   () => {
                     void fire()
                   },
-                  Math.max(0, stage.offsetMs),
+                  Math.max(
+                    0,
+                    captureAnchorPerformanceMs + stage.offsetMs - performance.now(),
+                  ),
                 )
               }),
           ),
@@ -1959,6 +2011,7 @@ export const device = {
           label: string
           offsetMs: number
           actualMs: number
+          captureRequestedAtMs: number
           dataUrl: string
         }> = []
         for (const snap of snaps) {
@@ -1967,14 +2020,101 @@ export const device = {
             label: snap.label,
             offsetMs: snap.offsetMs,
             actualMs: snap.actualMs,
+            captureRequestedAtMs: snap.captureRequestedAtMs,
             dataUrl: snap.dataUrl,
           })
         }
-        return out
+        delete registry[input.token]
+        return { captureAnchorMs, frames: out }
       },
-      { stages, skipWarmup: options?.skipWarmup === true },
+      { stages, skipWarmup: options.skipWarmup === true, token },
     )
-    return writeFastScreenshotFrames(namePrefix, frames)
+
+    await page.waitForFunction(
+      (captureToken) => {
+        const registry = (
+          window as Window & {
+            __sootsimTimedCaptures?: Record<string, { ready: boolean }>
+          }
+        ).__sootsimTimedCaptures
+        return registry?.[captureToken]?.ready === true
+      },
+      token,
+      { timeout: 5000 },
+    )
+
+    const armCapture = (anchorMs?: number) =>
+      page.evaluate(
+        ({ anchorMs, captureToken }) => {
+          const registry = (
+            window as Window & {
+              __sootsimTimedCaptures?: Record<
+                string,
+                {
+                  anchorPerformanceMs: number | null
+                  anchorWallMs: number | null
+                  ready: boolean
+                }
+              >
+            }
+          ).__sootsimTimedCaptures
+          const capture = registry?.[captureToken]
+          if (!capture?.ready) throw new Error('rnx timed capture was not armed')
+          const nowMs = Date.now()
+          capture.anchorWallMs = anchorMs ?? nowMs
+          capture.anchorPerformanceMs = performance.now() - (nowMs - capture.anchorWallMs)
+          return capture.anchorWallMs
+        },
+        { anchorMs, captureToken: token },
+      )
+
+    let triggerStartMs = 0
+    let triggerCompletedMs = 0
+    try {
+      let captureAnchorMs: number
+      if (options.anchorAfterTrigger === false) {
+        captureAnchorMs = await armCapture()
+        triggerStartMs = captureAnchorMs
+        const triggerPromise = Promise.resolve()
+          .then(options.trigger)
+          .then(() => {
+            triggerCompletedMs = Date.now()
+          })
+        const [capture] = await Promise.all([capturePromise, triggerPromise])
+        return {
+          captureAnchorMs,
+          frames: writeFastScreenshotFrames(namePrefix, capture.frames),
+          triggerCompletedMs,
+          triggerStartMs,
+        }
+      }
+
+      triggerStartMs = Date.now()
+      await Promise.resolve(options.trigger())
+      triggerCompletedMs = Date.now()
+      captureAnchorMs = await armCapture(triggerCompletedMs)
+      const capture = await capturePromise
+      return {
+        captureAnchorMs,
+        frames: writeFastScreenshotFrames(namePrefix, capture.frames),
+        triggerCompletedMs,
+        triggerStartMs,
+      }
+    } catch (error) {
+      await page
+        .evaluate((captureToken) => {
+          const registry = (
+            window as Window & {
+              __sootsimTimedCaptures?: Record<string, { cancelled: boolean }>
+            }
+          ).__sootsimTimedCaptures
+          const capture = registry?.[captureToken]
+          if (capture) capture.cancelled = true
+        }, token)
+        .catch(() => {})
+      await capturePromise.catch(() => {})
+      throw error
+    }
   },
 
   // batched multi-stage capture for animation diffs. all N captures happen

package/detox/jest-preset.cjs

@@ -17,7 +17,6 @@ module.exports = {
   testTimeout: 180000,
   maxWorkers: 1,
   watchman: false,
-  forceExit: true,
   verbose: true,
   testEnvironment: 'node',
   setupFilesAfterEnv: [path.join(PACKAGE_ROOT, 'detox', 'jest-setup-after-env.cjs')],