wix/Detox

This system is Detox, an end-to-end testing framework for React Native applications that automates UI interactions on Android and iOS devices. It provides a unified JavaScript API to drive native elements, manage device lifecycles, and execute tests via Jest, while handling complex synchronization between the JavaScript test runner and native app threads. The framework includes native instrumentation layers for both platforms to ensure reliable element matching, action execution, and state monitoring during automated test runs.

56 changes.

This period centered on restructuring Detox into a monorepo and modernizing its core architecture, including migrating iOS code to Swift and establishing a robust WebSocket-based client-server communication model. Significant efforts were dedicated to building comprehensive Android support via Espresso integration, implementing a modular plugin system for test artifacts, and creating extensive end-to-end test suites to validate the new framework capabilities.

86 changes.

This period focused on the foundational rewrite of Detox into 'Detox Next,' introducing a new iOS runner via XCUITest and a complete migration of the Android backend to Espresso. The work established a modular architecture for device allocation, CLI commands, and artifact recording, while implementing native expectation and action APIs for both platforms to replace legacy implementations.

53 changes.

This period focused on comprehensive support for React Native's New Architecture (Fabric) and modern RN versions, introducing architecture-aware idling resources to eliminate test flakiness. It also involved a major architectural overhaul of the test runner, replacing legacy Jest adapters with a custom environment and listener system, while establishing robust IPC and device lifecycle management.

Detox now supports reading and setting values for Android Material and React Native sliders, as well as checking UI controller idle states, by introducing new helper classes that use reflection to interact with internal view properties and managers.

detox/android/detox/src/full/java/com/wix/detox/espresso/common · high confidence

A new DescriptiveIdlingResource interface has been introduced in the Espresso idling resources module, extending the standard IdlingResource to include getDebugName and getBusyHint methods. This addition enables Detox to provide more descriptive names and busy hints for idling resources, improving the clarity of status inquiries and debugging information during test execution.

detox/android/detox/src/full/java/com/wix/detox/espresso/idlingresources · high confidence

New example projects have been added to demonstrate Detox integration with native platforms. The SwiftExample provides a pure Swift iOS application, while demo-native-ios and demo-native-android offer Objective-C and Java-based native apps respectively. These examples serve as reference implementations for setting up Detox in non-React Native native environments.

examples · high confidence

This change introduces the \SimulatorInstrumentsPlugin\ and \SimulatorInstrumentsRecording\ classes within the iOS instruments artifacts module, enabling the capture of performance traces on iOS simulators. The plugin automatically injects \recordingPath\ and \samplingInterval\ into the app's launch arguments before the test starts, allowing users to configure the trace sampling rate via \userConfig.samplingInterval\ (which is converted from milliseconds to seconds) and override the Detox Instruments binary location via the \DETOX\_INSTRUMENTS\_PATH\ environment variable. The recording implementation handles saving the \.dtxrec\ artifact to the final path or discarding it, providing specific user warnings if the save fails due to missing Detox Instruments integration.

detox/src/artifacts/instruments/ios · high confidence

The Android Detox native module now exposes scroll and tap interaction capabilities. Users can perform single, double, and multi-taps via the new DetoxViewActions object, and can scroll views up, down, left, or right by a specified amount in density-independent pixels (dp) with optional start offsets.

detox/android/detox/src/coreNative · high confidence

Detox now supports capturing video recordings of test executions. For Android devices, the new ADB screen recorder plugin records video via ADB and pulls the file upon test completion. For iOS simulators, the simulator video recording plugin leverages AppleSimUtils to record and save the video. Users can configure this feature via the artifacts configuration, choosing to record for all tests or only failing ones.

detox/src/artifacts/video · high confidence

Detox now includes specific invocation targets for Android's Espresso framework, enabling direct interaction with Espresso APIs. New files define the target classes for \androidx.test.espresso.Espresso\ and \androidx.test.espresso.web.sugar.Web\, allowing users to invoke methods on these classes directly within their test scripts.

detox/src/invoke · high confidence

The Android module now includes the standard Gradle wrapper scripts (gradlew, gradlew.bat), the .gitignore file for Android build artifacts, and the initial project setup files. This enables local building and testing of the Android component using the bundled Gradle distribution without requiring a pre-installed Gradle environment.

detox/android · high confidence

Detox now includes a new \AnimatedModuleIdlingResource\ for Android that monitors the React Native \NativeAnimatedModule\ to ensure animations have completed before proceeding with tests. This resource uses the \Choreographer\ to track frame callbacks and checks for active animations via the \NativeAnimatedNodesManager\, preventing test flakiness caused by asynchronous UI updates.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/animations · high confidence

Detox now supports synchronization with the React Native Fabric UI manager on Android. This new \FabricUIManagerIdlingResources\ component monitors the internal mount item queues (accessed via reflection to support RN 0.81+ field naming changes) and uses a 1.5-second tolerance window to handle edge-to-edge rendering artifacts, ensuring tests wait for UI updates to complete before proceeding.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/fabric · high confidence

The Android Detox module now includes the jOOQ Reflect library (org.joor.Reflect), providing a fluent API for performing Java reflection operations such as wrapping classes, invoking constructors, and calling methods. This addition enables more convenient and less verbose reflective access to Java objects and classes within the Android runtime environment.

detox/android/detox/src/main/java/org · high confidence

A new RNHelpers class has been introduced in the Android Detox helpers package to safely resolve React Native native modules by class name. This utility handles class loading and module existence checks, returning the requested NativeModule if found or null with debug logging if the class or module is missing, thereby preventing crashes during module resolution.

detox/android/detox/src/full/java/com/wix/detox/reactnative/helpers · high confidence

Introduced a new utility module at detox/src/utils/rn-consts/rn-consts.js that exposes the detected React Native version (parsed into major, minor, and patch components) and a boolean flag indicating whether the React Native New Architecture is enabled. The version detection safely falls back to a default placeholder if the react-native package cannot be resolved, enabling downstream components to adapt behavior based on the specific RN version or architecture configuration.

detox/src/utils/rn-consts · high confidence

A new MQThreadsReflector class has been introduced in the idling resources looper package to access React Native's internal message queue threads (JS and Native Modules) via reflection. This component enables Detox to identify and monitor the specific Looper threads associated with these queues, which is essential for accurately detecting when the React Native application is idle during end-to-end tests.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/looper · high confidence

Detox now includes a new NetworkIdlingResource for Android that monitors in-flight HTTP requests made by React Native's OkHttpClient. This resource tracks busy network calls to prevent test flakiness caused by asynchronous network activity. It uses reflection to access the underlying OkHttp dispatcher, with logic to handle field name differences between React Native versions prior to and after 0.80, and allows users to configure a blacklist of URLs to exclude from idle checks.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/network · high confidence

Added Android support for Instruments artifact recording, allowing users to capture profiling data on Android devices. The new AndroidInstrumentsPlugin injects recording path and optional sampling interval into app launch arguments, while AndroidInstrumentsRecording handles saving and discarding artifacts via ADB commands.

detox/src/artifacts/instruments/android · high confidence

The Android platform now supports the \expect\ and \waitFor\ assertion APIs, allowing users to write assertions like \toBeVisible\, \toHaveText\, and \toBeFocused\ on native elements. This change introduces the \AndroidExpect\ class which wires up matchers (such as \by.id\, \by.label\, and \by.accessibilityLabel\) to native element wrappers, enabling standard Detox assertion flows on Android devices.

detox/src/android · high confidence

Detox now records Android device logs (logcat) during test execution. This change introduces the ADBLogcatPlugin and ADBLogcatRecording classes, which capture logs starting from the app launch timestamp and save them as artifacts for debugging purposes.

detox/src/artifacts/log/android · high confidence

The Android view hierarchy XML output now includes a density attribute on the root element, providing screen density context for the captured UI tree. Additionally, the hierarchy generator has been updated to serialize WebView content by injecting a JavaScript snippet that extracts the DOM structure, ensuring that web views are represented in the hierarchy rather than being skipped or causing errors.

detox/android/detox/src/full/java/com/wix/detox/espresso/hierarchy · high confidence

The local CLI has been completely rewritten to use the yargs framework, introducing a modular command structure. New commands include 'detox build' (with --if-missing support for multi-app builds), 'detox start' (to run app start scripts), 'detox run-server' (to start a standalone server on a configurable port), 'detox init' (to generate a new .detoxrc.js config and e2e folder), and framework cache management commands ('build-framework-cache', 'clean-framework-cache', 'rebuild-framework-cache', 'reset-lock-file'). The 'detox test' command now supports detached runners, REPL mode, and configurable environment variable forwarding via testRunner.forwardEnv.

detox/local-cli · high confidence

The \DTXAppleInternals.h\ header in the AppleInternals module now exposes a comprehensive set of private UIKit and system interfaces, including methods for \UIWindowScene\, \UIWindow\, and \UIView\ (such as \\_keyWindowScene\ and \\_accessibilityHitTestSubviews\), as well as private event classes like \UIInternalEvent\ and \UITouchesEvent\. This addition enables the automation framework to interact with low-level iOS internals, such as retrieving the key window scene and simulating touch events, which are necessary for advanced device control and visibility checks.

detox/ios/Detox/AppleInternals · high confidence

This change introduces a new set of generated JavaScript files in the \detox/src/android/espressoapi\ directory that serve as the bridge between Detox and the Android Espresso framework. These files—\Detox.js\, \DetoxAction.js\, \DetoxAssertion.js\, \DetoxMatcher.js\, \DetoxViewActions.js\, \EspressoDetox.js\, \UIAutomator.js\, \UIDevice.js\, \ViewActions.js\, and their associated proxy and test files—expose low-level Android UI automation capabilities such as element matching, view actions (click, type, swipe), assertions, and device interactions (key presses, orientation changes) to the Detox test runner. This generation mechanism replaces or supplements manual implementation, ensuring that the Android driver stays synchronized with the underlying Espresso and UIAutomator APIs.

detox/src/android/espressoapi · high confidence

Detox now supports testing web views on Android via a new Espresso-Web integration. This change introduces generated API bindings (DetoxWebAtomMatcher, EspressoWebDetox, WebElement, WebExpect, WebViewElement) that allow users to locate and interact with web elements using matchers like ID, CSS selector, or XPath, and perform actions such as tapping, typing, and running JavaScript. The API also includes assertion methods like toExist and toHaveText, along with helper scripts for cursor and selection management.

detox/src/android/espressoapi/web · high confidence

This change adds the core Android implementation classes for Detox's element interactions and assertions, replacing or supplementing previous platform-specific logic. The new \NativeElement\ class provides the concrete implementation for actions such as tap, long press, swipe, scroll, type text, and screenshot, while \NativeExpect\ and \NativeWaitFor\ expose the assertion API (e.g., \toBeVisible\, \toHaveText\, \toBeFocused\) for both synchronous and asynchronous checks. Additionally, \WebElement\ and \WebViewElement\ classes are introduced to handle web view interactions, including script execution and text manipulation, with \WebExpect\ providing web-specific assertions. The \NativeMatcher\ class supports building complex view locators with ancestor/descendant and logical operators.

detox/src/android/core · high confidence

Added DetoxPolicy to centralize configuration for visibility checks and interaction behavior. Users can now rely on a default 75% pixel coverage threshold for visibility expectations (previously implicit or hardcoded elsewhere) and a 0.5 alpha threshold for pixel-level visibility. The policy also defines a threshold of 12 consecutive touch points with the same content offset, likely influencing scroll or swipe detection stability. A helper method for formatting percentage descriptions is also provided.

detox/ios/Detox/Policy · high confidence

Added a new XCUITest-based runner (\DetoxXCUITestRunner\) for iOS, replacing the previous implementation. This new runner supports system and web actions (tap, type, replace, clear, coordinate tap/long press) and expectations (element existence), utilizing native XCUITest APIs for interaction and predicate-based element finding.

detox/ios/DetoxXCUITestRunner · high confidence

The repository now includes a dedicated \generation\ module that automates the creation of JavaScript adapters for native testing frameworks. For Android, it parses Java source files (such as Espresso's \DetoxAction\ and \ViewActions\) and generates corresponding JavaScript wrappers with runtime type checking and argument sanitization. For iOS, it generates wrappers for EarlGrey actions (like \GREYActions\) and matchers. This system centralizes the adaptation logic, ensuring that the JavaScript API stays synchronized with the underlying native implementations while providing robust validation for method arguments.

generation · high confidence

Detox now uses a new ArtifactsManager subsystem that manages test artifacts (such as screenshots and logs) through a plugin-based architecture. This change introduces a configurable manager that accepts plugin factories and user configuration, allowing plugins to hook into specific lifecycle events like test start, test failure, and app readiness. The manager handles artifact path building and provides an API for plugins to track and untrack artifacts, enabling more flexible and structured artifact collection during test runs.

detox/src/artifacts · high confidence

Added a new \detox-cli\ executable (\cli.js\) that acts as a wrapper to spawn the local Detox binary or the Detox Recorder. The wrapper ensures the local \node\_modules/.bin\ directory is prioritized in the \PATH\ environment variable, fixing issues where global installations might interfere. It specifically handles Windows by locating the \PATH\ environment variable case-insensitively and using \cmd /c\ for spawning the \.cmd\ binary. Additionally, it adds support for the \detox recorder\ command on macOS (Darwin) by spawning the \DetoxRecorderCLI\.

detox-cli · high confidence

Adds the initial Android native implementation for Detox actions, including custom tap handling (single, double, and long-press) that injects motion events in a single batch to fix timing issues, and a new scrolling engine using \DetoxSwipe\ and \LinearSwiper\ for improved precision and accuracy. The update also introduces \scrollToIndex\ for React Native scroll views, \longPressAndDrag\ support, and the ability to take element screenshots.

detox/android/detox/src/main · high confidence

This change adds the foundational Android-side components for Detox-Native on Android. It introduces DetoxConfig and DetoxIdlePolicyConfig to manage test settings, specifically overriding Espresso's default idling timeouts to prevent failures on slower CI machines. It also adds the DetoxInstrumentsManager and related reflection-based classes (InstrumentsReflected, InstrumentsRecordingReflected) to interface with the com.wix.detoxprofiler library for performance profiling and JSI hook installation, alongside a new UiAutomator helper for accessing the Android UiDevice instance.

detox/android/detox/src/full/java/com/wix/detox/config, detox/android/detox/src/full/java/com/wix/detox/instruments, detox/android/detox/src/full/java/com/wix/detox/uiautomator · high confidence

The logger module in detox/src/logger has been replaced with a new DetoxLogger implementation that writes structured logs to JSONL files while maintaining plain-text output. Users can now enable console method overriding via the new overrideConsole configuration option, allowing Detox log messages to appear directly in the console alongside application output. The logger supports hierarchical child loggers with category merging, configurable log levels, and proper file stream management including safe closure on Windows.

detox/src/logger · high confidence

This change introduces the initial phase of Detox Next for iOS, replacing the legacy test execution flow with a new \XCUITestRunner\ that invokes the native XCUITest runner via \xcodebuild\ and passes invocation parameters as base64-encoded JSON. It adds a new \expectTwo\ API layer that structures element matchers, expectations (such as \toBeVisible\, \toHaveText\, and \toBeFocused\), and actions (like \tap\, \longPress\, and \getAttributes\) into explicit invocation objects, supporting modifiers like \.not\ and index-based selection via \.atIndex\. The update also adds dedicated APIs for interacting with system elements (\system\) and web views (\web\), including support for secured web interactions via \.asSecured()\ and new matchers for web content.

detox/src/ios · high confidence

The Detox framework now includes its own assertion infrastructure (DTXAssertionHandler) with dedicated macros (DTXAssert, DTXViewAssert, etc.) and Swift wrappers. This allows test assertions to be caught and converted into structured NSError objects with view descriptions, enabling more robust error reporting and recovery during test execution rather than crashing the process immediately.

detox/ios/Detox/Assertions · high confidence

Detox introduces a new \RuntimeDevice\ class in \detox/src/devices/runtime\ that serves as the primary interface for device operations. This class consolidates device actions such as launching, terminating, and resetting apps, while managing app selection, launch arguments, and process tracking. It delegates low-level hardware interactions to platform-specific device drivers and integrates with event emitters and error composers to provide a unified runtime environment for test execution.

detox/src/devices/runtime · high confidence

Detox for Android now supports interacting with React Native sliders via the new \AdjustSliderToPositionAction\, which handles both standard \AppCompatSeekBar\ and Material sliders. The framework also introduces \RNDetoxAccessibilityAction\ to dispatch custom accessibility actions to React Native components, and \DetoxTypeTextAction\ to reliably focus and type text into input fields. These changes enhance the reliability of UI interactions for these specific component types.

detox/android/detox/src/full/java/com/wix/detox/espresso/action · high confidence

Detox now provides a new, native Android API for interacting with WebViews using Espresso Web, allowing users to locate and manipulate web elements directly within Android tests. This change introduces a new set of classes (WebViewElement, WebElement, WebExpect) that expose methods for tapping, typing, scrolling, retrieving text, and executing JavaScript scripts inside WebViews. The implementation includes specific support for react-native-webview versions \>= 13.0.0 by correctly handling the RNCWebViewWrapper structure, and sets a 30-second timeout for web element interactions to improve reliability.

detox/android/detox/src/full/java/com/wix/detox/espresso/web · high confidence

Detox now includes new native JavaScript implementations for Android actions in \detox/src/android/actions\. The \native.js\ file adds support for specific UI interactions including \scrollToIndex\, \setDatePickerDate\, \adjustSliderToPosition\, \getAttributes\, and \performAccessibilityAction\, alongside existing actions like tap, long press, swipe, and scroll. The \web.js\ file introduces a parallel set of actions for interacting with web views within Android apps, enabling operations such as tapping, typing, replacing text, scrolling to views, running JavaScript scripts, and asserting element existence or text content.

detox/src/android/actions · high confidence

This change introduces several new Espresso matcher implementations in the Android Detox module to improve element identification reliability. A custom \IsDisplayingAtLeastDetoxMatcher\ replaces the standard \isDisplayingAtLeast\ to correctly calculate visible area for React Native views, addressing issues with \getGlobalVisibleRect\. Regex support is added via \RegexMatcher\, allowing pattern-based matching for accessibility labels, text, content descriptions, and tags. Additionally, \ViewAtIndexMatcher\ enables selecting elements by their index among matches, and \toHaveSliderPosition\ provides specific matching for slider components.

detox/android/detox/src/full/java/com/wix/detox/espresso/matcher · high confidence

A new AppStartCommand class has been introduced in the CLI to handle the execution and termination of app processes. This component wraps the execa library to spawn commands, providing structured logging and a promise-based interface that resolves or rejects based on the process exit code or signal. It supports a 'forceSpawn' mode to treat errors as warnings and allows graceful stopping of the process via a kill signal, forming the underlying mechanism for the 'detox start' and 'detox test --start' capabilities.

detox/local-cli/startCommand · high confidence

The \detox test\ command now includes a dedicated \TestRunnerCommand\ implementation that supports retrying failed test files, forwarding CLI configuration options as environment variables (e.g., \DETOX\_RETRIES\, \DETOX\_HEADLESS\), and executing app start scripts before tests. It also introduces a \--repl\ debugging mode and warns when the \DETOX\_ARGV\_OVERRIDE\ environment variable is used for ad-hoc troubleshooting.

detox/local-cli/testCommand · high confidence

Detox now provides a custom \ViewAssertions.matches\ implementation for Android that differs from standard Espresso behavior. Instead of throwing a \NoMatchingViewException\ when a view is not found in the hierarchy, this new assertion invokes the matcher with a null view, allowing for more flexible assertion logic within Detox's separated interaction-matcher architecture.

detox/android/detox/src/full/java/com/wix/detox/espresso/assertion · high confidence

Detox introduces a new inter-process communication (IPC) layer using the \node-ipc\ library to facilitate communication between the test runner (client) and the device driver/server. This change adds \IPCClient\ and \IPCServer\ classes that manage a shared \SessionState\ (including test results, worker counts, and teardown flags) across processes. The server exposes handlers for device allocation/deallocation, test result reporting, and context registration, while the client provides methods to trigger these actions and receive updates, enabling more robust coordination in detached or parallel execution modes.

detox/src/ipc · high confidence

Added the InstrumentsArtifactPlugin and InstrumentsArtifactRecording classes to handle iOS Instruments profiling artifacts. The plugin manages the recording lifecycle by starting a nominal recording on app launch and stopping it before app uninstall, termination, or device shutdown. The recording class handles the actual start and stop commands sent to the client, supporting a configurable sampling interval and ensuring operations only occur when the client is connected.

detox/src/artifacts/instruments · high confidence

Detox introduces a new set of Jest test environment listeners to manage test execution and output. The new DetoxCoreListener handles core lifecycle events, including test start/finish, describe block boundaries, and hook failures, while also exposing Detox's expect globals. A new SpecReporter provides detailed, colored console output for test suites and individual test invocations. Platform-specific tests can now be filtered using the DetoxPlatformFilterListener, which skips tests tagged with non-matching platform identifiers. Additionally, a REPLListener enables interactive debugging by launching a REPL session on test or hook failures, and a WorkerAssignReporter logs which device is assigned to which test file.

detox/runners/jest/testEnvironment/listeners · high confidence

Detox now uses a custom Jest test environment (\DetoxCircusEnvironment\) that extends NodeEnvironment via \jest-environment-emit\. This change introduces a pluggable listener system, allowing users to register custom event listeners (such as \DetoxCoreListener\, \SpecReporter\, and \REPLListener\) to intercept and handle Jest test events. The environment manages Detox initialization and cleanup lifecycle hooks and supports synchronous and asynchronous event handling with configurable timeouts, enabling deeper integration with Jest's test runner and third-party reporters.

detox/runners/jest/testEnvironment · high confidence

Detox now uses a new factory in the Android module to automatically select the correct idling resource strategy based on whether the app is running on the New Architecture (Fabric) or the legacy bridge. This ensures that UI, animation, timer, network, and async storage idling resources are correctly registered for the active React Native implementation, improving test stability across both architectures.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/factory · high confidence

Added new utility classes and functions in the artifacts utils module to handle artifact path construction. This includes \AndroidDevicePathBuilder\ for generating temporary artifact paths on Android devices (e.g., \/sdcard/...\), \ArtifactPathBuilder\ for creating structured paths for test artifacts based on test status (pass/fail) and invocation count, \buildDefaultArtifactsRootDirpath\ for generating timestamped root directories, \getTimeStampString\ for consistent timestamp formatting, and \temporaryPath\ for managing temporary files with specific extensions (json, png, log, etc.) and finding them by pattern. Tests were added for all new utilities.

detox/src/artifacts/utils · high confidence

Detox introduces a new artifact template system in \detox/src/artifacts/templates/artifact\ that standardizes how test artifacts (like screenshots and logs) are managed. The \Artifact\ base class provides a unified lifecycle with \start\, \stop\, \save\, and \discard\ methods, ensuring proper sequencing and state handling. The \FileArtifact\ class extends this to handle file-based artifacts, supporting temporary file relocation, appending to existing files, and safe cleanup. This change provides a more robust and consistent way to capture and store test artifacts during test execution.

detox/src/artifacts/templates/artifact · high confidence

Detox introduces a new device allocation lifecycle that adds a \postAllocate\ step to the device provisioning process. The \DeviceAllocator\ now delegates to a driver's optional \postAllocate\ method after initial allocation, allowing drivers to perform additional setup or modify the device cookie before the device is returned to the test runner. This change is supported by a new \DeviceRegistry\ for tracking device state across sessions and a \DeviceList\ utility for managing device collections, ensuring robust handling of device allocation, release, and cleanup.

detox/src/devices/allocation · high confidence

Detox introduces a new LogArtifactPlugin that captures device logs during test execution and saves them as artifacts. The plugin supports three configuration modes: 'all' (records logs for all tests), 'failing' (records logs only for failed tests), and 'none' (disables logging). When enabled, logs are saved as JSON and plain text files named with the process ID, and startup logs are saved with the device ID and timestamp. The plugin integrates with the existing artifacts subsystem and includes tests for the configuration parsing logic.

detox/src/artifacts/log · high confidence

Detox introduces a new Swift-based invocation system (Action, Element, Expectation, Predicate) that replaces the previous implementation, providing a structured foundation for test actions and assertions. This update significantly enhances WKWebView interaction by adding dedicated WebAction and WebExpectation types, allowing users to perform actions like tap, typeText, and runScript, as well as expectations like toHaveText, directly on web views. The framework also includes a mechanism to disable WebKit security restrictions via the \detoxDisableWebKitSecurity\ flag to bypass CORS issues during testing, and improves element matching by filtering out internal React Native accessibility bridges.

detox/ios/Detox/Invocation · high confidence

Detox introduces a suite of new internal utilities in \detox/src/utils\ to support its new client-server implementation and global lifecycle. This includes \AsyncEmitter\ for managing asynchronous event listeners, \Deferred\ for handling promise states, \ExclusiveLockfile\ for coordinating access to shared resources via file locking, \Timer\ for managing timeouts and action races, and \PIDService\ for process identification. Additionally, several helper modules are added for argument parsing (\argparse\), argument validation (\assertArgument\, \assertIsFunction\), file path handling (\appdatapath\, \constructSafeFilename\), and environment utilities (\envUtils\). Comprehensive unit tests are provided for all new components.

detox/src/utils · high confidence

Detox introduces a new set of stream utilities in \detox/src/logger/utils/streams\ to handle log processing and export. The \BunyanTransformer\ merges multiple session log files by timestamp and converts Bunyan JSON logs into plain text debug streams. The \ChromeTraceTransformer\ converts Bunyan log records into Chrome Trace Event format, handling process and thread ID mapping for visualization. Supporting components include \DetoxJSONLParser\ for parsing JSONL input, \JSONLStringer\ for serializing output to JSONL or JSON, and generic \transformers\ for stream manipulation.

detox/src/logger/utils/streams · high confidence

Detox introduces a new modular screenshot artifact system that replaces previous ad-hoc screenshot logic. The core \ScreenshotArtifactPlugin\ provides a configurable base class supporting modes like 'all', 'failing', 'manual', and 'none', with automatic screenshot capture for 'appNotReady' states by default. Platform-specific implementations are provided: \ADBScreencapPlugin\ for Android devices using ADB screencap and pull commands, and \SimulatorScreenshotPlugin\ for iOS simulators using AppleSimUtils, which also handles visibility debug screenshots on test failures. This change standardizes how screenshots are captured, stored, and cleaned up across different device types.

detox/src/artifacts/screenshot · high confidence

Detox now includes a set of new formatters in the sync-resources module that provide detailed, structured reports when the app is busy. These formatters cover specific resource types including JavaScript timers, native timers, UI elements (such as pending animations and layout needs), network requests, background threads, run loops, and delayed selectors. By extracting these into dedicated modules, the sync status output is now more granular and readable, helping users identify exactly which subsystems are blocking execution.

detox/src/client/actions/formatters/sync-resources · high confidence

This change introduces a suite of new utility components and a dedicated view-matching system within the Detox iOS utilities. It adds \UIView+DetoxMatchers\ to provide robust, predicate-based view hierarchy traversal that correctly handles accessibility containers and sorts results by screen coordinates. Additionally, it includes \DTXRunLoopSpinner\ for controlled runloop draining, \DTXDurationFormatter\ for human-readable time reporting, \DetoxCrashHandler\ for enhanced crash diagnostics, \DetoxInstrumentsManager\ for profiler integration, and Swift dispatchers for user activities and notifications.

detox/ios/Detox/Utilities · high confidence

The logging subsystem in \detox/src/logger/utils\ has been rewritten to use Bunyan as the underlying logger, introducing a new \BunyanLogger\ class that manages debug and file streams. This change adds structured tracing capabilities via \ThreadDispatcher\ and \CategoryThreadDispatcher\ for managing trace events, and a \DetoxLogFinalizer\ that converts JSONL logs into plain text and Chrome Trace format artifacts. Additionally, \customConsoleLogger\ now proxies standard console methods to the Bunyan logger, and \sanitizeBunyanContext\ ensures reserved properties are escaped to prevent conflicts.

detox/src/logger/utils · high confidence

Detox now supports React Native's new architecture (Fabric) by detecting the enabled state via DefaultNewArchitectureEntryPoint and routing context retrieval and event listening through the appropriate API (ReactHost for Fabric, ReactInstanceManager for legacy). A new ReactNativeLoadingMonitor ensures tests wait for the correct ReactContext after reloads or initial boot, and ReactMarkersLogger attaches to ReactMarker for RN 71+ to expose internal lifecycle events. Additionally, an OnBackPressedCallback is registered on Android API 35+ for legacy RN versions to ensure hardware back presses are handled by React Native's JS BackHandler instead of finishing the activity.

detox/android/detox/src/full/java/com/wix/detox/reactnative · high confidence

The iOS Detox utility now supports reloading apps built with the React Native New Architecture. The \reloadApp\ method attempts to trigger a reload via the new \didReceiveReloadCommand\ selector on the React host (accessed through \rootViewFactory\), falling back to the legacy \requestReload\ bridge method or the \RCTReloadNotification\ if the new path is unavailable. This ensures compatibility with both old and new React Native architectures during automated testing.

detox/ios/Detox/Utilities/ReactNativeSupport · high confidence

The Android test runner now distinguishes between single-view and multi-view actions. When an action targets multiple views, the system iterates through all matching elements, executes the action on each, and aggregates the results into a map under the 'elements' key; if only one view matches, the single result is returned directly. This change introduces the \MultipleViewsActionPerformer\ and \SingleViewActionPerformer\ classes, coordinated by the \ViewActionPerformer\ factory, to handle these distinct execution paths.

detox/android/detox/src/full/java/com/wix/detox/espresso/performer · high confidence

Detox now automatically captures and saves the iOS UI hierarchy (view hierarchy) as an artifact when a test fails. This is implemented via the new IosUIHierarchyPlugin, which listens for test failure events, registers the hierarchy snapshot, and ensures these artifacts are saved before the app is uninstalled. The feature respects the \detoxDisableHierarchyDump\ launch argument, allowing users to disable hierarchy dumping if needed.

detox/src/artifacts/uiHierarchy · high confidence

The Mocha runner integration has been removed in Detox v20.0.0. The adapter files in the Mocha runner directory now point to a deprecation module, and TypeScript definitions indicate that the integration is no longer supported. Users must migrate to a supported test runner.

detox/runners/mocha · high confidence

The device allocation system has been refactored to use a new factory pattern located in \detox/src/devices/allocation/factories\. This change introduces a \DeviceAllocatorFactory\ base class and specific implementations for Android (emulators, attached devices, GenyCloud), iOS (simulators), and external custom drivers. This structure centralizes the creation of allocation drivers, allowing for a more modular and extensible device management lifecycle.

detox/src/devices/allocation/factories · high confidence

The device runtime initialization logic has been restructured into a new factory pattern located in \detox/src/devices/runtime/factories\. This change introduces a base \RuntimeDeviceFactory\ that standardizes how runtime devices are created, alongside specific implementations for Android (\AndroidEmulator\, \AndroidAttached\, \Genycloud\), iOS (\IosSimulator\), and external/custom drivers (\External\). The Android factory now explicitly wires up dependencies like ADB, AAPT, and APK validation tools, while the iOS factory configures AppleSimUtils and supports headless mode. The external factory adds validation to ensure custom driver modules export the required \RuntimeDriverClass\. This refactoring centralizes driver instantiation and dependency injection for different device types.

detox/src/devices/runtime/factories · high confidence

The iOS native implementation has been reorganized into a standalone \Detox\ framework module, replacing the previous monolithic structure. This change introduces a formal module map (\Detox.modulemap\) that explicitly separates public headers (like \Detox.h\) from private implementation details (such as \DetoxAppDelegateProxy.h\ and various \UIView\ extensions). The codebase has been partially migrated to Swift, with core management logic now residing in \DetoxManager.swift\, while Objective-C components like \DetoxAppDelegateProxy.m\ handle app delegate interception and event dispatching. This modularization improves build isolation and clarifies the boundary between the public API and internal synchronization mechanisms.

detox/ios/Detox · high confidence

The Detox Xcode project now includes a shared scheme (Detox.xcscheme) that configures the build and test environment for the Detox framework. This scheme enables code coverage during testing, passes the '-DetoxUnitTest YES' argument to the test runner, and explicitly includes the 'DetoxUserNotificationTests' test bundle, ensuring that user notification tests are executed as part of the standard test action.

detox/ios/Detox.xcodeproj/xcshareddata · high confidence

The Detox Android integration now includes a new BridgeIdlingResource that monitors the React Native JavaScript bridge state using the NotThreadSafeBridgeIdleDebugListener API. This change, introduced to support React Native 0.84, allows Detox to accurately detect when the bridge is busy or idle, improving synchronization reliability during end-to-end tests by preventing actions from being taken while the bridge is processing.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/bridge · high confidence

The Android testing backend has been replaced with an Espresso-based implementation. This change introduces new core components in the \espresso\ package—\DetoxAction\, \DetoxAssertion\, \DetoxMatcher\, \DetoxViewActions\, and \EspressoDetox\—to handle element interactions, assertions, and matching. It also includes a custom \DetoxFailureHandler\ that enhances error reporting by attaching XML view hierarchies to failure exceptions, and updates synchronization logic in \UiAutomatorHelper\ to align with Espresso's threading model.

detox/android/detox/src/full/java/com/wix/detox/espresso · high confidence

The Android driver's tooling layer has been restructured to improve reliability and clarity. A new \ApkValidator\ now explicitly checks whether provided APK paths point to the application or test binary, throwing descriptive errors if they are swapped. The \AppInstallHelper\ and \AppUninstallHelper\ have been introduced to manage the push, install, and uninstall of both app and test binaries (including the \.test\ bundle ID) via ADB. Instrumentation execution is now handled by \Instrumentation\ and \MonitoredInstrumentation\, which parse logs for stack traces to provide better crash diagnostics. Additionally, \instrumentationArgs\ now supports serializing URL blacklist regular expressions and properly escapes arguments to prevent shell injection issues.

detox/src/devices/common/drivers/android/tools · high confidence

The Android matcher implementation has been updated to allow regular expressions in \by.id\, \by.label\, \by.text\, and \by.accessibilityLabel\ queries, enabling more flexible pattern matching. Additionally, the \by.type\ matcher now resolves semantic type names (such as 'image' or 'activity-indicator') to their underlying Android class names, allowing users to target elements by their semantic role rather than specific implementation classes.

detox/src/android/matchers · high confidence

The Android emulator driver now starts emulators with the \-read-only\ flag by default, ensuring that the device state is not modified during testing. This change is implemented in the new \EmulatorExec\ module, which handles command-line argument construction for emulator operations, including the \LaunchCommand\ that now explicitly includes the read-only setting unless overridden.

detox/src/devices/common/drivers/android/emulator · high confidence

The Android-side server communication layer has been completely rewritten in Kotlin, replacing the previous implementation with a new architecture centered on \DetoxActionHandlers\ and \DetoxActionsDispatcher\. This change introduces a typed, extensible handler system where specific actions (such as \Ready\, \ReactNativeReload\, \Invoke\, \Cleanup\, and \QueryStatus\) are processed by dedicated classes rather than generic string-based logic. The \QueryStatusActionHandler\ now provides detailed app status information, including busy resources, while the \InvokeActionHandler\ improves error reporting by attaching the view hierarchy to failure payloads. Under the hood, \DetoxActionsDispatcher\ manages action execution across primary and secondary threads, and \DetoxServerAdapter\ handles WebSocket connectivity using OkHttp, ensuring robust connection management and message routing between the test runner and the Android app.

detox/android/detox/src/full/java/com/wix/detox/adapters · high confidence

The Android instrumentation test runner and activity launch mechanism have been restructured to improve reliability and synchronization. A new \DetoxJUnitRunner\ now manages application lifecycle events to coordinate the start of performance recording and JSI installation. Activity launching has been moved to a dedicated \ActivityLaunchHelper\ that bypasses Espresso's \ActivityTestRule\ to prevent monitor leaks when launching background activities, ensuring the app is fully ready before tests proceed. Additionally, the main test entry point (\DetoxMain\) now enforces a handshake with the test server before launching the activity, and new handlers for crashes and ANRs are integrated to report these events to the test runner.

detox/android/detox/src/full/java/com/wix/detox · high confidence

Detox on Android now provides cleaner error messages by stripping verbose XML view hierarchies from Espresso exception reports, while preserving the hierarchy data for debugging when needed. Additionally, the framework introduces detection for busy background threads, identifying specific sources such as JavaScript execution, native module calls, and async tasks to help users understand why tests might be waiting.

detox/android/detox/src/full · high confidence

The \scripts/\ directory has been completely replaced with a new suite of automation tools. The release pipeline now relies on Yarn 4 (enforced via \corepack\ in \install.sh\) and integrates with Buildkite metadata for versioning and tagging (\releaseArgs.js\, \publishNewVersion.js\). A new \change\_react\_native\_version.js\ script automatically updates React Native and its associated peer dependencies (including specific handling for RN 77, 84, and 85) across the test and demo projects. CI execution is now structured into platform-specific runners (\ci.android.sh\, \ci.ios.sh\) that handle SDK license approval, build, and e2e testing, while demo projects are tested via \demo-projects.android.sh\ and \demo-projects.ios.sh\, including a new \demo-rn-bloat-bundle-test.sh\ to verify bundle size constraints. Artifacts and Allure reports are uploaded to Surge via \upload\_artifact.sh\, and a new \purge\_expired\_domains.mjs\ script cleans up old reports.

scripts · high confidence

The configuration module has been rewritten to support multiple apps per configuration via the new \apps\ array and \build\/\start\ scripts, replacing the legacy single-app \app\ property. The \detox.init()\ function no longer automatically launches the app; users must now explicitly configure \behavior.launchApp\ to 'manual' and handle app launching themselves. The configuration format has been modernized to drop legacy dash-based properties in favor of camelCase, and the system now supports extending configurations via the \extends\ property in \.detoxrc\ files.

detox/src/configuration · high confidence

The Detox iOS native project has been reorganized and significantly modernized. The core infrastructure (DetoxManager, WebSocket) and critical components (InvocationManager, Action, Expectation) have been converted from Objective-C to Swift. The project now integrates DetoxSync for synchronization, replacing previous dependencies like EarlGrey, and includes the COSTouchVisualizer and LNViewHierarchyDumper frameworks. Additionally, comprehensive support for testing WKWebViews has been added through new WebAction, WebExpectation, and WebPredicate classes, enabling interactions like tapping, typing, and scrolling within web content.

detox/ios/Detox.xcodeproj · high confidence

The Detox project has been restructured into a monorepo, moving the server and core logic into a single repository. This change introduces a new ESLint configuration and ignore rules to standardize code quality, and adds comprehensive TypeScript definitions (detox.d.ts, globals.d.ts) that expose the new Copilot and Pilot APIs alongside existing device and element matchers. A new semantic type system (semanticTypes.js) has been added to map UI components like images, buttons, and lists to platform-specific classes for more robust matching. Additionally, the launch arguments system has been refactored to support shared and local scoping, and the URL blacklist feature now accepts RegExp and arrays for more flexible network filtering. The testing infrastructure has been updated with a new Jest configuration using the allure2 reporter and 100% coverage thresholds, and the Pilot integration is now exposed via a dedicated DetoxPilot class.

detox · high confidence

The Detox documentation website has been completely redesigned and rebuilt using Docusaurus, featuring a new homepage with a hero banner, feature list, and social network integration. The site now includes a dedicated Showcase page displaying user apps with store links, a blog section for announcements (including Detox 20 and Detox Copilot), and a restructured documentation sidebar with new guides for TypeScript, WebViews, and Genymotion SaaS. The visual identity has been updated with a dark mode default, custom SCSS styling, and a 'Stand With Ukraine' banner component.

website · high confidence

The Detox worker lifecycle and environment setup have been restructured. The internal Copilot component is replaced by DetoxPilot (with a deprecated alias for backward compatibility), and the worker now uses the CAF library for managing asynchronous operations and cancellation. The environment factory now explicitly wires up device allocation, validation, and artifacts management for Android and iOS configurations, and the invocation layer exposes Espresso and EspressoWeb targets for direct device interaction.

detox/src · high confidence

Android scrolling actions now include edge-monitoring to prevent attempts to scroll past boundaries, mirroring iOS behavior. Additionally, swipe gestures support custom start coordinates (X, Y) and specific amounts, allowing for more precise user interactions.

detox/android/detox/src/main/java/com · high confidence

A new file, TimelineContextTypes.js, has been added to the timeline artifacts module, defining a set of constants (TEST, DESCRIBE, INVOCATION) that standardize the context types used within the timeline system.

detox/src/artifacts/timeline · medium confidence

The Android integration for React Native's AsyncStorage has been refactored to more accurately detect when storage operations are complete. By introducing a new \AsyncStorageIdlingResource\ and a reflection-based \SerialExecutorReflected\ helper, Detox now inspects the internal executor state (active and pending tasks) of the native module. This change ensures that end-to-end tests wait correctly for asynchronous storage writes to finish, reducing flakiness caused by premature test continuation.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/storage · high confidence

When Detox fails to connect to the test app, the error messages now provide specific troubleshooting hints based on whether the app was launched or not, and include a direct link to the official troubleshooting guide for further details.

detox/src/errors/longreads · high confidence

The matcher creation logic is now centralized in a new \MatchersFactory\ class located at \detox/src/matchers/factories/index.js\. This factory provides platform-specific implementations for Android and iOS, where the iOS factory now explicitly instantiates and passes an \XCUITestRunner\ to the \IosExpect\ class, and includes validation logic for external custom drivers to ensure they export the required \ExpectClass\. Unit tests have been added to verify the validation behavior for external modules.

detox/src/matchers/factories · high confidence

Detox now uses a dedicated provider system to manage artifact collection plugins. The new \ArtifactPluginsProvider\ hierarchy centralizes the registration of plugins for logs, screenshots, video, and instruments, with specific implementations for Android (using ADB), iOS physical devices, and iOS simulators (using AppleSimUtils). This change organizes how artifact data is captured and exposed to the API, separating platform-specific logic into distinct provider classes.

detox/src/artifacts/providers · high confidence

This change introduces a new device allocation lifecycle, starting with the definition of serializable device representations (DeviceCookie) for Android and iOS, and the implementation of Android-specific service locators. These locators manage the initialization and lazy loading of execution drivers for local emulators and GenyCloud instances, alongside standard Android utilities like ADB and AAPT, establishing the foundational wiring for device management.

(repo-wide) · high confidence

Detox now supports Jest 30 and introduces a new global lifecycle. This includes a new assertion to ensure custom Detox environments correctly pass the context argument to the parent constructor, utilities to retrieve full test names and detect timeouts, and validation logic to enforce the use of the Jest Circus test runner and compatible Jest versions. A workaround is also applied to disable global cleanup to prevent teardown failures caused by Detox proxies.

detox/runners/jest/testEnvironment/utils · high confidence

Detox now uses the promisify-child-process library for spawning and executing child processes, replacing the previous implementation. This change introduces robust retry logic with configurable backoff for both exec and spawn operations, ensuring better resilience against transient failures. It also provides enhanced, structured logging for command execution, including detailed stdout/stderr capture, retry attempt tracking, and configurable verbosity levels, improving debuggability for end users.

detox/src/utils/childProcess · high confidence

The Android driver now includes a dedicated AAPT module that uses the AAPT binary to extract package names and detect test APKs via instrumentation markers, replacing previous parsing logic. The ADB driver has been refactored to use a new \BinaryExec\ abstraction and the \execWithRetriesAndLogs\ utility, ensuring that device serials are properly quoted in shell commands and that ADB operations (such as installation and state retrieval) benefit from built-in retry and logging mechanisms.

detox/src/devices/common/drivers/android/exec · high confidence

Detox introduces a new device allocation lifecycle for Android, replacing the previous monolithic driver with a modular system. The \AndroidAllocDriver\ base class now handles post-allocation configuration, specifically setting up System UI behaviors (keyboard, pointer indicators, navigation, status bar) via \SystemUIDemoMode\ to prevent UI glitches during tests. Specific allocators like \EmulatorAllocDriver\ and \GenyAllocDriver\ manage their respective device lifecycles: emulators are validated via \AVDValidator\ (checking for AVD existence and emulator binary version \>= 29), launched via \EmulatorLauncher\ (with retry logic for unknown errors and boot completion polling), and shut down on cleanup; Genymotion Cloud instances are managed via \GenyInstanceLauncher\ (handling creation, ADB connection, and teardown). A new \FreeDeviceFinder\ and its \FreeEmulatorFinder\ subclass handle device selection by checking availability, online status, and matching against device queries or AVD names. This refactoring ensures that System UI setup is applied consistently across all Android device types after allocation.

detox/src/devices/allocation/drivers/android · high confidence

The Android runtime driver has been restructured into a modular hierarchy to better support different device environments. The new \AndroidDriver\ serves as the base implementation, handling core operations like app installation, launch, termination, and state reset (which now explicitly grants all permissions after resetting app state). Specialized drivers extend this base: \EmulatorDriver\ adds support for setting device location and configurable ADB install strategies, \AttachedAndroidDriver\ provides naming for physically attached devices, and \GenyCloudDriver\ optimizes ADB execution with retry logic to handle network instability in cloud environments. Comprehensive tests have been added to verify instrumentation lifecycle, URL payload delivery, and device-specific behaviors.

detox/src/devices/runtime/drivers/android · high confidence

Detox introduces a new execution layer for Android interactions, splitting logic into \native.js\ and \web.js\. The native implementation now wraps actions and assertions using \EspressoDetoxApi\ and \DetoxAssertionApi\, integrates invocation tracing via \traceInvocationCall\, and enforces stricter validation for \WaitForInteraction\ parameters (e.g., timeout must be a positive number, search matchers must be \NativeMatcher\ instances). The web implementation provides a simpler \WebInteraction\ base class for executing web-specific actions and assertions. This change restructures how interactions are constructed and executed on Android, adding traceability and error handling improvements.

detox/src/android/interactions · high confidence

Detox for Android now uses a new Java-based engine to invoke native methods, replacing the previous implementation. This change introduces a structured approach using \MethodInvocation\ to parse JSON instructions and dispatch calls via reflection, supporting various target types such as static class methods, object instance methods, and nested invocations. Users benefit from more robust handling of method arguments, including proper type conversion for primitives and complex objects, and the ability to invoke methods that were previously inaccessible due to visibility restrictions.

detox/android/detox/src/full/java/com/wix/invoke · high confidence

Detox now supports the modern Jest Circus test runner via the new \detox/runners/jest\ entry point, which exposes \DetoxCircusEnvironment\, \globalSetup\, and \globalTeardown\. The previous \detox/runners/jest-circus\ path is now a migration shim that delegates to this new location. The old Jest adapter and reporter integrations (e.g., \adapter\, \specReporter\, \streamlineReporter\) are deprecated and throw errors, as Detox no longer supports them since v20.0.0. A new reporter system is introduced, featuring a \DetoxReporterDispatcher\ that coordinates multiple reporters (IPC, Summary, Verbose) and handles early teardown logic when Jest's \--bail\ option is used.

detox/runners/jest · high confidence

Detox Android introduces three new Kotlin utility files in the common package to support internal operations. UIExtensions adds helper functions to iterate over child views and perform recursive in-order traversal of the view hierarchy, which supports more robust UI element discovery. KotlinReflectUtils provides a safe reflection mechanism to access Kotlin property values, handling differences between debug and release build compilations. RNAnnotations introduces a source-level annotation to track compatibility requirements for specific React Native major versions.

detox/android/detox/src/full/java/com/wix/detox/common · high confidence

The \detox/src/server\ module has been replaced with a new architecture built on the \ws\ library, introducing dedicated classes for managing the server lifecycle (\DetoxServer\), individual client connections (\DetoxConnection\), and test sessions (\DetoxSession\, \DetoxSessionManager\). This change introduces a structured session model where testers and apps are registered as distinct roles, enabling the server to correctly route actions between them and handle disconnections (e.g., notifying the tester when the app disconnects). The new implementation also includes explicit error handling for malformed messages, validation of login parameters, and a timeout mechanism for graceful server shutdown.

detox/src/server · high confidence

The client-side action handling has been restructured with the introduction of a formal \SyncStatusSchema.json\ that defines the structure for synchronization status responses, including specific resources like delayed selectors, dispatch queues, run loops, and UI animations. Concurrently, \actions.js\ now implements a class-based action system where individual operations (such as Login, Ready, Shake, SetOrientation, and Cleanup) are defined as distinct classes inheriting from a base \Action\ class, utilizing a new \SyncStatusFormatter\ to process JSON status responses.

detox/src/client/actions · high confidence

The Detox client now uses a new \AsyncWebSocket\ implementation for communication with the device server, replacing the previous synchronous or callback-based approach. This change introduces promise-based API calls, automatic message ID tracking, and support for request timeouts. It also adds detection of concurrent non-atomic actions to prevent race conditions in test code, and improves error handling by providing clearer stack traces and specific error messages for network issues, timeouts, and unexpected server responses.

detox/src/client · high confidence

Detox now includes dedicated environment validators for Android Genymotion Cloud and iOS Simulator devices. For Genymotion Cloud, the validator ensures the gmsaas executable is at least version 1.6.0 and, for versions 1.11.0 and above, runs a 'doctor' health check to catch configuration issues like missing Android SDKs. For iOS Simulators, the validator checks that the Detox framework cache exists, providing a clear error message and fix instructions if it is missing.

detox/src/devices/validation · high confidence

Detox introduces a new plugin-based system for managing test artifacts (such as screenshots and logs) located in the \detox/src/artifacts/templates/plugin\ directory. This change replaces the previous monolithic implementation with a hierarchy of abstract base classes—\ArtifactPlugin\, \WholeTestRecorderPlugin\, \StartupAndTestRecorderPlugin\, and \TwoSnapshotsPerTestPlugin\—that define lifecycle hooks (e.g., \onTestStart\, \onTestDone\, \onBeforeCleanup\) for capturing and storing artifacts. This allows users to configure artifact behavior, such as taking snapshots on test failure or keeping only failed test artifacts, through a more modular and extensible configuration structure.

detox/src/artifacts/templates/plugin · high confidence

The iOS simulator allocation logic has been replaced with a new driver that introduces a dedicated post-allocation step. After a simulator is found or created, the system now explicitly boots it using \applesimutils\ and applies a workaround for hidden-window screenshot failures, ensuring the device is fully ready for testing before use.

detox/src/devices/allocation/drivers/ios · high confidence

Detox now uses a new realm-based architecture to manage its internal state and lifecycle. This introduces a primary context (DetoxPrimaryContext) that handles device allocation, IPC server initialization, and session state serialization, and a secondary context (DetoxSecondaryContext) that communicates with the primary via an IPC client. A shared DetoxContext base class and a DetoxInternalsFacade provide a unified interface for test runners to interact with Detox, exposing symbols for lifecycle events, device management, and logging. This change isolates the core runtime logic from the test runner integration, improving modularity and state management.

detox/src/realms · high confidence

The sync status reporting mechanism has been refactored to use a new \SyncStatusFormatter\ that validates incoming status JSON against a schema and formats detailed, human-readable descriptions for specific busy resources. This change introduces support for formatting additional resource types including animation updates, background threads, delayed perform selectors, dispatch queues, run loops, one-time events, timers, UI activity, network activity, looper activity, disk I/O, and React-Native bridge activity. The formatter now provides clearer diagnostics for idle states and specific busy tasks, improving the user's ability to understand why an app is not responding during tests.

detox/src/client/actions/formatters · high confidence

The pre-commit hook now automatically strips registry-specific URLs (\_\_archiveUrl) from yarn.lock to ensure the lockfile remains portable across different environments, and runs yarn install in immutable mode to validate the lockfile integrity before allowing commits.

.husky · high confidence

The Android UI extension now computes accessibility labels by recursively traversing the view hierarchy of React Native objects, collecting raw labels from content descriptions and text views, and joining them with a separator that adapts based on the React Native minor version (comma-space for v81+, space otherwise). This replaces the previous single-level lookup, ensuring that composite or nested React Native components expose their full accessible text to test assertions like toHaveLabel().

detox/android/detox/src/full/java/com/wix/detox/reactnative/ui · high confidence

The CLI utility layer has been reorganized into dedicated modules to improve maintainability and support new capabilities. A new \frameworkUtils\ module centralizes the logic for building and cleaning the Detox framework and XCUITest runner caches, introducing support for the \--framework\ and \--xcuitest\ flags to target specific components. \jestInternals\ and \patchJestUtil\ now handle Jest version detection (supporting 29.2.x and 30.x) and patch \jest-util\ to enable REPL mode by modifying interactive detection logic. Additionally, new utilities for CLI error handling (\cliErrorHandling\), process interruption (\interruptListeners\), and argument parsing (\yargsUtils\) have been introduced to standardize how the CLI manages user-facing errors and command-line options.

detox/local-cli/utils · high confidence

The post-install process has been restructured to improve reliability and compatibility. For iOS, the build logic is now split into dedicated scripts: \build\_framework.ios.sh\ and \build\_xcuitest.ios.sh\ handle the actual compilation using isolated environments, while \build\_local\_framework.ios.sh\ and \build\_local\_xcuitest.ios.sh\ manage caching, extraction of prebuilt artifacts, and dev-mode source building. The main \postinstall.js\ orchestrates these steps and now supports disabling the post-install phase via the \DETOX\_DISABLE\_POSTINSTALL\ environment variable. For Android, a new \updateGradle.js\ script automatically patches the Gradle wrapper version and \settings.gradle\ file based on the detected React Native minor version (supporting RN 71–79), and conditionally disables the New Architecture in \gradle.properties\ if \ENABLE\_NEW\_ARCH\ is not set to true.

detox/scripts · high confidence

The iOS simulator log recording mechanism has been replaced with a new implementation that uses the \log stream\ command via \appleSimUtils\. This change introduces a dedicated \SimulatorLogRecording\ class to manage the log stream process, including graceful interruption handling and configurable delays for start/stop operations, aiming to stabilize log capture and prevent crashes when the app is terminated during tests.

detox/src/artifacts/log/ios · high confidence

Detox 20 no longer supports the legacy Jest adapters; attempting to use them now throws an error directing users to the migration guide. To assist with the transition, the package now includes a deprecation notice module that halts execution with clear instructions, and a migration helper that automatically redirects requires from the old \detox/runners/jest-circus\ path to the new \detox/runners/jest\ path while logging a warning about the outdated location.

detox/runners · high confidence

The CI configuration has been reorganized into modular pipeline files to improve release control and debugging capabilities. A new release workflow now includes interactive blocks for selecting version types (patch, minor, major, pre-release), dry-run modes, and a fast-release option that skips building and testing. A debug mode allows users to manually select specific React Native versions (iOS/Android, Demo App) for targeted testing. Post-processing steps have been separated to handle test coverage aggregation independently. The common pipeline now targets specific React Native versions (77, 84, 85.2) for both iOS and Android, including demo apps, replacing the previous monolithic structure.

.buildkite · high confidence

The repository now includes standardized configuration files to enforce consistent coding styles and improve documentation quality. A \.editorconfig\ defines indentation and line-ending rules for TypeScript, JavaScript, and Markdown files, while \.prettierrc\ sets code formatting preferences. Documentation workflows are enhanced with \.markdownlintrc\ for linting and a comprehensive \.remarkrc.mjs\ configuration that integrates spell-checking, link validation, and style checks. Additionally, \.gitattributes\ ensures consistent line endings for shell scripts, and \.gitignore\ is updated to exclude IDE-specific files (JetBrains, VS Code) and build artifacts.

(repo-wide) · high confidence

Detox now introduces a dedicated error hierarchy (DetoxError, DetoxRuntimeError, DetoxConfigError) and composer classes to provide clearer, more actionable feedback when configuration files are invalid or runtime operations fail. Users will see improved error messages with specific hints and debug information for issues like missing configurations, invalid device types, or failed app selections, making it easier to diagnose and fix setup problems.

detox/src/errors · high confidence

Detox now uses a new Objective-C bridge (DetoxSwiftBridge) to locate the root view and React Native factories in Swift-based iOS applications. By reflecting on the app delegate's instance variables, Detox can automatically discover these components without requiring explicit Swift code changes from the user, enabling \reloadApp\ and other lifecycle operations to work correctly in Swift projects.

detox/ios/Detox/Utilities/SwiftSupport · high confidence

The Android demo application has been updated to support newer React Native versions (including 0.71+) by migrating to Kotlin, adopting the DefaultReactActivityDelegate with Fabric support, and switching to AndroidX test libraries. The app now includes a BUCK build configuration, explicit ProGuard rules for obfuscation, and a network security configuration that permits cleartext traffic for localhost and emulator IPs to ensure Detox end-to-end tests function correctly on attached devices.

examples/demo-react-native/android · high confidence

The CLI templates for new Detox projects have been updated to align with modern Jest and Detox configurations. The generated Jest config now uses the \detox/runners/jest/testEnvironment\ instead of the default \jsdom\ environment, addressing compatibility issues with recent Jest versions. Additionally, the template introduces a new global lifecycle structure via \globalSetup\ and \globalTeardown\ hooks, replacing the previous approach where \detox.init()\ automatically launched the app; users must now explicitly manage app launch within their test setup (e.g., using \device.launchApp()\ in \beforeAll\).

detox/local-cli/templates · high confidence

This change introduces the core iOS implementation for Detox actions, enabling reliable UI interaction testing. It adds category extensions for key UIKit components—\NSObject\, \UIScrollView\, \UIDatePicker\, \UIPickerView\, \UIDevice\, and \UIApplication\—to handle taps, long presses, swipes, scrolling, text input, device orientation, and date/picker selection. Under the hood, it implements a synthetic touch injection system (\DTXSyntheticEvents\, \DTXTouchInjector\) that delivers precise touch events to the app under test, including support for drag-and-drop trajectories and normalized starting points. The implementation also includes fixes for iOS 18 keyboard errors, correct coordinate system handling, and improved accessibility element support to ensure actions target hittable elements correctly.

detox/ios/Detox/Actions · high confidence

The iOS simulator driver has been restructured to use a new \DeviceDriverBase\ class that defines the standard driver interface, with \IosDriver\ providing platform-specific implementations and \SimulatorDriver\ handling simulator-specific logic. A key behavioral change is the introduction of \AppStateResetFallback\, which implements a backup-uninstall-restore strategy to reset app state on iOS simulators, addressing the lack of a native reset command. The driver now supports passing architecture arguments during app launch and includes updated unit tests for the new driver hierarchy and app state reset functionality.

detox/src/devices/runtime/drivers/ios · high confidence

The iOS simulator driver tools have been updated to rely on Apple's native \simctl\ commands for core operations like setting permissions and launching apps, replacing the previous reliance on the external \applesimutils\ binary for these tasks. This change includes support for passing architecture flags (e.g., \--arch\) during app launch on iOS 26+ and allows URL blacklists to be configured using RegExp patterns or arrays. Additionally, a new \SimulatorAppCache\ component has been introduced to manage backing up, restoring, and cleaning up app data for simulators, improving the reliability of state reset operations.

detox/src/devices/common/drivers/ios/tools · high confidence

Detox now includes a new idling resource for React Native's Paper UI architecture on Android. This change adds a set of reflection-based wrappers (UIManagerModuleReflected, NativeHierarchyManagerReflected, etc.) to inspect internal React Native state, allowing Detox to accurately detect when the UI rendering queue is idle and preventing flaky test failures caused by race conditions.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/paper · high confidence

This change introduces dedicated ProGuard configuration files (proguard-rules.pro and proguard-rules-app.pro) to the Android Detox module. These rules ensure that critical React Native components, Kotlin reflection classes, and specific utility libraries (such as Apache Commons) are preserved during code shrinking and obfuscation. This allows Detox tests to run correctly in release builds where minification is enabled, preventing crashes caused by missing classes or methods.

detox/android/detox · high confidence

The timer-based idling resources on Android have been fixed to work correctly with React Native 74, 75, and newer versions, including the new Fabric architecture. A new \FabricTimersIdlingResource\ handles Fabric by reflecting into the React Native internals to detect active timers, while the existing \TimersIdlingResource\ continues to use the \TimingModule\ for older architectures. This resolves \AbstractMethodError\ and build failures caused by changes in React Native's internal field names and API availability.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/timers · high confidence

The Android idling resource implementation has been rewritten in Kotlin to improve reliability and control. A new base DetoxIdlingResource class introduces explicit pause and resume capabilities, allowing tests to temporarily suspend idle checks for specific resources (such as network, timers, or UI) without unregistering them. Additionally, a StabilizedIdlingResource wrapper has been added to mitigate race conditions caused by 'flapping' resources that briefly toggle between busy and idle states; it requires multiple consecutive idle checks before reporting idle, ensuring Espresso's interrogation process does not miss short busy periods. The central ReactNativeIdlingResources manager now orchestrates these resources, including a fix for Espresso 3.7.0+ Looper handler caching issues that previously caused stale state upon re-registration.

detox/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources · high confidence

Detox now supports hot-reloading in React Native applications using the New Architecture (Fabric). The reloader logic has been updated to detect whether Fabric is enabled and, if so, uses the new \ReactHost.reload()\ API instead of the legacy \reactInstanceManager.recreateReactContextInBackground()\. This ensures that developers using the New Architecture can continue to use Detox's reloading features without interruption.

detox/android/detox/src/full/java/com/wix/detox/reactnative/reloader · high confidence

The demo application has been upgraded to React Native 81, which includes necessary build fixes and updates to the Android entry point (MainApplication.kt) to align with the new architecture. This change ensures the demo app correctly initializes the React Native host and Fabric integration, resolving previous compatibility issues with the newer React Native version.

app · high confidence

Add mock implementations for logger and trace utilities; Add test application entry point and TypeScript declarations; Added Android and iOS test artifact verification snapshots; Added Android instrumentation tests with Detox Butler integration; Added Android test app build and ProGuard configuration; Added Android test infrastructure and build configuration; Added Android test resource fixtures for Espresso and web interactions; Added Android test utility classes for UI synchronization, native view spying, and React Native 76 compatibility; Added CJS configuration mock for testing; Added NativeModule and ShakeEventEmitter test fixtures for iOS; Added TypeScript type tests for Detox APIs; Added Xcode scheme for the iOS example test project; Added comprehensive e2e test suite for core Detox functionality; Added e2e driver helpers for actions, scrolling, launch args, and URL handling; Added e2e integration tests and custom tracing reporter; Added e2e test screens for the Detox test application; Added e2e test utility modules for snapshots, skipping, and environment checks; Added e2e-unhappy test suite and CI scripts for error handling verification; Added iOS UI test infrastructure for custom keyboards, overlay messages, and shake gestures; Added iOS example app configuration files for testing; Added iOS test app scaffolding and configuration; Added integration test utilities for logger and lifecycle verification; Added integration tests for Jest bail support, initialization, and timeline artifacts; Added mock implementations for the Detox logger; Added mock server for testing; Added overlay message view implementation for iOS test app; Added snapshot for timeline integration test; Added snapshot tests for Android AAPT and ADB command execution; Added snapshot tests for Android APK validation error messages; Added snapshot tests for AsyncWebSocket and Client error handling; Added snapshot tests for CLI port validation; Added snapshot tests for Detox error composition and internal/runtime errors; Added snapshot tests for DetoxLogFinalizer; Added snapshot tests for DetoxLogger formatting and duration events; Added snapshot tests for DetoxPrimaryContext error handling; Added snapshot tests for SyncStatusFormatter resource types; Added snapshot tests for composeRunnerConfig validation errors; Added snapshot tests for external driver validation errors; Added stub test infrastructure for integration testing; Added test app scaffolding and configuration for Detox e2e testing; Added test coverage for Android action handlers and query status logic; Added test helpers for AsyncStorage stress testing; Added test infrastructure and mocks for CLI testing; Added test view components for UI testing; Added tests for Android busy background thread detection; Added tests for Android idling resources; Added tests for Detox runner migration and reporter; Added tests for DetoxExceptionUtils error message cleaning; Added tests for MaterialSliderHelper; Added tests for PairsIterator and DetoxInstrumentsManager; Added tests for ViewActionPerformer action routing; Added tests for regex matching and view-at-index matcher descriptions; Added unit tests for Android Activity launch logic; Added unit tests for Android common utilities; Added unit tests for Android invoke module; Added unit tests for Android scroll and swipe logic; Added unit tests for Android swipe gestures and AsyncStorage idling resource; Added unit tests for DetoxCustomTapper and GetAttributesAction; Added unit tests for Vector2D utility class; Added unit tests for the Android MethodsSpy component; Expanded Android demo app with native test utilities and views; Expanded end-to-end test coverage for Pilot AI interactions; New iOS example test project with native modules and CI support; Updated Detox client mock to support infinite connection testing; Updated snapshot tests for argument assertion utilities.

The iOS build now includes DetoxSync, DTXLoggingInfra, LNViewHierarchyDumper, and COSTouchVisualizer as Git submodules, replacing previous inline or alternative implementations. A .tbzignore file is added to exclude build artifacts and example projects from the source tarball, ensuring a cleaner distribution package.

detox/ios · high confidence

This release introduces the \detox-cli\ wrapper package and establishes the Android build configuration for the native library. The Android module now targets SDK 35, uses Kotlin 2.0.21, and upgrades Espresso to 3.7.0, while the main \detox\ package version is set to 20.51.4.

(dependencies) · high confidence

The Android build system now uses Gradle 8.14.3 via the wrapper configuration. This ensures that all builds are executed with a consistent, modern Gradle version, which may improve build performance and compatibility with newer Android tooling.

detox/android/gradle · high confidence

The project's Yarn package manager has been updated to version 4.12.0. This change replaces the previous binary in the \.yarn/releases\ directory, ensuring that all subsequent package installations and resolutions are handled by the new Yarn 4.x engine.

.yarn · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 51 (+1.4)
• Rubric changed (rubric-2026.09.12 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 87 → 89 (+2.3)
• Architecture 67 → 67 (-0.8)
• Maturity 63 → 65 (+1.4)
• Readiness 35 → 35 (+0.1)
• Security 58 → 65 (+6.5)
• Performance 63 (new)

• Critical CVE: [GHSA redacted] (yarn.lock)
• Documentation: contradicts the code (docs/guide/typescript.md)
• Documentation: contradicts the code (docs/guide/uninstalling.md)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• Medium CVE: [GHSA redacted] (yarn.lock)
• Medium CVE: [GHSA redacted] (yarn.lock)
• Off-boarding risk: anonymized user #1
• getGenerator (cognitive 27) (generation/core/generator.js)
• getGenerator (cyclomatic 28) (generation/core/generator.js)

• Critical CVE: [GHSA redacted] (yarn.lock)
• Documentation: no installation or build instructions (docs/articles/how-detox-works.md)
• Documentation: no project overview (README.md)
• Documentation: written for insiders (docs/api/device.md)
• Documentation: written for insiders (docs/api/expect.md)
• Duplicated block (11 lines × 2) (detox/ios/Detox/Invocation/Expectation.swift)
• Duplicated block (15 lines × 2) (detox/android/detox/src/main/java/com/wix/detox/espresso/action/DetoxSwipeWithLongPress.kt)
• Duplicated block (16 lines × 2) (detox/ios/Detox/Invocation/Action.swift)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• Low cohesion: DetoxCoreListener (LCOM4 5) (detox/runners/jest/testEnvironment/listeners/DetoxCoreListener.js)
• Low cohesion: NativeMatcher (LCOM4 4) (detox/src/android/core/NativeMatcher.js)
• Medium CVE: [GHSA redacted] (yarn.lock)
• Medium vulnerability: [GHSA redacted] (yarn.lock)
• Medium: security finding (details withheld)
• …and 5 more

• Unchanged — 0 containers · 2 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

wix/Detox was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.