SeleniumHQ/selenium

This system is the Selenium WebDriver framework, providing a standardized API for automating web browsers across multiple languages including Java, .NET, Python, Ruby, and JavaScript. It manages the lifecycle of browser drivers, supports the W3C WebDriver specification, and implements the bidirectional BiDi protocol for real-time event streaming and advanced control. The codebase also includes infrastructure for Selenium Grid, enabling distributed test execution and dynamic node management.

64 changes.

This period focused on modernizing the project's build infrastructure by migrating multiple language bindings to Bazel and transitioning core logic to TypeScript. It also involved extensive updates to align with the W3C WebDriver specification, including the introduction of new .NET bindings and significant refactoring of existing drivers to support modern browser automation standards.

104 changes.

This period focused on a comprehensive architectural overhaul of the Selenium Grid, introducing a modular, event-driven design with pluggable backends for session management, distribution, and security. Simultaneously, the project standardized its build infrastructure across all language bindings by migrating to Bazel and modernizing test suites, while significantly expanding driver support for Edge, Chromium, and WebAuthn.

60 changes.

This period focused on implementing the WebDriver BiDi protocol across Java, .NET, and JavaScript bindings, adding comprehensive modules for browsing context, network interception, script execution, and emulation. Concurrently, the project introduced Selenium Manager in Rust and wrapped it for Java and .NET to automate driver management, while expanding test coverage and infrastructure for Kubernetes and Redis-backed grid scalability.

The .NET WebDriver BiDi implementation now includes a Permissions module, allowing users to manage browser permissions via the \AsPermissions()\ extension on the \IBiDi\ interface. This addition introduces the \IPermissionsModule\ interface and \PermissionsModule\ implementation, exposing the \SetPermissionAsync\ method to grant, deny, or prompt for specific permissions (defined in \PermissionState\) for a given origin and optional user context. Supporting types include \PermissionDescriptor\, \SetPermissionOptions\, and \SetPermissionResult\, with JSON serialization handled by a dedicated \PermissionsJsonSerializerContext\.

dotnet/src/webdriver/BiDi/Permissions · high confidence

The Java bindings now include the \org.openqa.selenium.bidi.log\ package to support the WebDriver BiDi \log.entryAdded\ event. This adds model classes for \GenericLogEntry\, \ConsoleLogEntry\, and \JavascriptLogEntry\, along with \LogLevel\ and \StackTrace\ types, allowing users to receive and inspect structured log data from the browser. A \FilterBy\ utility is provided to filter log entries by severity level, and the \Log.entryAdded()\ method maps incoming JSON events to the appropriate entry type.

java/src/org/openqa/selenium/bidi/log · high confidence

Introduces a new \JdbcBackedSessionMap\ implementation that persists session data to a relational database via JDBC. Users can now configure a JDBC connection using \--jdbc-url\, \--jdbc-user\, and \--jdbc-password\ flags to enable session storage in a database, providing an alternative to in-memory or Redis-backed session maps for Grid nodes.

java/src/org/openqa/selenium/grid/sessionmap/jdbc · high confidence

Introduces a new \JdkHttpClient\ in the \org.openqa.selenium.remote.http.jdk\ package that implements the \HttpClient\ interface using the Java 11 \java.net.http.HttpClient\. This provides an alternative HTTP transport layer supporting basic authentication, proxy configuration, SSL context customization, and WebSocket connections, alongside a dedicated \ConnectionException\ for connection failures.

java/src/org/openqa/selenium/remote/http/jdk · high confidence

Grid users can now configure the Distributor to use a Redis-backed implementation, enabling stateless, horizontally-scalable grid deployments. This change introduces new internal components (RedisBackedDistributor, RedisBackedGridModel, and RedisBackedNodeRegistry) that store all grid model state in Redis, allowing multiple Distributor replicas to share a consistent view of nodes and sessions. Users can enable this by setting the distributor implementation to 'org.openqa.selenium.grid.distributor.redis.RedisBackedDistributor' and providing a Redis URL, which supports concurrent scheduling and health checks across multiple grid instances.

java/src/org/openqa/selenium/grid/distributor/redis · high confidence

Introduces a new Redis-backed implementation for the Selenium Grid's data layer, enabling distributed session and node management via Redis. This change adds the \GridRedisClient\ class and associated build configuration, leveraging Lettuce and Redisson libraries to provide atomic operations for node availability, session queues, and distributed locking within the Grid infrastructure.

java/src/org/openqa/selenium/redis · high confidence

This change introduces the Virtual Authenticator API, allowing users to simulate WebAuthn operations in automated tests. It adds the \IHasVirtualAuthenticator\ interface to enable adding and removing virtual authenticators, and the \Credential\ class to manage resident and non-resident credentials (including ID, private key, and user handle). Configuration is handled via \VirtualAuthenticatorOptions\, which supports setting the CTAP protocol (CTAP2 or U2F), transport type (USB, BLE, NFC, internal), and flags for resident keys, user verification, and user consent.

dotnet/src/webdriver/VirtualAuth · high confidence

The BiDi API now includes a WebExtension module that allows users to install and uninstall browser extensions. This change introduces the \IWebExtensionModule\ interface with \InstallAsync\ and \UninstallAsync\ methods, supporting extension data via archive paths, base64-encoded content, or file paths. The implementation handles serialization and command execution for the \webExtension.install\ and \webExtension.uninstall\ BiDi commands.

dotnet/src/webdriver/BiDi/WebExtension · high confidence

Introduces a new ZeroMQ-backed event bus (\ZeroMqEventBus\) for the Selenium Grid, providing an alternative to the existing eventing mechanism. This implementation supports both bound and unbound socket modes, configurable heartbeat intervals to prevent stale connections, and automatic rejection handling for events with unparseable secrets. It includes build configuration for the \jeromq\ and \failsafe\ dependencies and exposes a \RejectedEvent\ listener for monitoring event processing failures.

java/src/org/openqa/selenium/events/zeromq · high confidence

A new download page has been added to the common web resources, featuring links to sample files including one with special characters (spaces, ampersands, underscores, quotes, and tildes) in its filename. This allows users to test file download functionality, particularly how the system handles non-standard filenames.

common/src/web/downloads · high confidence

The repository now includes a common directory with example WebExtensions (manifest v3) in both signed and unsigned formats, along with their build definitions. These assets allow test suites across Java, Python, Ruby, .NET, and JavaScript to verify WebExtension functionality in Firefox and Chrome without relying on external or pre-built add-ons.

common/extensions · high confidence

The Java bindings now include a new \RelativeLocator\ API in the \org.openqa.selenium.support.locators\ package, allowing users to find elements based on their spatial relationship to other elements (e.g., \above\, \below\, \toLeftOf\, \toRightOf\, and their \straight\ variants). This feature is implemented via a new \RelativeLocatorServerSide\ class that registers as a \CustomLocator\ named

java/src/org/openqa/selenium/support/locators · high confidence

Added a new C++ library (imehandler) that provides an abstraction layer for managing Input Method Editor (IME) engines on Windows. This component introduces an abstract ImeHandler interface and a WinapiHandler implementation that interacts with the Windows registry to enumerate, load, activate, and switch between keyboard layouts and input engines, enabling downstream drivers to manage complex IME states.

cpp/imehandler · high confidence

The \common/devtools/chromium\ location now includes protocol definition files (\.pdl\) and build rules for Chromium versions 151, 152, and 153. These files define the structure for the browser and JavaScript DevTools Protocol domains, enabling the generation of protocol JSON files used by language-specific WebDriver implementations (dotnet, java, javascript, py, rb) to communicate with these browser versions.

common/devtools/chromium · high confidence

Added a set of static files to the common web resources to demonstrate Federated Credential Management (FedCM) integration. This includes configuration files (config.json, accounts.json, client\_metadata.json) defining the identity provider endpoints and sample user data, along with HTML pages (fedcm.html, fedcm\_async.html, fedcm\_async\_js.html) that implement the client-side logic for triggering the credential selection UI, and placeholder login/sign-in pages to support the flow.

common/src/web/fedcm · high confidence

New files have been added to the common HTML5 module to demonstrate and support specific HTML5 capabilities. A new database.js script implements the Web SQL Database API, providing functions to open a database, create a 'docs' table, insert and select records, and delete all data, with UI feedback for errors and completion. A geolocation.js script demonstrates the Geolocation API by fetching the current position and displaying a Google Maps static image along with coordinate details. Additionally, a test.appcache file defines caching rules for images and fallback pages to support offline access, and a status.html file serves as a basic online status page.

common/src/web/html5 · high confidence

The Firefox driver internals now include an IniFileReader class that parses .INI configuration files into a structured store of sections and key-value pairs. Users relying on Firefox-specific configuration files will have these files read and processed internally by this new component, enabling access to specific settings via section and key lookups.

dotnet/src/webdriver/Firefox/Internal · high confidence

Selenium now includes a new \org.openqa.selenium.federatedcredentialmanagement\ package that allows Java users to interact with the browser's Federated Credential Management dialogs. This addition introduces the \HasFederatedCredentialManagement\ interface for drivers, enabling test scripts to access the currently open FedCM dialog via \getFederatedCredentialManagementDialog()\. Users can now programmatically manage dialog states by selecting accounts (\selectAccount\), canceling the dialog (\cancelDialog\), and controlling privacy-related behaviors such as disabling promise rejection delays (\setDelayEnabled\) or resetting cooldowns (\resetCooldown\). The package also provides model classes like \FederatedCredentialManagementAccount\ to inspect account details (e.g., email, name, login state) presented in the account chooser or auto-reauth dialogs.

java/src/org/openqa/selenium/federatedcredentialmanagement · high confidence

A new JavaScript module (bidi-mutation-listener.js) has been introduced in the bidi-support directory to observe DOM changes via the MutationObserver API. This listener tracks attribute modifications on the document subtree, excluding internal WebDriver attributes, and sends mutation details (target ID, attribute name, current and old values) through a provided channel. The module is now exported as part of the build configuration, enabling other components to leverage this DOM change detection capability for BiDi (Bidirectional) protocol interactions.

javascript/bidi-support · high confidence

A new JavaScript file, mutation-listener.js, has been added to the CDP support module to monitor DOM changes. This script uses a MutationObserver to track attribute changes on the document, excluding internal WebDriver markers, and reports detected changes via a \_\_webdriver\_attribute function. The file is now exported as part of the build configuration.

javascript/cdp-support · high confidence

The Java bindings now include a new Permissions module under the WebDriver BiDi API, introducing the \PermissionState\ enum to represent permission states (granted, denied, prompt) as defined by the W3C specification. This module is marked as Beta and includes nullability annotations via JSpecify to improve type safety for developers interacting with permission-related BiDi commands.

java/src/org/openqa/selenium/bidi/permissions · high confidence

This release adds RBS type signature files for the Ruby Selenium bindings, covering the DevTools module, the Selenium Server class, core WebDriver classes (Point, Dimension, Rectangle), and the full WebDriver BiDi implementation including Browser, BrowsingContext, Network, and Protocol domains. These signatures provide static type checking support for the Ruby driver and BiDi components.

rb/sig · high confidence

This change introduces a new library for managing Input Method Engine (IME) configurations on Linux systems using the iBus framework. It adds a dedicated IBusHandler implementation that allows querying active and available engines, activating or deactivating input contexts, and loading specific engines. The update also includes a default iBus configuration file (ibus.conf) to set global engine preferences and hotkeys, and utility classes to handle iBus-specific key mappings, laying the groundwork for deeper integration with browser automation tools like FirefoxDriver.

cpp/imehandler/linux · high confidence

This change introduces the local C++ toolchain definition for the \@local\_config\_cc\ repository, providing the necessary BUILD files, Starlark configuration rules, and wrapper scripts to enable C++ compilation in remote build environments. It configures the default x86\_64 (k8) toolchain to use GCC with specific compiler and linker flags (such as \-fstack-protector\ and \-fuse-ld=gold\) and includes a stub toolchain configuration for the \armeabi-v7a\ Android architecture to satisfy build system requirements.

common/remote-build/cc · high confidence

The modal\_dialogs area now includes a new 'modern\_modal.html' file that demonstrates a CSS-based modal overlay with a close button and click-outside-to-close behavior, replacing the reliance on the legacy window.showModalDialog API for this specific sample. Additionally, a chain of legacy modal samples (modalindex.html, modal\_1.html, modal\_2.html, modal\_3.html) was added to illustrate the older window.showModalDialog navigation pattern.

_common/src/web/modal\dialogs · high confidence

A new \empty\ package has been introduced under \org.openqa.selenium.remote.tracing\ containing null-object implementations (\NullTracer\, \NullSpan\, \NullContext\, \NullPropagator\, and \NullAttributeMap\) that satisfy the tracing interfaces without performing any actual tracing or recording. This allows Selenium to operate in environments where OpenTelemetry dependencies are not available or desired, effectively disabling tracing overhead while maintaining API compatibility.

java/src/org/openqa/selenium/remote/tracing/empty · high confidence

A new Python script (rmSourcemaps.py) has been added to the Grid UI scripts directory. This script walks through the 'build' directory and deletes any files ending in '.map', effectively stripping source maps from the production build artifacts to reduce bundle size.

javascript/grid-ui/scripts · high confidence

New JavaScript atoms have been introduced to enable WebDriver to interact with browser storage mechanisms. The changes add \appcache.js\, \local\_storage.js\, and \session\_storage.js\ under \javascript/webdriver/atoms/storage\. These files provide wrapper functions for accessing the HTML5 Application Cache status, as well as standard operations for Local Storage and Session Storage (such as get, set, remove, clear, and key enumeration). This allows automation scripts to query and modify these storage areas directly.

javascript/webdriver/atoms/storage · high confidence

The Browser module for the BiDi protocol is now implemented, exposing commands to manage browser state and user contexts. Users can create and remove isolated user contexts, retrieve the list of active user contexts and client windows, close the browser, and configure download behavior (including specifying allowed destinations or denying downloads). The module also supports setting unhandled prompt behavior and accepting insecure certificates when creating new user contexts.

dotnet/src/webdriver/BiDi/Browser · high confidence

The \common/devtools\ directory now serves as the central location for Chrome DevTools Protocol (CDP) definitions, providing \browser\_protocol.json\ and \js\_protocol.json\ (version 1.3) along with a Python-based converter (\convert\_protocol\_to\_json.py\ and \pdl.py\) to generate these files from \.pdl\ sources. A new \BUILD.bazel\ file exposes these protocol files to the JavaScript, Python, and Ruby bindings, enabling consistent protocol usage across language-specific drivers.

common/devtools · high confidence

The \org.openqa.selenium.chrome\ package has been reorganized to include new entry points and configuration classes. \ChromeDriver\ now initializes casting and CDP capabilities via \AddHasCasting\ and \AddHasCdp\ providers, and exposes a \builder()\ method for easier instantiation. \ChromeDriverService\ provides a builder pattern for configuring driver options like build checks and logging. \ChromeOptions\ and \ChromeDriverInfo\ manage browser-specific capabilities and driver discovery. Additionally, \ElectronDriver\ and \ElectronOptions\ are introduced to support driving Electron applications, while \ChromeDriverInfo\ declares support for both BiDi and CDP.

java/src/org/openqa/selenium/chrome · high confidence

The Java Firefox driver now exposes three new capabilities—installing/uninstalling extensions, capturing full-page screenshots, and switching browser contexts (content vs. chrome)—through the \HasExtensions\, \HasFullPageScreenshot\, and \HasContext\ interfaces. These are implemented via new \AugmenterProvider\ classes (\AddHasExtensions\, \AddHasFullPageScreenshot\, \AddHasContext\) that register custom GeckoDriver commands (e.g., \/session/:sessionId/moz/addon/install\, \/session/:sessionId/moz/screenshot/full\, \/session/:sessionId/moz/context\) and are automatically applied to \FirefoxDriver\ instances. This allows users to programmatically manage add-ons, take complete page captures, and interact with browser UI elements beyond the web content page.

java/src/org/openqa/selenium/firefox · high confidence

The Grid UI directory is initialized with the necessary configuration files to support a modern React-based frontend. This includes ESLint and Prettier settings for code quality, a SWC configuration for compilation, and Bazel build rules (BUILD.bazel) that define how the TypeScript sources are transpiled, bundled with esbuild, and packaged into a JAR. Additionally, Jest configuration is provided for running unit tests, and SVG assets for various browsers and operating systems are added to support the UI's visual elements.

javascript/grid-ui · high confidence

The Grid node implementation has been restructured to introduce a new \ActiveSession\ interface and \BaseActiveSession\ class, which centralize session state and dialect handling. This change adds support for custom element locators via the \CustomLocatorHandler\, allowing third-party locator strategies to be registered and used within WebDriver sessions. Additionally, a new \NodeCommandInterceptor\ SPI is introduced, enabling pluggable command interception and sidecar integration through the \--ext\ flag, while the \Node\ class now exposes dedicated endpoints for file uploads/downloads and session event firing to support remote filesystems and external monitoring.

java/src/org/openqa/selenium/grid/node · high confidence

The Selenium Grid server now allows users to extend its functionality by loading additional JARs or directories at startup using the new --ext command-line flag. This change introduces a Bootstrap entry point and a custom classloader mechanism that loads extension classes while isolating them from the core Selenium runtime, enabling third-party commands, driver implementations, or other server-side features without modifying the core distribution.

java/src/org/openqa/selenium/grid · high confidence

The IEDriverServer executable now supports a new /version command-line argument that displays version information and exits, and introduces a /whitelisted-ips argument to restrict server connections to a specified list of IPv4 addresses. These changes are implemented via a new CommandLineArguments parser and reflected in the updated project resources and versioning (4.14.0.0).

cpp/iedriverserver · high confidence

The .NET WebDriver bindings are introduced in this location, providing the core API for browser automation. The implementation is built using Bazel and targets .NET Framework 4.6.2, .NET Standard 2.0, and .NET 8.0. The codebase is fully annotated with Nullable Reference Types and uses C\# language version 14.0. It relies on \System.Text.Json\ for serialization and includes Selenium Manager binaries for all supported platforms (Linux x86\_64/arm64, macOS, Windows) to handle driver management. The bindings implement W3C WebDriver specification compliance, including support for capabilities like \webSocketUrl\ and \se:downloadsEnabled\, and provide classes for handling alerts, cookies, and element location.

dotnet/src/webdriver · high confidence

This change introduces the foundational C++ components for the WebDriver server, including the HTTP server logic, command parsing, session management, and response handling. It adds the core classes (Command, Response, Server, Session) and supporting headers (command\_types, errorcodes, keycodes, logging) that enable the server to receive JSON wire protocol requests, dispatch them to specific command handlers, and return standardized HTTP responses with appropriate error codes.

cpp/webdriver-server · high confidence

The \javascript/grid-ui/public\ directory now contains the foundational static assets for the Grid UI, including an HTML entry point (\index.html\) that loads the application, a \manifest.json\ defining the app as a standalone PWA with Selenium branding, a custom SVG favicon, and a \robots.txt\ file. A Bazel build rule (\BUILD.bazel\) is also introduced to package these static files into a JAR for distribution.

javascript/grid-ui/public · high confidence

This change introduces the initial version of Selenium Manager, a Rust-based command-line tool that automates the management of browser and driver resources for Selenium. The diff establishes the complete project structure, including the Bazel build configuration (BUILD.bazel), source code modules for managing Chrome, Edge, and other browsers (src/chrome.rs, src/edge.rs, etc.), and configuration handling (src/config.rs). It also adds essential project metadata files such as the Apache 2.0 LICENSE, NOTICE, and documentation (README.md, CHANGELOG.md, AGENTS.md). This provides the foundational codebase for the Selenium Manager CLI.

rust · high confidence

This release introduces the ability to connect to browsers via the Chrome DevTools Protocol, allowing .NET users to send commands and receive events directly. The \DevToolsSession\ class manages the WebSocket connection, while \DevToolsDomains\ provides version-independent access to browser capabilities like network manipulation, JavaScript execution, and target management. Users can now intercept network requests, monitor console logs, and control browser behavior through a structured API that automatically detects or allows specifying the DevTools protocol version.

dotnet/src/webdriver/DevTools · high confidence

The .NET bindings now include the core components required to automate Microsoft Edge: \EdgeDriver\, \EdgeDriverService\, and \EdgeOptions\. \EdgeDriver\ extends \ChromiumDriver\ and registers custom commands for Microsoft-specific features such as DevTools Protocol (CDP) execution and Cast mirroring. \EdgeOptions\ sets the default browser name to \MicrosoftEdge\, uses the \ms:\ vendor prefix for capabilities, and provides a \UseWebView\ property to launch Edge WebView2 sessions. \EdgeDriverService\ manages the \msedgedriver\ executable and supports the \SE\_EDGEDRIVER\ environment variable for locating the driver.

dotnet/src/webdriver/Edge · high confidence

Added the Safari driver implementation for .NET, including the SafariDriver class, SafariDriverService, and SafariOptions. Users can now automate Safari browsers using the standard Selenium WebDriver interface. The implementation supports configuring Safari-specific options such as enabling automatic inspection and profiling, and allows specifying the path to the SafariDriver executable. The service handles the lifecycle of the safaridriver process, including hard termination since the native driver lacks a clean shutdown API.

dotnet/src/webdriver/Safari · high confidence

This update introduces a new AndroidOptions base class to support automating browsers on Android devices, and adds a Base64UrlEncoder utility to handle encoding without external dependencies. It also includes internal refactoring of file, port, and resource utilities to improve reliability in various execution environments, and updates the cookie handling to properly expose SameSite attributes in returned cookies.

dotnet/src/webdriver/Internal · high confidence

The .NET bindings now include the Internet Explorer driver implementation, providing the InternetExplorerDriver, InternetExplorerOptions, and InternetExplorerDriverService classes. Users can launch and control Internet Explorer browsers using these new types, which support IE-specific capabilities such as protected mode settings, element scroll behavior, and full-page screenshots. The driver service integrates with Selenium Manager for automatic driver location and supports asynchronous service start/stop operations.

dotnet/src/webdriver/IE · high confidence

Adds a new \OpenQA.Selenium.BiDi\ namespace providing a bidirectional communication layer over WebSockets, enabling real-time event streaming and command execution. The implementation includes a \BiDi\ entry point for connection management, a \Broker\ for internal transport and message handling, and dedicated modules (such as BrowsingContext, Network, Script, and Input) that expose specific WebDriver BiDi capabilities. Users can now subscribe to live events via \StreamAsync\ or \SubscribeAsync\, execute commands with cancellation support, and configure the underlying WebSocket transport using \BiDiOptionsBuilder\.

dotnet/src/webdriver/BiDi · high confidence

This change adds a new \javascript/chrome-driver\ directory containing Chrome-specific Selenium WebDriver atoms (such as \getLocationInView\, \isElementClickable\, and \getPageZoom\) and the Bazel build rules (\BUILD.bazel\) required to compile them into C++ headers and source files for the ChromeDriver binary. The implementation includes support for Shadow DOM visibility checks and improved scrolling logic to ensure elements are correctly positioned in the viewport, addressing previous issues where elements were not clickable or located correctly within complex DOM structures.

javascript/chrome-driver · high confidence

This change adds a new GraphQL endpoint to the Selenium Grid, enabling users to query grid topology, node health, and active session details via a structured API. The implementation includes a new \GraphqlHandler\ that processes queries against a \selenium-grid-schema.graphqls\ definition, exposing data such as node counts, session queues, and individual session capabilities. It replaces the previous caching mechanism with Caffeine for improved performance and filters out reserved sessions to ensure only active sessions are reported in the grid status.

java/src/org/openqa/selenium/grid/graphql · high confidence

This change adds the foundational transport layer for WebDriver BiDi in Java, including the \BiDi\ class for managing WebSocket connections, sending commands, and subscribing to events, along with \Connection\, \Command\, \Event\, and \Handle\ classes. It also introduces \BiDiProvider\, an \AugmenterProvider\ that automatically augments \WebDriver\ instances with the \HasBiDi\ interface when a \webSocketUrl\ capability is present, enabling lazy initialization of the BiDi connection. The \BUILD.bazel\ file defines the new \bidi\ and \augmenter\ libraries, and the package is marked with \@Beta\ and nullability annotations.

java/src/org/openqa/selenium/bidi · high confidence

The Java binding now includes a dedicated \selenium-manager\ module that wraps the Selenium Manager binary to automatically locate and manage browser drivers. This change introduces a new Maven artifact (\org.seleniumhq.selenium:selenium-manager\) which bundles prebuilt Selenium Manager executables for Linux (x86\_64 and arm64), macOS, and Windows directly into the JAR. The Java implementation uses a singleton pattern to extract the appropriate platform binary to a temporary cache, executes it via \ProcessBuilder\ to retrieve driver paths from JSON output, and cleans up the temporary binary on JVM shutdown. It also opens the module to \org.seleniumhq.selenium.json\ to enable JSON parsing of the manager's output.

java/src/org/openqa/selenium/manager · high confidence

Added a new \org.openqa.selenium.virtualauthenticator\ package that enables users to simulate WebAuthn virtual authenticators in tests. This includes the \HasVirtualAuthenticator\ interface for driver integration, \VirtualAuthenticatorOptions\ to configure protocol (CTAP2/U2F) and transport settings, and the \Credential\ class to manage resident and non-resident credentials. Users can now add, list, and remove simulated credentials and control user verification states without physical hardware.

java/src/org/openqa/selenium/virtualauthenticator · high confidence

The Grid now includes a new \LocalDistributor\ implementation that manages node registration, health checks, and session distribution within the same JVM process. This change adds dedicated scheduled executors for handling new session requests, purging dead nodes, and running node health checks, along with a \LocalGridModel\ and \LocalNodeRegistry\ to track node state and availability in memory. Users benefit from improved reliability and configurability of the local Grid mode, including better handling of node restarts, draining states, and health-check failures, as well as JMX monitoring exposure for the distributor.

java/src/org/openqa/selenium/grid/distributor/local · high confidence

A new LocalNode implementation and its factory are added to the grid, enabling the Selenium Grid to run as a standalone node that manages local WebDriver sessions directly. This change introduces a new build target (BUILD.bazel) and core classes (LocalNode, LocalNodeFactory, SessionSlot) that handle session lifecycle, capability matching, and node draining, while integrating with the existing event bus and command interceptor infrastructure.

java/src/org/openqa/selenium/grid/node/local · high confidence

Added a new \OneShotNode\ implementation in the \org.openqa.selenium.grid.node.k8s\ package that registers as a node, accepts exactly one WebDriver session, and then automatically drains and shuts down. This enables Kubernetes environments to provision ephemeral nodes per session, with configuration driven by \--driver-name\ and \--stereotype\ flags (via \OneShotFlags\) and integration with the grid's event bus and JMX monitoring.

java/src/org/openqa/selenium/grid/node/k8s · high confidence

The Java bindings now include a local event bus implementation (GuavaEventBus) in the org.openqa.selenium.events.local package, enabling internal components to subscribe to and fire events using Guava's EventBus under the hood. Additionally, a new org.openqa.selenium.status package provides the HasReadyState functional interface, allowing components to expose a simple isReady() check for readiness state.

java/src/org/openqa/selenium/events/local, java/src/org/openqa/selenium/status · high confidence

A new local session map implementation is added to the Grid, storing active sessions in a Caffeine-backed cache with 60-minute expiration for recently removed sessions to improve diagnostics on NoSuchSessionException. The component listens to SessionClosedEvent, NodeRemovedEvent, and NodeRestartedEvent to track and batch-remove sessions, and exposes nullability annotations via jspecify for better static analysis.

java/src/org/openqa/selenium/grid/sessionmap/local · high confidence

The Grid now includes a new local implementation of the session queue (\LocalNewSessionQueue\) that manages new session requests in memory. This component introduces batch consumption of requests, configurable request timeouts, and a maximum response delay to prevent creating sessions that would immediately time out or be disposed. It also adds JMX management for monitoring queue state and ensures graceful shutdown behavior to avoid resource leaks during server stop.

java/src/org/openqa/selenium/grid/sessionqueue/local · high confidence

Added new \RemoteDistributor\ and \RemoteSessionMap\ classes that implement grid components by communicating with a remote Selenium Grid via HTTP. \RemoteDistributor\ handles node registration, draining, removal, status checks, and session creation by sending JSON requests to the grid's distributor endpoints, while \RemoteSessionMap\ manages session lifecycle (add, get, remove, URI lookup) by interacting with the grid's session endpoints. Both implementations are annotated with \@NullMarked\ from the \jspecify\ library to enforce null-safety and are wired into the build system with appropriate visibility and dependencies.

java/src/org/openqa/selenium/grid/distributor/remote, java/src/org/openqa/selenium/grid/sessionmap/remote · high confidence

Added a new \RemoteNewSessionQueue\ component that implements the \NewSessionQueue\ interface by communicating with a remote grid endpoint over HTTP. This allows the grid to manage new session requests via a distributed queue service rather than local memory, supporting operations like adding, retrieving, and completing session requests through REST API calls.

java/src/org/openqa/selenium/grid/sessionqueue/remote · high confidence

The grid now includes a new \RemoteNode\ implementation that allows the distributor to communicate with and manage remote browser nodes over HTTP. This component handles session creation requests, health checks with specific timeouts, and node status reporting, enabling the grid to distribute sessions across multiple nodes. It also introduces retry logic for session creation when a remote node is shutting down or restarting, improving reliability in distributed environments.

java/src/org/openqa/selenium/grid/node/remote · high confidence

The Selenium Manager component is now included in the .NET bindings, providing an experimental API that automatically detects installed browser versions, downloads matching driver binaries, and caches them for subsequent use. This eliminates the need for manual driver management by handling the discovery and configuration of browser drivers internally, with the manager binary shipped directly within the package.

dotnet/src/webdriver/Manager · high confidence

The \org.openqa.selenium.remote.codec.w3c\ package now provides the core encoding and decoding logic for the W3C WebDriver protocol. \W3CHttpCommandCodec\ maps internal driver commands to W3C-compliant HTTP endpoints (such as \/session/:sessionId/element\ and \/session/:sessionId/execute/sync\) and handles locator translation, while \W3CHttpResponseCodec\ interprets W3C JSON responses, including specific error handling for alerts and HTTP status codes. This change establishes the protocol-specific layer required for W3C-compliant browser automation.

java/src/org/openqa/selenium/remote/codec/w3c · high confidence

The \org.openqa.selenium.bidi.emulation\ package introduces a new BiDi emulation interface (\Emulation\) that allows users to override browser settings via commands such as \setScriptingEnabled\, \setNetworkConditions\, \setScreenOrientationOverride\, \setScreenSettingsOverride\, \setUserAgentOverride\, \setTimezoneOverride\, and \setGeolocationOverride\. This update adds support for disabling JavaScript emulation (previously only enabling was supported), allows null values for geolocation overrides, and marks all classes in the package as \@Beta\ with nullability annotations.

java/src/org/openqa/selenium/bidi/emulation · high confidence

The \org.openqa.selenium.bidi.network\ package now includes the core Java classes required for WebDriver BiDi network interception and monitoring. This adds parameter builders for network commands (\AddInterceptParameters\, \ContinueRequestParameters\, \ContinueResponseParameters\, \ProvideResponseParameters\), event data models (\BeforeRequestSent\, \FetchError\, \ResponseDetails\), and supporting types (\AuthChallenge\, \BytesValue\, \CacheBehavior\, \Cookie\, \FetchTimingInfo\, \Header\, \Initiator\, \InterceptPhase\, \RequestData\, \ResponseData\, \SetCookieHeader\, \UrlPattern\). These classes enable users to configure network intercepts, handle authentication challenges, and access detailed request/response metadata and timing information within the BiDi protocol.

java/src/org/openqa/selenium/bidi/network · high confidence

The Java print API has been expanded to allow finer control over printed output. Users can now configure page margins via the new PageMargin class, select from predefined or custom page sizes using PageSize (including constants like ISO\_A4 and US\_LETTER), and specify page ranges using a List in addition to the previous varargs method. These options are structured into dedicated model classes that serialize to the required map format for the print command.

java/src/org/openqa/selenium/print · high confidence

The selenium-webdriver package has been moved to the repository root, bringing with it a comprehensive restructuring of the build and development environment. This change introduces a Bazel-based build system that automates the generation of TypeScript modules from the WebDriver BiDi CDDL specification, ensuring type fidelity across bindings. The package now includes a full implementation of the BiDi protocol, featuring new modules for browser management, browsing context lifecycle, event inspection, and network interception. Additionally, the release standardizes developer tooling with Prettier and ESLint configurations, updates the minimum supported Node.js version to 22, and bundles prebuilt Selenium Manager binaries for Linux arm64.

javascript/selenium-webdriver · high confidence

The .NET bindings now include dedicated documentation and configuration files to standardize the development experience. A new .editorconfig enforces consistent C\# formatting (Allman-style braces, file-scoped namespaces) and sets specific Roslyn diagnostic severities. AGENTS.md provides guidance for AI coding assistants and human contributors on code location, logging conventions, deprecation handling, and async patterns. TESTING.md details the NUnit-based test infrastructure, including how to run tests via Bazel or IDEs, skip tests for specific browsers/platforms, and manage driver lifecycles. Additionally, a new Selenium.slnx solution file and updated README.md clarify the Bazel-centric build process and dependency management using Paket.

dotnet · high confidence

The JavaScript module now uses Bazel for building, introducing BUILD.bazel and defs.bzl files that configure tools like pnpm and Prettier, and expose custom rules for Closure JS dependencies and Mocha tests. A new webdriver-bootstrap.js file has been added to the root of the JavaScript directory to load the Closure library and generated deps.js in the correct order for browser-based usage, while a readme.txt provides instructions for regenerating dependencies and running the local test server.

javascript · high confidence

The build system now includes new private Bazel rules in common/private to handle packaging and driver distribution. These include dmg\_archive and deb\_archive for downloading and extracting macOS DMG and Debian packages, pkg\_archive for macOS .pkg files, and zip\_file for creating zip archives. Additionally, drivers.bzl introduces local\_drivers to expose local browser drivers (chromedriver, msedgedriver, geckodriver) as Bazel targets, while passwd.bzl provides rules for generating passwd files and tar archives for container environments.

common/private · high confidence

The WebDriver BiDi protocol now includes an Emulation module, exposing a new IEmulationModule interface and implementation that allows users to override browser environment settings. This adds support for commands such as SetTimezoneOverride, SetUserAgentOverride, SetLocaleOverride, SetMediaFeaturesOverride, SetForcedColorsModeThemeOverride, SetScriptingEnabled, SetScreenOrientationOverride, SetScreenSettingsOverride, SetScrollbarTypeOverride, SetTextLayoutModeOverride, SetGeolocationOverride, SetTouchOverride, and SetNetworkConditions, enabling precise control over how the browser presents itself and handles device/network characteristics during automation.

dotnet/src/webdriver/BiDi/Emulation · high confidence

The WebDriver BiDi implementation now includes a dedicated Input module that exposes the \input.performActions\, \input.releaseActions\, and \input.setFiles\ commands, along with a new \input.fileDialogOpened\ event. Users can now simulate complex input sequences using key, pointer, wheel, and none source actions, with pointer moves supporting double-precision coordinates and configurable origins (viewport, pointer, or element). The module also provides a \FileDialogOpenedEventArgs\ to handle file dialog interactions, including support for multiple file selection and element references.

dotnet/src/webdriver/BiDi/Input · high confidence

Added a set of new JSON converters in the BiDi layer to handle specific data types required by the WebDriver BiDi specification. These include converters for camel-case and kebab-case enums, date-time offsets (both milliseconds and seconds), optional values, and identifiable objects. Additionally, specialized converters handle print page ranges and special double values (NaN, Infinity, -Infinity, and -0) to ensure compliance with the BiDi protocol's serialization rules.

dotnet/src/webdriver/BiDi/Json/Converters · high confidence

The BiDi Network module is now available, providing a comprehensive API for intercepting and collecting network traffic. Users can add and remove intercepts to control request and response phases (BeforeRequestSent, ResponseStarted, AuthRequired) and add or remove data collectors to gather request/response bodies. The module exposes events for network activity and commands to continue, fail, or provide responses, as well as set extra headers and manage cache behavior. It includes support for authentication challenges, cookie handling, and retrieving data via collectors.

dotnet/src/webdriver/BiDi/Network · high confidence

The BiDi Script module is now available, providing the ability to execute JavaScript in browsing contexts and worker realms. Users can evaluate expressions and call functions via \EvaluateAsync\ and \CallFunctionAsync\, with support for passing arguments, awaiting promises, and managing result ownership. The module introduces a rich type system for JavaScript values, including \LocalValue\ for sending data and \RemoteValue\ for receiving results, with automatic conversion between .NET types and JavaScript primitives, objects, arrays, and regular expressions. It also supports script preloading via \AddPreloadScript\, handle management with \Disown\, and event streaming for realm creation/destruction and channel messages. Serialization is handled via custom JSON converters that support polymorphic deserialization for realm types and evaluation results.

dotnet/src/webdriver/BiDi/Script · high confidence

The WebDriver BiDi implementation now includes a dedicated Session module that exposes session lifecycle and configuration commands. Users can create new sessions with detailed capabilities (including browser name, version, platform, and proxy settings) and end sessions. The module supports checking session status, subscribing to and unsubscribing from events (with optional context and user context filtering), and handling user prompts via a configurable handler. Proxy configuration is supported with specific types (autodetect, direct, manual, PAC, system) and SOCKS proxy options.

dotnet/src/webdriver/BiDi/Session · high confidence

Users can now configure browser download behavior (allowing or denying downloads with a specified destination folder) and retrieve detailed information about client windows (including state, dimensions, and position) via the BiDi protocol. These new classes, marked as Beta, are part of the \org.openqa.selenium.bidi.browser\ package and include support for null-safety annotations.

java/src/org/openqa/selenium/bidi/browser · high confidence

This change introduces a new \org.openqa.selenium.bidi.module\ package that provides a unified entry point for interacting with BiDi modules. It adds a \Browser\ class for managing user contexts and download behavior, an \Input\ class for performing actions and setting files, a \Permission\ class for setting permissions, a \Script\ class for calling functions and evaluating expressions, and a \Storage\ class for cookie management. Additionally, it introduces several inspector classes (\BrowsingContextInspector\, \LogInspector\, \Network\, \SpeculationInspector\) that allow subscribing to specific BiDi events like navigation, logging, network activity, and prefetch status. These classes are marked as \@Beta\ and are designed to simplify the BiDi API by providing a more structured, module-oriented approach compared to the raw command/event handling.

java/src/org/openqa/selenium/bidi/module · high confidence

This change introduces a new \org.openqa.selenium.cli\ package that provides the foundational mechanisms for configuring and running Selenium Grid via the command line. It adds the \CliCommand\ interface, which allows commands to expose configurable roles and flag objects, and a \WrappedPrintWriter\ utility for formatted output. The package is annotated with \@NullMarked\ to enforce null-safety, and a Bazel build file defines the library dependencies, including the core Selenium library and the grid configuration module.

java/src/org/openqa/selenium/cli · high confidence

The \org.openqa.selenium.chromium\ package introduces a new \ChromiumDriver\ base class and a suite of interfaces (\HasCasting\, \HasCdp\, \HasLaunchApp\, \HasNetworkConditions\, \HasPermissions\) that enable advanced browser control. Users can now cast devices, execute Chrome DevTools Protocol (CDP) commands, launch Chromium apps, simulate network conditions (latency, offline mode, throughput), and manage browser permissions directly through the driver. This package also includes \ChromiumOptions\ for configuration and \ChromiumNetworkConditions\ for defining network constraints.

java/src/org/openqa/selenium/chromium · high confidence

The .NET bindings now include a dedicated \Chromium\ namespace with a base \ChromiumDriver\ and \ChromiumDriverService\ that consolidate Chrome, Edge, and Android Chromium automation. Users can configure driver logging levels (\ChromiumDriverLogLevel\), enable verbose logging, append to log files, and add readable timestamps via the service. Browser-side options include mobile emulation settings, performance logging preferences with tracing categories, network condition simulation, and Android-specific options such as \UseRunningApp\ and \AndroidProcess\. The driver also registers custom commands for Chrome DevTools Protocol execution, casting (sinks, mirroring), and permission management.

dotnet/src/webdriver/Chromium · high confidence

The Dynamic Grid node now includes a new \org.openqa.selenium.grid.node.docker\ package that provides a complete implementation for provisioning browser sessions in Docker containers. This change introduces configuration flags for Docker connection details, API version pinning, device mappings, and container grouping labels, alongside logic to manage browser and video recording containers, handle session timeouts, and save container logs to local assets. This new module replaces or supplements previous Docker node logic, enabling users to run Selenium Grid nodes that dynamically spawn browser containers with configurable host configurations and asset storage paths.

java/src/org/openqa/selenium/grid/node/docker · high confidence

Added new JavaScript atoms for interacting with HTML5 features: \appcache.js\ exposes the application cache status, \database.js\ provides wrappers for opening Web SQL databases and executing SQL queries, \storage.js\ adds support for reading and writing to localStorage and sessionStorage, and \location.js\ enables retrieving the device's geolocation. These changes also include \html5\_browser.js\, which introduces a centralized helper to detect browser support for these specific HTML5 APIs, ensuring commands fail gracefully on unsupported browsers.

javascript/atoms/html5 · high confidence

Introduces a new \RouterServer\ component in the \org.openqa.selenium.grid.router.httpd\ package, providing an alternative HTTP/Netty-based router for the Selenium Grid. This implementation adds configuration flags to disable the Grid UI (\--disable-ui\), enable transparent TCP tunneling for WebSocket connections (\--tcp-tunnel\), and specify a sub-path for all user-facing routes (\--sub-path\). It also enforces basic authentication via username/password flags and improves health-check responses by returning appropriate HTTP status codes on the \/readyz\ endpoint.

java/src/org/openqa/selenium/grid/router/httpd · high confidence

The Grid JMX package now includes a JMXHelper utility and an MBean wrapper that automatically expose annotated Grid components via JMX. By marking a service with @ManagedService and its properties/methods with @ManagedAttribute or @ManagedOperation, developers can register beans with the platform MBean server without manual JMX boilerplate, enabling easier runtime monitoring and management of Grid nodes.

java/src/org/openqa/selenium/grid/jmx · high confidence

This change introduces the \org.openqa.selenium.bidi.browsingcontext\ package, providing a new Java API for the WebDriver BiDi browsing context module. The \BrowsingContext\ class exposes methods to create, navigate, reload, and traverse browsing contexts, as well as capture screenshots (including box and element clips) and handle user prompts. It is accompanied by supporting classes for locating nodes (\Locator\, \LocateNodeParameters\), managing navigation and download events (\NavigationInfo\, \DownloadInfo\, \HistoryUpdated\), and configuring screenshot formats and clip rectangles. All classes in this package are marked with the \@Beta\ annotation.

java/src/org/openqa/selenium/bidi/browsingcontext · high confidence

Selenium introduces a new \org.openqa.selenium.docker\ package providing a Java-native client for managing Docker containers. This library features a \Docker\ class that automatically detects and selects the appropriate Docker API version (supporting 1.40, 1.44, and 1.48) via an adapter pattern, ensuring compatibility across different Docker Engine versions. It includes classes for configuring containers (\ContainerConfig\), handling images (\Image\, \ImageId\), and managing container lifecycles (\Container\, \ContainerInfo\), along with a \BUILD.bazel\ file defining the new module dependencies.

java/src/org/openqa/selenium/docker · high confidence

Added the \org.openqa.selenium.bidi.storage\ package, providing Java classes to interact with the WebDriver BiDi storage commands. This includes builders and parameter objects for setting (\SetCookieParameters\, \PartialCookie\), getting (\GetCookiesParameters\, \GetCookiesResult\), and deleting (\DeleteCookiesParameters\) cookies, along with filtering (\CookieFilter\) and partition descriptors (\PartitionDescriptor\, \StorageKeyPartitionDescriptor\, \BrowsingContextPartitionDescriptor\) to support partitioned storage contexts. All classes are marked as \@Beta\.

java/src/org/openqa/selenium/bidi/storage · high confidence

The \org.openqa.selenium.bidi.script\ package now includes a comprehensive set of model classes to support the WebDriver BiDi script module. This adds support for executing and evaluating JavaScript, including parameter builders (\CallFunctionParameters\, \EvaluateParameters\) and result types (\EvaluateResultSuccess\, \EvaluateResultExceptionValue\). It also introduces local and remote value representations (\LocalValue\, \RemoteValue\, \ArrayLocalValue\, \MapLocalValue\, etc.) for serializing and deserializing script arguments and return values, along with supporting types for realms (\RealmInfo\, \RealmTarget\), channels (\ChannelValue\), and node properties (\NodeProperties\).

java/src/org/openqa/selenium/bidi/script · high confidence

A new command-line tool, JavadocJarMaker, has been added to the Selenium Java build system. This utility generates Javadoc JARs from source JARs, utilizing the \rules\_jvm\_external\ library to ensure stable zip entries (deterministic output). It is now available as a public Bazel target (\//java/src/dev/selenium/tools/javadoc:javadoc\) and depends on the core Selenium library and the new \io\ artifact.

java/src/dev/selenium/tools/javadoc · high confidence

Selenium Grid nodes can now run in Kubernetes by automatically spawning browser sessions as ephemeral Jobs. This adds a new \selenium-node-kubernetes\ module (with CLI flags like \--kubernetes-configs\ and \--kubernetes-namespace\) that inherits Pod specifications (such as security context, resource limits, and node selectors) from the Node Pod to the browser Jobs. File uploads and downloads are forwarded via port-forwarding, and session assets (logs and videos) are stored in per-session subfolders within a configurable assets path.

java/src/org/openqa/selenium/grid/node/kubernetes · high confidence

A new \ModuleGenerator\ tool has been added to the Selenium Java build tools, allowing users to convert standard JARs into Java Platform Module System (JPMS) modules. This utility accepts an input JAR and configuration flags (such as \--exports\, \--hides\, \--opens-to\, and \--uses\) to generate a properly structured module JAR. It leverages \jdeps\ for dependency analysis and libraries like JavaParser and ByteBuddy to inspect and modify bytecode, ensuring the resulting JAR includes the correct \module-info.class\ and manifest attributes.

java/src/dev/selenium/tools/modules · high confidence

This change introduces the \org.openqa.selenium.grid.node.config\ package, which centralizes Node configuration and session management. It adds \NodeFlags\ and \NodeOptions\ to handle command-line arguments and configuration values (such as max sessions, timeouts, and driver settings), a \DriverServiceSessionFactory\ to manage the lifecycle of driver services and sessions, and a \SessionCapabilitiesMutator\ to merge and validate session capabilities against node stereotypes. A \BUILD.bazel\ file is also added to define the build dependencies for this new module.

java/src/org/openqa/selenium/grid/node/config · high confidence

The \org.openqa.selenium.remote.tracing\ package now provides a new abstraction for distributed tracing, introducing interfaces like \Tracer\, \Span\, and \Propagator\ to replace previous implementations. This change introduces \TracedHttpClient\ and \SpanDecorator\ to automatically instrument HTTP client requests and server-side handlers with OpenTelemetry-compatible spans, capturing attributes such as HTTP method, status codes, and exceptions. The package also defines \AttributeKey\ constants and \Tags\ to standardize trace data, allowing users to integrate Selenium's remote communication with existing OpenTelemetry tracing backends.

java/src/org/openqa/selenium/remote/tracing · high confidence

Added a new Relay node implementation that allows Selenium Grid nodes to forward WebDriver commands to an external service (such as an Appium server or cloud provider). This includes command-line flags and configuration options for specifying the target service URL, host, port, status endpoint, and protocol version, as well as logic to parse service configurations, match capabilities against a defined stereotype, and manage session lifecycles via a dedicated session factory.

java/src/org/openqa/selenium/grid/node/relay · high confidence

The BiDi API now includes a Speculation module, allowing users to monitor resource prefetching activities. This change introduces the \ISpeculationModule\ interface and a \SpeculationBiDiExtensions.AsSpeculation()\ method to access the module from the BiDi connection. Users can subscribe to the \PrefetchStatusUpdated\ event, which provides \PrefetchStatusUpdatedEventArgs\ containing the browsing context, URL, and a \PreloadingStatus\ (Pending, Ready, Success, or Failure) to track the outcome of prefetch requests.

dotnet/src/webdriver/BiDi/Speculation · high confidence

The \dotnet/src/support/UI\ package now includes several new classes to simplify common UI automation patterns. \LoadableComponent\<T\>\ and \SlowLoadableComponent\<T\>\ provide a base for modeling pages or components that load asynchronously, with the latter adding timeout-based polling for slow-loading content. \PopupWindowFinder\ allows users to easily detect and switch to new browser windows opened by clicking elements or invoking actions. \SelectElement\ offers a convenient API for interacting with HTML \\<select\>\ elements, including selecting options by text or value and retrieving selected options. Additionally, \ILoadableComponent\, \LoadableComponentException\, and \UnexpectedTagNameException\ support these functionalities with appropriate interfaces and error handling.

dotnet/src/support/UI · high confidence

The .NET bindings now include a new \OpenQA.Selenium.Interactions\ namespace that implements the W3C WebDriver specification for advanced user interactions. This introduces a structured API with \Actions\ as the main builder, supporting distinct input devices (\PointerInputDevice\, \KeyInputDevice\, \WheelInputDevice\) and action sequences (\ActionSequence\). Users can now perform complex gestures including pointer down/up, key presses, pauses, and wheel scrolling, with the framework handling the serialization of these actions into the standard wire format.

dotnet/src/webdriver/Interactions · high confidence

The .NET support library now includes a new \WebDriverExtensions\ class that provides convenient extension methods for \IWebDriver\. Users can call \TakeScreenshot()\ directly on any driver instance, which automatically handles unwrapping drivers that implement \IWrapsDriver\ to locate the underlying screenshot capability. Additionally, \ExecuteJavaScript()\ is available in two forms: a void version for scripts that do not return values, and a generic \ExecuteJavaScript\<T\>()\ version that automatically converts the script's return value to the specified type, including fallback conversion logic and null-safety checks for value types.

dotnet/src/support/Extensions · high confidence

The \org.openqa.selenium.support.decorators\ package introduces a new \WebDriverDecorator\ class that allows users to extend or modify the behavior of WebDriver instances and derived objects (like WebElement and Alert) without subclassing. This feature, marked as Beta, uses ByteBuddy to create dynamic proxies, enabling developers to intercept method calls before, after, or instead of the original execution, and handle errors. The package includes supporting classes like \Decorated\ and \DefaultDecorated\ to manage the decorated state and relies on \jspecify\ for nullability annotations.

java/src/org/openqa/selenium/support/decorators · high confidence

Selenium introduces a new \io\ Maven artifact containing core I/O utilities. This includes \FileHandler\ for filesystem operations, \Zip\ for creating and extracting archives (preserving file modification times), \TemporaryFilesystem\ for managing temporary directories with automatic cleanup, \CircularOutputStream\ and \MultiOutputStream\ for stream handling, and \Read\ for safely reading input streams as UTF-8 strings. The module depends on \jspecify\ for null-safety annotations.

java/src/org/openqa/selenium/io · high confidence

The repository now includes a comprehensive set of new scripts to standardize the build and development workflow. A unified \format.sh\ and \format.ps1\ script provides targeted, per-language code formatting and linting (including Ruff for Python, RuboCop for Ruby, and Google Java Format) with smart change detection. CI reliability is improved with scripts for flaky test reporting (\flaky-report.sh\, \parse-flaky-results.sh\), automatic reruns on transient failures (\rerun-failures.sh\), and disk space management. Developer onboarding is streamlined via a Windows \dev-environment-setup.ps1\ script and a \dev-image\ Dockerfile. Additionally, new Bazel targets in \scripts/BUILD.bazel\ manage build-time utilities like pinned browser updates, CDP synchronization, and copyright generation.

scripts · high confidence

A new \org.openqa.selenium.concurrent\ package has been added to the Java client, providing core utilities for concurrent operations. This includes a \Lazy\<T\>\ class for thread-safe, lazy initialization of values, a \GuardedRunnable\ helper to prevent scheduled tasks from stopping when they throw exceptions, and an \ExecutorServices\ utility for graceful shutdown of executor services. The package is now buildable via Bazel and depends on \org.jspecify:jspecify\ for nullability annotations.

java/src/org/openqa/selenium/concurrent · high confidence

A new configuration package (\org.openqa.selenium.grid.sessionmap.config\) has been introduced to manage Session Map server settings within the Selenium Grid. This includes command-line flags for specifying the session server's host, port, scheme (e.g., redis, http), and implementation class, as well as a \SessionMapOptions\ class that resolves these settings into a URI and the appropriate \SessionMap\ instance. The module is built with Bazel and depends on JCommander for argument parsing and JSpecify for nullability annotations.

java/src/org/openqa/selenium/grid/sessionmap/config · high confidence

The .NET EventFiringWebDriver now exposes events for getting and completing shadow root retrieval (GettingShadowRoot/GetShadowRootCompleted) and includes new event argument classes (GetShadowRootEventArgs, FindElementEventArgs, WebDriverNavigationEventArgs, WebDriverScriptEventArgs, WebElementEventArgs, WebElementValueEventArgs, WebDriverExceptionEventArgs) to provide richer context for these and other driver actions.

dotnet/src/support/Events · high confidence

This change introduces a new \org.openqa.selenium.events\ package that provides a typed, JSON-serializable event system for internal component communication. It adds the \Event\ class for carrying unique IDs and typed data, an \EventBus\ interface for subscribing listeners and firing events, and an \EventListener\ utility that bridges generic Java consumers to specific event types. The implementation relies on the \jspecify\ library for null-safety annotations and the existing JSON library for serialization, establishing a foundation for decoupled, asynchronous interactions within the Selenium Java bindings.

java/src/org/openqa/selenium/events · high confidence

The \org.openqa.selenium.support.events\ package now provides a new \EventFiringDecorator\ and \WebDriverListener\ interface that allow you to wrap a WebDriver instance to intercept and observe method calls. Listeners can subscribe to specific events (such as \beforeGet\ or \afterFindElement\) or generic events (such as \beforeAnyCall\) to perform logging, debugging, or other side effects. By default, exceptions thrown by listeners are suppressed, but this behavior can be changed by overriding \throwsExceptions()\. The package also includes a \WebDriverListenerException\ for wrapping listener errors and depends on \jspecify\ for nullability annotations.

java/src/org/openqa/selenium/support/events · high confidence

The Selenium Grid now provides a new command-line interface for managing grid components, including dedicated commands for the Hub, Standalone server, and EventBus. This update introduces a new 'completion' command that generates Zsh shell autocompletions for the Selenium CLI, improving the user experience when typing commands. Additionally, an 'info' command has been added to display help documentation on various grid topics such as configuration, security, and Kubernetes integration.

java/src/org/openqa/selenium/grid/commands · high confidence

This change introduces a new set of data classes and event types in the \org.openqa.selenium.grid.data\ package to support the Grid's session and node lifecycle. It adds structured data models for session creation requests and responses (\CreateSessionRequest\, \CreateSessionResponse\, \NewSessionResponse\), node status reporting (\NodeStatus\, \DistributorStatus\), and slot matching logic (\DefaultSlotMatcher\, \SemanticVersionComparator\). Additionally, it defines a comprehensive set of server-side events (\NodeAddedEvent\, \NodeRemovedEvent\, \NodeDrainStarted\, \NodeDrainComplete\, \NewSessionResponseEvent\, etc.) to enable integration with the Grid's event bus, allowing external systems to react to node availability changes and session creation outcomes.

java/src/org/openqa/selenium/grid/data · high confidence

A new \org.openqa.selenium.grid.security\ package has been introduced, providing core security components for the Selenium Grid. This includes \AddSecretFilter\ and \RequiresSecretFilter\ to manage and validate registration secrets via the \X-REGISTRATION-SECRET\ header, and \BasicAuthenticationFilter\ to enforce HTTP Basic Authentication using configured username and password credentials. The \SecretOptions\ class handles configuration loading for these secrets and authentication, while the \Secret\ class provides value-based equality and encoding utilities. These filters allow grid nodes and routers to secure internal communication channels.

java/src/org/openqa/selenium/grid/security · high confidence

The \org.openqa.selenium.grid.session\ package has been introduced, containing the \ActiveSession\ and \SessionFactory\ interfaces along with a \package-info.java\ that applies \@NullMarked\ nullability constraints. This change establishes the core abstractions for managing WebDriver sessions within the grid, explicitly defining null-safety expectations for the session lifecycle and creation logic.

java/src/org/openqa/selenium/grid/session · high confidence

The Selenium Grid web layer has been restructured with a new \web\ package containing core components for request handling and static resource serving. This includes \GridUiRoute\ to serve the Grid UI console, \ResourceHandler\ for serving static assets from classpath or file systems, and \ReverseProxyHandler\ to forward requests to upstream nodes while filtering specific HTTP headers. Security and compliance are enforced via \CheckOriginHeader\ and \CheckContentTypeHeader\ filters, which validate request origins and ensure JSON UTF-8 content types, while \EnsureSpecCompliantResponseHeaders\ guarantees proper response headers. The \RoutableHttpClientFactory\ enables internal routing of HTTP clients to these handlers, and \StatusBasedReadinessCheck\ provides Kubernetes-compatible health checks by reading the grid status.

java/src/org/openqa/selenium/grid/web · high confidence

The \org.openqa.selenium.docker.internal\ package now includes \ImageSummary\ and \Reference\ classes to handle Docker image metadata. \Reference\ parses Docker image strings into domain, name, tag, digest, and platform components, normalizing legacy domains and defaulting to the host architecture. \ImageSummary\ provides a JSON deserialization structure for image IDs and repository tags. These classes are marked as \@Beta\ and are part of the internal Docker support infrastructure.

java/src/org/openqa/selenium/docker/internal · high confidence

Selenium WebDriver for .NET now includes a new internal logging infrastructure that allows users to capture detailed diagnostic information. The system supports writing logs to a file via the new FileLogHandler, which can be configured to overwrite or append to existing files. By default, internal logs are set to the Warn level to reduce noise, but setting the SE\_DEBUG environment variable enables Debug-level logging and directs output to stderr. The implementation uses lazy initialization for handlers and interpolated string handlers to minimize performance overhead when logging is disabled.

dotnet/src/webdriver/Internal/Logging · high confidence

This change introduces a new \httpd\ module for the Selenium Grid Node, containing the \NodeServer\ command, default configuration (\DefaultNodeConfig\), and package-level nullability annotations. The \NodeServer\ exposes a \/readyz\ endpoint that returns HTTP 200 when the node has capacity and HTTP 503 when it does not, and it registers a shutdown hook to fire a \NodeRemovedEvent\ when the JVM terminates. The module depends on \guava\, \failsafe\, and \jspecify\, and is wired into the build system via a new \BUILD.bazel\ file.

java/src/org/openqa/selenium/grid/node/httpd · high confidence

This change introduces a new \org.openqa.selenium.grid.server\ package that consolidates server startup logic, command-line flags, and runtime options. Users benefit from a new \--bind-host\ flag to control whether the server binds to the reported hostname (useful for Docker/containerized environments), configurable external URIs via \--external-url\, and a new server-side event bus integration. The event bus allows components to publish and subscribe to events using configurable connection strings (\--publish-events\, \--subscribe-events\) and supports pluggable implementations (defaulting to ZeroMQ) with configurable heartbeat periods to prevent connection theft. The build system (Bazel) is updated to include this new module with dependencies on JCommander, Guava, and JSpecify.

java/src/org/openqa/selenium/grid/server · high confidence

The grid distributor now includes a new \selector\ package containing the \SlotSelector\ interface and two implementations: \DefaultSlotSelector\ and \GreedySlotSelector\. The default selector prioritizes nodes with diverse browser configurations to preserve availability for niche requests, while the new greedy selector maximizes node utilization by filling partially used nodes first. This change introduces a new build target (\selector\) with dependencies on Guava and JSpecify, and adds nullability annotations to the package.

java/src/org/openqa/selenium/grid/distributor/selector · high confidence

The \org.openqa.selenium.remote.http\ package introduces a new HTTP client abstraction built around a \ClientConfig\ object that manages connection, read, and WebSocket timeouts (configurable via system properties), proxy settings, SSL context, and a filter chain. This model includes a default \AddSeleniumUserAgent\ filter to inject a versioned User-Agent header, a \RetryRequest\ filter for transient errors, and a \Filter\ interface for request/response interception. The package also provides new message types (\BinaryMessage\, \CloseMessage\), content suppliers (\BytesContentSupplier\, \FileContentSupplier\), and an \HttpClient\ interface with a \Factory\ pattern for pluggable implementations (defaulting to JDK 11 HTTP client).

java/src/org/openqa/selenium/remote/http · high confidence

The remote driver package has been restructured to support a new, extensible driver augmentation system. A new \Augmenter\ class and \AugmenterProvider\ interface allow capabilities to dynamically add interfaces (such as \HasAuthentication\ and \HasLogEvents\) to WebDriver instances at runtime, with specific implementations provided for Chromium-based browsers via DevTools. The package also introduces a new \AbstractDriverOptions\ base class for standardized capability handling, a \Browser\ interface for unified browser identification, and a \Dialect\ enum to manage W3C command and response codecs. Additionally, an \AddWebDriverSpecHeaders\ filter ensures HTTP requests include standard headers like \Content-Type\ and \Cache-Control\.

java/src/org/openqa/selenium/remote · high confidence

Selenium introduces a new Maven artifact, selenium-os, which provides utilities for interacting with the operating system. This module includes an ExecutableFinder to locate executables across the system PATH and an ExternalProcess builder to launch and manage external commands with configurable output buffering and environment variables. The package is annotated with jspecify null-safety markers and depends on the core selenium library.

java/src/org/openqa/selenium/os · high confidence

The \org.openqa.selenium.grid.sessionmap\ package now provides a set of HTTP handlers (\AddToSessionMap\, \GetFromSessionMap\, \GetSessionUri\, \RemoveFromSession\) and a \NullSessionMap\ implementation to manage WebDriver sessions within the Grid. These components expose REST endpoints for adding, retrieving, and removing sessions, supporting distributed session tracking and routing.

java/src/org/openqa/selenium/grid/sessionmap · high confidence

A new \sessions\ CLI command has been added to Selenium Grid, allowing users to run a dedicated HTTP server that manages session state. This server exposes \/status\ and \/readyz\ endpoints for health checks and integrates with the existing Grid roles (Event Bus, HTTPD, Session Map). The implementation includes a default configuration for TCP event publishing/subscribing and deprecates the \max-threads\ flag in favor of the \newsession-threadpool-size\ flag in the Distributor.

java/src/org/openqa/selenium/grid/sessionmap/httpd · high confidence

This change introduces the Redis-backed session map implementation for the Selenium Grid, adding the \RedisBackedSessionMap\ class which persists session data to Redis and listens for node removal and restart events to clean up stale sessions. It also includes the Bazel build configuration (\BUILD.bazel\) to package this module as \selenium-session-map-redis\ with dependencies on Lettuce and JSpecify, and adds nullability annotations to the package.

java/src/org/openqa/selenium/grid/sessionmap/redis · high confidence

The Session Queue component now supports a Redis-backed implementation (RedisBackedNewSessionQueue) for horizontal scalability, allowing multiple SessionQueue replicas to share a single logical queue via a configurable backend URL. This change introduces new command-line flags and configuration options under the \[sessionqueue\] section to tune queue behavior, including session-request-timeout, session-request-timeout-period, session-retry-interval, and sessionqueue-batch-size, with sensible defaults applied when values are omitted or invalid.

java/src/org/openqa/selenium/grid/sessionqueue/config · high confidence

The Safari driver now exposes two new capabilities via the Augmenter pattern: \HasPermissions\ and \HasDebugger\. Users can now manage browser permissions (currently limited to \getUserMedia\) using \setPermissions\ and \getPermissions\ on the driver instance, and can attach to Safari's Web Inspector using \attachDebugger\. These features are marked as \@Beta\ and are implemented through new \AddHasPermissions\ and \AddHasDebugger\ classes that register additional HTTP commands for the Safari-specific endpoints.

java/src/org/openqa/selenium/safari · high confidence

The \java/src/org/openqa/selenium\ package now contains the foundational API definitions for the Java bindings, including core interfaces like \Capabilities\, \Alert\, \HasAuthentication\, and \HasDownloads\, as well as model classes such as \Cookie\, \Architecture\, and \By\ locators. This change establishes the public contract for browser capabilities, element location, and new features like file downloads and authentication, serving as the \selenium-api\ artifact that other modules depend on.

java/src/org/openqa/selenium · high confidence

The Java bindings now include dedicated documentation and build configuration files to streamline development. A new AGENTS.md provides AI coding assistants with specific guidance on code location, common Bazel commands, and Java coding conventions such as interface design, logging, and deprecation. A comprehensive TESTING.md guide explains how to write and run tests using JUnit 5 and AssertJ, including details on test annotations and Bazel test filters. The java.iml files have been updated to reflect the Java 11 requirement and correct source folder structures, while BUILD.bazel and defs.bzl establish the standard Bazel build rules and dependencies for the Java module.

java · high confidence

The \common\ module now provides the foundational Bazel build rules and data definitions required to download, pin, and select specific versions of Chrome, Edge, and Firefox (including beta/dev editions) and their corresponding drivers (chromedriver, geckodriver, msedgedriver) across Linux, macOS, and Windows. This change introduces \repositories.bzl\ to fetch browser binaries and drivers via \http\_archive\ and custom archive rules, \browsers.bzl\ to expose these assets as selectable data dependencies for tests, and \BUILD.bazel\ to define build flags (such as \pin\_browsers\ and \headless\) that control whether tests use these pinned local binaries or fall back to system-installed versions. It also includes \selenium\_manager.bzl\ to bundle Selenium Manager binaries and \webref\_cddl.bzl\ to pin the CDDL grammars and WebDriver BiDi spec used for schema generation.

common · high confidence

The grid distributor logic has been restructured to improve maintainability and support high-availability configurations. The \Distributor\ class is now an abstract base that delegates specific HTTP endpoints (such as adding nodes, creating sessions, draining/removing nodes, and checking status) to dedicated handler classes like \AddNode\, \CreateSession\, \DrainNode\, and \RemoveNode\. Additionally, node state management has been extracted into an abstract \GridModel\ and \NodeRegistry\ interface, allowing implementations to store node data either locally or in an external datastore. This change also introduces null-safety annotations via \jspecify\ and replaces Guava collections with standard Java collections in the distributor package.

java/src/org/openqa/selenium/grid/distributor · high confidence

The \javascript/webdriver\ directory now includes a \BUILD.bazel\ file that defines the build targets for the WebDriver JavaScript bindings. This adds \closure\_js\_library\ targets for core modules (such as capabilities, commands, logging, and session handling) and a \closure\_test\_suite\ to run the associated tests, enabling the library to be built and tested using the Bazel build system.

javascript/webdriver · high confidence

This change introduces a new internal architecture for managing browser driver processes in the Java bindings. It adds \DriverService\ to handle the lifecycle (start, stop, health checks) of the native driver executables, \DriverFinder\ to locate driver binaries using Selenium Manager or environment variables, and \DriverCommandExecutor\ to route WebDriver commands to these services. This replaces the previous ad-hoc driver management logic with a consistent, reusable service layer that handles process timeouts, graceful shutdowns, and error reporting for all browser drivers.

java/src/org/openqa/selenium/remote/service · high confidence

The monolithic Rakefile has been refactored into dedicated task files for each language binding (appium, bazel, common, dotnet, java, node, python, ruby, rust), moving shared utilities into common.rb and language-specific logic into their respective .rake files. This change introduces a new Bazel-based test-indexing system (bazel.rake) that builds a file-to-test-target mapping to enable precise, fast detection of affected tests for CI, replacing the previous directory-based fallback. Each language binding now has its own structured tasks for building, packaging, releasing, verifying, formatting, and linting, improving maintainability and build performance.

_rake\tasks · high confidence

A new JsonExtensions class has been added to the BiDi JSON handling layer, providing two utility methods for users interacting with the WebDriver BiDi protocol. The GetDiscriminator method allows the system to robustly extract discriminator values from JSON objects during deserialization, improving how polymorphic types are identified. The GetTypeInfo method provides a safer way to retrieve JsonTypeInfo from JsonSerializerOptions, ensuring that type information is available within the serializer context before use.

dotnet/src/webdriver/BiDi/Json · high confidence

The .NET support library now uses implicit global usings to automatically include common namespaces (System, System.Collections.Generic, System.Linq, System.Threading, and System.Threading.Tasks) across all files. This reduces boilerplate code by eliminating the need for explicit using directives in individual source files, simplifying the codebase while maintaining the same functionality.

dotnet/src/support/Properties · high confidence

The .NET Chrome bindings have been restructured to align with the W3C WebDriver specification and modern driver management practices. ChromeDriver now defaults to W3C protocol compliance, and driver service creation utilizes Selenium Manager to automatically locate the driver executable, removing the need for manual path configuration in most cases. The codebase has been updated to use the 'goog:chromeOptions' capability name, supports casting to devices, and includes type-safe properties for recent Chrome capabilities. Additionally, the driver service now respects the SE\_CHROMEDRIVER environment variable for locating the executable.

dotnet/src/webdriver/Chrome · high confidence

The distributor's readiness check endpoint (/readyz) now returns an HTTP 503 (Unavailable) status code when the distributor is not ready, instead of a different status. This change improves compatibility with health-check systems that rely on standard HTTP status codes to determine service availability. The endpoint still returns a JSON body indicating the readiness state and a message.

java/src/org/openqa/selenium/grid/distributor/httpd · high confidence

The .NET Firefox driver bindings have been refactored to modernize how Firefox is configured and launched. FirefoxOptions now defaults to WebDriver BiDi (setting the 'remote.active-protocols' preference to 1) instead of the legacy implementation, and exposes new properties for Android automation (FirefoxAndroidOptions), environment variables, and logging levels. The FirefoxDriverService has been updated to support geckodriver command-line arguments such as --websocket-port, --marionette-port, and --marionette-host, and enforces a hard termination (kill) of the driver process on shutdown due to the lack of a clean shutdown API. Additionally, a new FirefoxCommandContext enum and associated driver commands allow tests to switch between 'content' and 'chrome' contexts, and the FirefoxProfile class now uses System.IO.Compression for profile serialization.

dotnet/src/webdriver/Firefox · high confidence

The Grid Router now manages HTTP connections to Nodes more efficiently by pooling and caching HttpClient instances based on the Node URI and the session's effective read timeout, which reduces connection overhead and prevents premature timeouts for long-running page loads. Additionally, WebSocket proxying has been optimized by switching to a direct Netty frame-forwarding path after the handshake, eliminating intermediate object allocations and executor submissions to lower latency. The /status endpoint has also been updated to include the node's session timeout in its response and to report readiness only when Nodes are available and have capacity.

java/src/org/openqa/selenium/grid/router · high confidence

The grid configuration subsystem has been restructured to support a more flexible and robust configuration model. The \Config\ interface now includes a \getArray\ method for parsing list-of-table options and a \getClass\ method for dynamic class instantiation via reflection. New implementation classes have been introduced: \AnnotatedConfig\ allows configuration from Java objects annotated with \@ConfigValue\; \CompoundConfig\ merges multiple configuration sources by priority; \ConcatenatingConfig\ maps flat key-value pairs to the section/option structure; \EnvConfig\ exposes environment variables as config settings; and \MemoizedConfig\ caches lookups for performance. The \Configs\ utility now supports both \.toml\ and \.json\ file extensions. Additionally, the underlying TOML parsing library has been migrated to \tomlj/tomlj\, and the build dependencies have been updated to include \jcommander\, \guava\, \tomlj\, and \jspecify\.

java/src/org/openqa/selenium/grid/config · high confidence

The IE Driver now supports driving Edge in IE Mode, including logic to locate Edge windows and handle new window creation within that context. The codebase has been refactored to move command handler implementations from headers to source files, introduced an asynchronous script executor for better JavaScript execution, and added a dedicated Alert class to handle browser dialogs. Additionally, cookie handling has been rewritten to be more robust and spec-compliant, and the driver now includes capabilities for setting whitelisted IP addresses and strict file interactability.

cpp/iedriver · high confidence

The IE driver now uses dedicated JavaScript atoms (findElement, findElements, getElementRect, etc.) to handle element interactions, addressing specific browser quirks such as invalid class name validation in IE8 and below and ensuring accurate element positioning data. These changes improve reliability for element finding and rect retrieval in Internet Explorer.

javascript/ie-driver · high confidence

The IE driver's command handler implementation has been rewritten to align with the W3C WebDriver specification. This update introduces new handlers for W3C-standard actions (ActionsCommandHandler), window management (CreateNewWindowCommandHandler), and alert handling (AcceptAlertCommandHandler, DismissAlertCommandHandler). It also refactors core interactions, including element clicking (ClickElementCommandHandler) to support native events and obscured element detection, cookie management (AddCookieCommandHandler, DeleteCookieCommandHandler) with stricter validation, and element clearing (ClearElementCommandHandler) with improved state checks. These changes ensure the driver behaves more predictably and consistently with modern web standards.

cpp/iedriver/CommandHandlers · high confidence

The injected WebDriver atoms in \javascript/webdriver/atoms/inject\ have been updated to accept an optional serialized window context (\opt\_window\). This allows actions like clicking, typing, finding elements, and executing scripts to target specific frames or windows rather than being limited to the current execution context. The \execute\_script.js\ module now decodes this context from a cache, and locators and DOM queries resolve elements within the specified window, enabling reliable interaction with off-screen or cross-origin frames.

javascript/webdriver/atoms/inject · high confidence

The BrowsingContext module now exposes context-aware event sources (such as NavigationStarted, DownloadWillBegin, and FileDialogOpened) that automatically filter events to the specific browsing context, and command options (like SetViewport and GetTree) that automatically inject the context, simplifying the API for users working with individual browsing contexts.

dotnet/src/webdriver/BiDi/BrowsingContext · high confidence

This change adds a new \javascript/private\ directory containing Bazel build rules and Python scripts that streamline the build and test process for JavaScript components. It introduces \closure\_js\_deps\ and \closure\_make\_deps\ to generate Closure \deps.js\ files by scanning sources, replacing previous Node.js-based wrappers to avoid Windows symlink issues. It also adds \closure\_fragment\ and \header.bzl\ to compile JavaScript atoms into C++ and Java constants, \jsdoc.bzl\ to generate API documentation using Bazel-managed Node.js, and \mocha\_test.bzl\ and \test\_suite.bzl\ to standardize test execution with appropriate timeouts and XML output reporting.

javascript/private · high confidence

The \org.openqa.selenium.support.pagefactory.internal\ package now includes \LocatingElementHandler\ and \LocatingElementListHandler\, which implement \InvocationHandler\ to proxy \WebElement\ and \List\<WebElement\>\ lookups via \ElementLocator\. These handlers ensure that \NoSuchElementException\ is propagated for all method calls except \toString\ (which returns a descriptive string) and \getWrappedElement\ (which returns the underlying element), while also unwrapping \InvocationTargetException\ causes. Additionally, \package-info.java\ applies \@NullMarked\ from jspecify to enforce null-safety conventions within this internal package.

java/src/org/openqa/selenium/support/pagefactory/internal · high confidence

The .NET bindings in the Remote WebDriver layer have been updated to support the W3C WebDriver specification. This change introduces a new \W3CWireProtocolCommandInfoRepository\ that maps commands to W3C-standard HTTP endpoints (e.g., \/session\, \/session/{sessionId}/url\) and replaces the legacy JSON Wire Protocol dialect. The \HttpCommandExecutor\ now defaults to this W3C repository, and new classes such as \DesiredCapabilities\, \ReadOnlyDesiredCapabilities\, and \RemoteSessionSettings\ provide structured capability handling, including support for \mustMatch\ and \firstMatch\ capability groups. Additionally, the \RemoteWebDriver\ class now exposes DevTools session capabilities (\se:cdp\) and integrates with the \IHasDownloads\ interface, enabling users to interact with modern browser drivers that require W3C-compliant session negotiation.

dotnet/src/webdriver/Remote · high confidence

The \org.openqa.selenium.remote.codec\ package now includes \AbstractHttpCommandCodec\ and \AbstractHttpResponseCodec\, which implement the W3C WebDriver wire protocol for encoding and decoding HTTP requests and responses. This change establishes the foundational codec layer for standard WebDriver commands (such as navigation, element interaction, and session management) and responses, replacing or supplementing previous implementations to ensure strict adherence to the W3C specification.

java/src/org/openqa/selenium/remote/codec · high confidence

The \org.openqa.selenium.interactions\ package has been completely rewritten to implement the W3C WebDriver Actions protocol. The legacy \Keyboard\ and \Mouse\ classes are replaced by a builder-based \Actions\ API that constructs \Sequence\ objects for \KeyInput\, \PointerInput\, and \WheelInput\ sources. This change introduces support for complex, multi-device gestures (such as simultaneous key presses and pointer movements) and allows users to specify custom action durations and scroll origins, aligning Java's interaction capabilities with the modern WebDriver standard.

java/src/org/openqa/selenium/interactions · high confidence

The Java DevTools implementation has been completely rewritten to remove the Guava dependency, replacing it with native Java 11+ APIs and the JSpecify nullability annotations. The build system has migrated from Maven to Bazel, introducing a new \CdpClientGenerator\ tool that generates CDP bindings from protocol definitions. This change also introduces a new \CdpVersionFinder\ for matching browser versions to CDP implementations and a \DevToolsProvider\ for lazy augmentation of WebDriver instances.

java/src/org/openqa/selenium/devtools · high confidence

The Java Edge driver module has been reorganized into a new package structure (\org.openqa.selenium.edge\) with a complete rewrite of core components. \EdgeDriver\ now initializes specific \AddHasCasting\ and \AddHasCdp\ augmenters, enabling Microsoft-specific casting commands (get/set sinks, start/stop mirroring) and Chrome DevTools Protocol (CDP) execution. \EdgeDriverService\ introduces granular configuration options via a builder, including support for WebView2 automation, readable timestamps, log appending, and build-check disabling. \EdgeOptions\ now exposes a \useWebView()\ method to target WebView2 apps and adds support for \ms:loggingPrefs\. The driver info provider has been updated to recognize WebView2 and declare support for both BiDi and CDP.

java/src/org/openqa/selenium/edge · high confidence

The Java Internet Explorer driver implementation has been updated to use Selenium Manager for driver discovery and execution, replacing the previous native event and legacy capability mechanisms. All valid IE-specific options are now consolidated under the \se:ieOptions\ capability namespace to align with W3C standards, and non-W3C compliant options have been removed. The driver service now supports configurable logging levels, host binding, and extraction paths, while the driver finder is implemented independently of service classes to improve modularity.

java/src/org/openqa/selenium/ie · high confidence

The \org.openqa.selenium.json\ package has been refactored to remove the Guava dependency in favor of standard Java collections and to add JSpecify nullability annotations for improved static analysis. This change introduces a new \BUILD.bazel\ build file for the module, updates the \JsonOutput\ class to enforce a maximum serialization depth of 100, and restructures the internal type coercion logic (including \ConstructorCoercer\ and \InstanceCoercer\) to use Java's built-in reflection and collection APIs.

java/src/org/openqa/selenium/json · high confidence

The Java build system has been restructured to use JUnit 5 for running tests, replacing the previous runner with \com.github.bazel\_contrib.contrib\_rules\_jvm.junit5.JUnit5Runner\. This change is supported by a new set of Bazel macros in \java/private\ (including \junit5\_test\, \java\_export\, and \java\_test\_suite\) that leverage \rules\_jvm\_external\ for Maven artifact generation and publishing. Additionally, NullAway static analysis is now integrated into the \java\_library\ rule to enforce null-safety checks during compilation.

java/private · high confidence

The Java logging package has been rebuilt from the ground up, introducing new core types such as the \EventType\ functional interface for handling log events, the \HasLogEvents\ interface for objects that emit logs, and the \Logs\ interface for fetching log entries. Existing data structures like \LogEntry\, \LogEntries\, \LoggingPreferences\, and \LogType\ have been re-implemented to support this new architecture, including the addition of \toJson()\ methods for serialization and the use of \@NullMarked\ annotations for improved null-safety.

java/src/org/openqa/selenium/logging · high confidence

The .NET test infrastructure in dotnet/private has been updated to use the Microsoft Testing Platform (MTP) instead of the legacy NUnit runner. This change introduces a new mtp\_shim.cs entry point and a dotnet\_nunit\_test\_suite rule that leverages the NUnit3.TestAdapter (v6.2.0) and Microsoft Testing Platform extensions to execute tests, ensuring compatibility with modern .NET testing standards while maintaining support for existing NUnit test suites.

dotnet/private · high confidence

The build system for the Linux-specific native events component has been migrated to Bazel, introducing a new BUILD.bazel file to compile the noblur library. This change also includes the addition of print\_events.h, a utility for debugging X11 events, and updates to x\_ignore\_nofocus.c to cache XQueryTree results, preventing browser crashes when querying window information during window closure.

cpp/linux-specific · high confidence

The Python bindings now rely on the Rust-based Selenium Manager to locate and manage browser drivers, replacing the previous Python-based driver management logic. This change improves driver installation reliability and performance by leveraging the prebuilt Selenium Manager binary, which is now bundled with the Python package. Users will experience faster and more robust driver setup without needing to manually download or configure driver executables.

(repo-wide) · high confidence

The browser automation atoms in the \javascript/atoms\ directory have been migrated from the Google Closure Compiler to TypeScript, with the build system switching from legacy scripts to Bazel. This change introduces TypeScript source files (e.g., \get-attribute.ts\, \find-elements.ts\, \is-displayed.ts\) that are compiled to JavaScript via the TypeScript compiler (\tsc\) and wrapped for global execution. The \BUILD.bazel\ file now defines the build rules for these new TypeScript atoms, while the \README.md\ provides updated instructions for running tests using Bazel targets like \closure-test-chrome\ and \closure-test-edge\.

javascript/atoms · high confidence

The C++ interactions library now supports persistent mouse hovering on Windows by running a background thread that continuously sends WM\_MOUSEMOVE messages, ensuring browsers like Internet Explorer correctly track the cursor during hover states. Additionally, the library now maintains the state of modifier keys (Shift, Control, Alt) across multiple interaction calls, allowing complex sequences like Control-click or Shift-typed input to function correctly without releasing modifiers prematurely.

cpp/webdriver-interactions · high confidence

The .NET Support library now uses new Bazel build rules to compile and package the library. The build targets .NET Standard 2.0 exclusively, enables nullable reference types, and uses C\# language version 14.0. The NuGet package includes source link support, symbol files (snupkg), and embeds the project logo. Dependencies have been updated to use Microsoft.Bcl.AsyncInterfaces and System.Threading.Tasks.Extensions, and the package correctly includes license and notice files.

dotnet/src/support · high confidence

The Grid server now uses a new Netty-based implementation (NettyServer) to handle HTTP and WebSocket traffic, replacing the previous server stack. This change introduces a new pipeline architecture with dedicated handlers for request/response conversion (RequestConverter, ResponseConverter) and WebSocket message handling (MessageInboundConverter, MessageOutboundConverter). It also adds support for transparent TCP tunnels for WebSocket connections, allowing the Router to bypass the WebSocket data path for improved performance, and includes a PostUpgradeHook interface for customizing the Netty pipeline after the WebSocket handshake.

java/src/org/openqa/selenium/netty · high confidence

The Grid now includes a dedicated HTTP server for the new session queue (accessible via the 'sessionqueue' CLI command), which exposes /status and /readyz endpoints to report queue readiness for load balancers and Kubernetes services. The server also logs a deprecation warning when the legacy --max-threads flag is used, directing users to the newsession-threadpool-size flag in the Distributor instead.

java/src/org/openqa/selenium/grid/sessionqueue/httpd · high confidence

This location introduces TypeScript source files and build helpers for the \find-elements\, \getAttribute\, and \isDisplayed\ atoms, replacing the previous Closure-based implementations. The new TypeScript atoms provide the same element-locating and DOM-inspection capabilities for WebDriver users, while the accompanying JavaScript build scripts (\wrap-as-global.js\, etc.) ensure the compiled outputs are correctly exposed as browser globals (e.g., \window.bot.dom.typescript.isShown\) for test pages to consume.

javascript/atoms/typescript · high confidence

The Grid distributor now exposes several new configuration options in the \[distributor\] section, allowing users to tune the new session thread pool size (--newsession-threadpool-size), the interval for purging dead nodes (--purge-nodes-interval), and the backend datastore URL for external implementations like Redis (--distributor-backend-url). Additionally, the distributor's URI schema now automatically defaults to HTTPS when the server is configured as secure or self-signed, and the package is marked as null-safe via jspecify.

java/src/org/openqa/selenium/grid/distributor/config · high confidence

This change introduces several new internal helper classes and refines debug logging behavior. The \Debug\ class now centralizes debug mode detection via \selenium.debug\ and \SE\_DEBUG\ environment variables, providing a warning when \SE\_DEBUG\ overrides user settings and configuring the logger to output to stderr at FINE level when active. New utility classes include \Either\ (a functional left/right container with \stream()\ and \iterator()\ methods that return empty results for left values), \Maps\ and \Sets\ (providing immutable, ordered, or sorted collection factories), and \Multimap\ (a map holding unique values per key). The \Require\ class has been updated with nullability annotations and enhanced validation methods for durations and numbers, while \package-info.java\ applies \@NullMarked\ to the entire package.

java/src/org/openqa/selenium/internal · high confidence

The Grid now uses a dedicated \NewSessionQueue\ abstraction to manage incoming session requests, introducing a new set of internal HTTP endpoints (e.g., \/se/grid/newsessionqueue/session\) for adding, retrieving, retrying, and clearing queued requests. This change provides better visibility into pending session requests and allows the Grid to handle session creation failures or timeouts more gracefully by keeping requests in the queue until they are successfully fulfilled or explicitly removed.

java/src/org/openqa/selenium/grid/sessionqueue · high confidence

The Grid now introduces a dedicated logging subsystem that allows users to choose between plain text and structured (JSON) log output via the \--plain-logs\ and \--structured-logs\ flags. This change adds new command-line options for configuring the log file path, encoding, log level, and timestamp format, while ensuring that explicit Java logging properties take precedence over Selenium's defaults. The implementation includes custom formatters for both output styles and a flushing handler to ensure logs are written immediately, improving the reliability and parseability of Grid logs for operators.

java/src/org/openqa/selenium/grid/log · high confidence

The Page Factory support library has been refactored to improve type safety and reduce runtime casting. The core \AbstractFindByBuilder\ class is now generic, allowing subclasses like \FindBy.FindByBuilder\, \FindBys.FindByBuilder\, and \FindAll.FindByBuilder\ to handle their specific annotation types without excessive casting. Additionally, the \Color\ class and By locator builders now include JSpecify annotations (such as \@NullMarked\ and \@Nullable\) to provide better static analysis support for null-safety.

java/src/org/openqa/selenium/support · high confidence

The \org.openqa.selenium.support.pagefactory\ package has been reorganized to improve code stability and type safety. The \AbstractAnnotations\ class was introduced to abstract annotation processing, and \Annotations\ now validates that \@FindBy\, \@FindBys\, and \@FindAll\ are not used together on the same field. \AjaxElementLocator\ now uses \java.time.Clock\ for time-based operations and provides clearer error messages when element lookup times out. New locator mechanisms, \ByAll\ and \ByChained\, allow users to locate elements using multiple locators (OR and AND logic, respectively). The entire package is now annotated with \@NullMarked\ from the JSpecify library to enforce null-safety.

java/src/org/openqa/selenium/support/pagefactory · high confidence

The .NET bindings now include a set of internal polyfill classes in the Properties folder to support modern C\# language features and runtime attributes on targets older than .NET 8. These additions include \ArgumentNullExceptionExtensions\ to provide \ThrowIfNull\ behavior, \CallerArgumentExpressionAttribute\ and \InterpolatedStringHandlerAttribute\/\InterpolatedStringHandlerArgumentAttribute\ to enable advanced compiler diagnostics and interpolated string handlers, and various nullability and trimming attributes (\NullableAttributes\, \TrimmingAttributes\, \StringSyntaxAttribute\) to ensure correct static analysis and AOT compatibility. A \GlobalUsings.cs\ file has also been added to automatically import common namespaces, and \AssemblyInfo.cs\ explicitly sets the assembly as CLS-compliant.

dotnet/src/webdriver/Properties · high confidence

The Python bindings have updated their minimum supported Python version to 3.10, removing support for Python 3.9. This change ensures compatibility with modern Python features and security updates, meaning users must upgrade their Python environment to at least version 3.10 to use these bindings.

py · high confidence

The IE driver's user input simulation logic has been restructured into a set of distinct simulator classes within the ActionSimulators directory. This change introduces \JavaScriptActionSimulator\ for synthetic DOM events, \SendInputActionSimulator\ for low-level Windows API input (including support for swapped mouse buttons and normalized coordinates), \SendMessageActionSimulator\ for posting window messages, and \PersistentEventSimulator\ for continuous mouse movement. A common \ActionSimulator\ base class and \InputState\ tracking are now used to manage shared state like button presses and modifier keys across these different input methods.

cpp/iedriver/ActionSimulators · high confidence

The OpenTelemetry tracing module has been rewritten to replace deprecated OpenTelemetry SDK creation methods and the old SemanticAttributes class with current APIs (such as AttributeMap and AutoConfiguredOpenTelemetrySdk). This change ensures compatibility with OpenTelemetry 1.6.0 and later, removes legacy dependencies like Guava from the remote package, and updates the build configuration to explicitly limit OpenTelemetry dependency usage, resulting in a cleaner and more maintainable tracing integration.

java/src/org/openqa/selenium/remote/tracing/opentelemetry · high confidence

The element locator atoms have been rewritten to leverage native browser capabilities (such as querySelector/querySelectorAll) where available, replacing older Closure Library helpers. This change introduces stricter validation and proper error codes for invalid selectors, including compound class names and empty tag names. It also fixes specific edge cases: class names containing dots are now correctly escaped for CSS selectors, ID locators escape special characters to ensure querySelectorAll works with IDs containing spaces or symbols, and link text matching now correctly handles non-breaking spaces. Additionally, the relative locator strategy has been introduced to find elements based on their spatial relationship to other elements.

javascript/atoms/locators · high confidence

The \org.openqa.selenium.net\ package has been restructured to improve reliability and performance. Port selection in \PortProber\ now avoids browser-restricted ports (such as IRC and X11) and dynamically detects ephemeral port ranges on Linux and older Windows versions to prevent race conditions. Host resolution in \HostIdentifier\ and \NetworkUtils\ has been optimized to avoid slow reverse DNS lookups, particularly on macOS, by using environment variables and direct interface checks. Additionally, \UrlChecker\ now properly consumes HTTP input streams to prevent socket leaks, and the entire package is annotated with JSpecify nullability markers.

java/src/org/openqa/selenium/net · high confidence

The JavaScript atoms used by WebDriver bindings have been updated to improve accuracy and reliability. The \getAttribute\ atom now correctly handles boolean attributes by returning \null\ when they are not set (instead of \false\ or \true\), and properly resolves property aliases like \class\ to \className\. It also includes specific logic for \spellcheck\ and ensures that \href\ and \src\ attributes on links and images return the resolved property value. Additionally, the input atoms (\sendKeys\, \click\, \mouseMove\) now support persistent modifier key states across calls and correctly default mouse movements to the center of an element when no offset is specified, providing more consistent behavior for advanced user interactions.

javascript/webdriver/atoms · high confidence

The internal code generator for the .NET Chrome DevTools Protocol bindings has been completely rewritten. It now targets .NET 8 and uses the built-in System.Text.Json library instead of the previous Newtonsoft.Json dependency, resulting in a lighter build with fewer external packages. The new generator uses dependency injection and a template-based approach (Handlebars) to produce C\# code, which improves maintainability and aligns the build process with modern .NET standards.

_third\party/dotnet/devtools · high confidence

The minimum supported Ruby version for the Ruby bindings has been raised to 3.1. This change drops support for older Ruby versions (such as 2.x) and ensures compatibility with the current Ruby ecosystem. Users must upgrade their Ruby environment to version 3.1 or higher to use this release of the Selenium Ruby bindings.

rb · high confidence

The \org.openqa.selenium.support.ui\ package has been reorganized into a modular Bazel build structure (\BUILD.bazel\) defining separate libraries for clock, components, elements, and wait logic. The codebase now incorporates JSpecify annotations (e.g., \@Nullable\, \@NonNull\, \@NullMarked\) to enforce null-safety across classes like \ExpectedCondition\, \FluentWait\, and \Wait\. Additionally, \ExpectedCondition\ now implements both Guava's \Function\ and Java's \java.util.function.Function\ to maintain backward compatibility while adopting standard Java interfaces.

java/src/org/openqa/selenium/support/ui · high confidence

The BiDi schema in common/bidi has been updated to include Mozilla-specific extensions, adding new commands for debugging (such as setting breakpoints, stepping, and script source retrieval), profiling (start, stop, and status checks), and managing Firefox web extensions (listing installed extensions). The schema also incorporates custom Firefox options for session capabilities and browsing context scopes, alongside standard W3C BiDi commands, ensuring the generated code reflects these vendor-specific capabilities.

common/bidi · high confidence

The mirror information file for Selenium has been updated to include release assets for version 4.49.0, alongside existing entries for versions 4.43.0 through 4.48.0 and the nightly build. This ensures that users relying on this mirror can access the latest stable Selenium releases and snapshot builds.

common/mirror · high confidence

The C++ build configuration has been updated to support Visual Studio 2017. The solution file now targets Visual Studio 15 (version 15.0.26430.16) and includes projects for the IE Driver, WebDriver server, civetweb, and json-cpp, ensuring compatibility with the newer IDE environment.

cpp · high confidence

The IE Driver now uses updated JavaScript automation atoms (including the Sizzle selector engine) embedded in the C++ source files. This update ensures that element location, interaction, and other browser automation commands executed via JavaScript in Internet Explorer reflect the latest improvements and bug fixes from the upstream WebDriver atom library.

cpp/iedriver/Generated · high confidence

The Closure Library source code and its Apache 2.0 license are now vendored in third\_party/closure, with Bazel build rules exposing the full library and testing subsets. Several Bazel third-party rules are patched to improve build reliability: rules\_jvm\_external now supports excluding third-party prefixes from javadoc generation and conditionally publishing main artifacts; rules\_ruby patches ensure correct runfiles resolution and Windows CRLF line endings; rules\_rs patches add Windows toolchain support, shorten toolchain names, and fix debug prefix maps for non-MSVC targets; and aspect\_rules\_jest patches handle runfiles path resolution.

_third\party · high confidence

The \DefaultWait\<T\>\ class in the Support package now accepts a \CancellationToken\ in its \Until\ method, allowing users to cancel a waiting operation before the timeout expires. The \Until\ method is also marked \virtual\, enabling subclasses to override the polling behavior. To support these changes and improve testability, the implementation now uses a new \IClock\ abstraction (with a \SystemClock\ singleton) instead of direct \DateTime\ calls.

dotnet/src/webdriver/Support · high confidence

The JavaScript bindings now allow WebDriver commands to be executed from a browser page to a remote server using Cross-Origin Resource Sharing (CORS), removing the previous reliance on JSONP. This change introduces a new CorsClient that communicates with the server's /xdrpc endpoint, enabling the full client stack to run directly in the browser for supported environments (WebKit, Firefox, IE8+, and Opera 12+). Users can now test the client stack locally without starting a server by using the provided demo page, which utilizes a fake command executor with canned responses.

javascript/webdriver/http · high confidence

Added .NET remote WebDriver integration tests; Added BiDi permissions test and consolidated test project usings; Added BiDi test harness pages for logging, input actions, and script preloading; Added HTML5 storage, geolocation, and Shadow DOM test suites; Added QUnit-based tests for Chrome Driver JavaScript atoms; Added QUnit-based tests for injected WebDriver atoms; Added frames benchmark for Safari driver performance testing; Added overflow test pages for all axis combinations; Added sample HTML pages for nested directory testing; Added sample pages for scrolling test scenarios; Added static test pages for locator testing; Added test bootstrap script for WebDriver JavaScript tests; Added test fixture pages for proxy and WebDriver scenarios; Added test fixture pages for window switching tests; Added test fixtures for atoms testing; Added test fixtures for complex click scenarios; Added test fixtures for element coordinate edge cases; Added test for key event handling when target is removed from DOM; Added test infrastructure for .NET Support tests; Added test resources for frame deletion and issue 4876 scenarios; Added tests for BiDi Browser user context and download behavior; Added tests for BiDi Emulation module commands; Added tests for BiDi Network module capabilities; Added tests for BiDi Script and Log capabilities; Added tests for BiDi browsing context, storage, and speculation capabilities; Added tests for BiDi input actions and file handling; Added tests for BiDi session management and custom module event handling; Added tests for Chrome DevTools Protocol (CDP) domains; Added tests for EventFiringWebDriver and JavaScript extension methods; Added tests for WebDriver interactions and virtual authenticator; Added tests for internal logging infrastructure; Added unit tests for BiDi session and transport layer; Added unit tests for Firefox driver components; Added unit tests for HTTP client implementations; Added unit tests for UI support components; Added web-based test pages for screenshot validation; Expanded test coverage for Selenium WebDriver JavaScript library; In-process test web server for .NET WebDriver tests; Java test suite migration to JUnit 5 and AssertJ; Migrate JavaScript atoms tests to QUnit; New test infrastructure and sample web pages for Selenium.

The .NET bindings now use Paket for dependency management and have been updated to target .NET 8.0 alongside .NET Framework 4.6.2 and .NET Standard 2.0. The test projects have been migrated to the Microsoft Testing Platform and upgraded to NUnit 4.6.0, with the test target framework set to .NET 10.0.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 50.

• Code Health 39
• Architecture 93
• Maturity 50
• Readiness 67
• Security 70
• Domain Modelling 79
• Performance 60

• 300 commits — 260 feature/other, 40 fixes

• .github/workflows — 49 commits
• rb/spec — 29 commits
• (root) — 26 commits
• java/src — 24 commits
• dotnet/src — 20 commits
• rb/lib — 20 commits
• common/repositories.bzl — 19 commits
• javascript/selenium-webdriver — 19 commits
• py/test — 14 commits
• py/selenium — 10 commits
• docs/decisions — 7 commits
• common/selenium_manager.bzl — 6 commits
• java/test — 6 commits
• rust/src — 5 commits
• common/mirror — 4 commits
• py/BUILD.bazel — 4 commits
• py/docs — 4 commits
• rust/tests — 4 commits
• dotnet/test — 3 commits
• rake_tasks/java.rake — 3 commits

• fix: Fix badge for CI build on the default branch (#17901)
• fix: Revert "[py] temporarily disable nightly TestPyPI publishing (#17920)" (#17924)
• fix: [build] Fix GeckoDriver rejecting system-access via capabilities (#17811)
• fix: [build] Fix the two CDDL repin fallouts breaking every Python target (#18068)
• fix: [build] fix bug that prevented binding jobs from running on schedule and dispatch
• fix: [build] fix invalid escape sequence in the Java atom line format
• fix: [build] fix release order - nightly must be updated before mirror job runs
• fix: [build] fix the issues that caused the release workflow to fail during last release (#17921)
• fix: [dotnet] [bidi] Fix NamespaceUri json property name (#17958)
• fix: [dotnet] [bidi] Fix mismatch of proxy json property names (#17960)
• fix: [dotnet] [bidi] Fix realm type enum serialization (#17959)
• fix: [dotnet] [bidi] Fix various missing fields in DTO (#17961)
• fix: [dotnet] fix flaky cancellation test to accept OperationCanceledException subclasses
• fix: [dotnet] fix flaky test to search the document response body in VerifySearchInResponseBody instead of the last response
• fix: [grid] Fix 500 when downloading a file whose name contains spaces (#17968)
• fix: [java] Add regression test for relative locators on collapsed table borders (#17827)
• fix: [java] Fix By.className()/By.id() misescaping non-ASCII leading digits (#17815)
• fix: [java] Fix By.name() double String.format on names containing '%' (#17888)
• fix: [java] fix flaky test by waiting for the reveal mutation instead of asserting it arrives last
• fix: [java] fix two flaky BiDi tests that left timing-dependent state behind (#17918)
• …and 280 more

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

SeleniumHQ/selenium 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.