SeleniumHQ/selenium
54.2
Adequate · 13 November 2026
210.3k
lines of production code
Java
with C#, JavaScript, C++, Python, Ruby
6
measurements over time
What this system is
Features
Add BiDi Permissions module for managing browser permissions
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
Add BiDi log event support with entry types and filtering
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
Add JDBC and Redis session map implementations for Selenium Grid
Selenium Grid now supports storing session state in external backends via two new modules: a JDBC implementation (selenium-session-map-jdbc) and a Redis implementation (selenium-session-map-redis). The JDBC module introduces command-line flags (--jdbc-url, --jdbc-user, --jdbc-password) and configuration options under the sessions section to connect to a relational database, while the Redis module leverages the Lettuce client for Redis connectivity. Both modules are registered as session map roles, include nullability annotations via jspecify, and are built as public release artifacts with their own Maven coordinates.
java/src/org/openqa/selenium/grid/sessionmap/jdbc · high confidence
Add JDK 11 HTTP client implementation
Introduces a new HTTP client implementation in the \org.openqa.selenium.remote.http.jdk\ package that utilizes the Java 11 \java.net.http.HttpClient\. This change adds support for modern HTTP/2 connections and includes specific handling for request bodies (avoiding chunked encoding where unsupported), header filtering (ignoring restricted headers like \content-length\ and \host\), and authentication via a custom \PasswordAuthenticator\. It also provides a dedicated \ConnectionException\ for better error context and ensures locale-independent header processing.
java/src/org/openqa/selenium/remote/http/jdk · high confidence
Add Java virtual authenticator API interfaces
New interfaces and configuration classes have been added to the \org.openqa.selenium.virtualauthenticator\ package to support the W3C WebAuthn automation specification. \HasVirtualAuthenticator\ allows drivers to create and remove virtual authenticators, while \VirtualAuthenticator\ provides methods to manage credentials (add, remove, list) and simulate user verification states. \VirtualAuthenticatorOptions\ enables configuration of protocol (CTAP2/U2F), transport (BLE/USB/NFC/Internal), and flags for resident keys and user consent. The package is marked with \@NullMarked\ to enforce null-safety annotations.
java/src/org/openqa/selenium/virtualauthenticator · high confidence
Add Redis-backed Distributor for horizontal grid scalability
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
Add Virtual Authenticator support
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
Add WebExtension module for installing and uninstalling browser extensions
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
Add download page with sample files for testing special characters
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
Add signed and unsigned example WebExtensions for testing
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
Added C++ IME engine management library for Windows
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
Added FedCM demonstration assets and configuration
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
Added HTML5 feature demonstration scripts and offline support files
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
Added IniFileReader for parsing INI configuration files
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
Added Java bindings for Federated Credential Management (FedCM) API
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
Added Permissions module for WebDriver BiDi
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
Added RBS type signatures for DevTools, Server, WebDriver, and BiDi modules
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
Added iBus IME engine management support for Linux
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
Added local C++ toolchain configuration for remote builds
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
Added modern modal dialog sample and legacy modal chain
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
Added no-op tracing implementation for environments without OpenTelemetry
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
Added self-signed localhost certificate for test environments
A self-signed certificate and private key for localhost are now included in the common/certificates directory, allowing test web servers to serve pages over HTTPS. A build rule exposes these files to Python and Ruby test targets, and a script is provided to regenerate the certificate if needed.
common/certificates · high confidence
Browser module implementation for BiDi
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
Centralized Chrome DevTools Protocol definitions and generation tooling
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
Chrome package restructured with new driver and service classes
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
Firefox driver now supports extensions, full-page screenshots, and context switching via augmentation
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
Grid node refactored with new session abstraction and pluggable command interception
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
Grid server now supports pluggable extensions via --ext flag
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
IEDriverServer adds /version flag and IP whitelist capability
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
Initial .NET WebDriver bindings with Bazel build and W3C compliance
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
Initial implementation of the C++ WebDriver server core
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
Initial release of Selenium Manager Rust implementation
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
Initial support for Chrome DevTools Protocol (CDP) in .NET
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
Initial support for Microsoft Edge WebDriver bindings
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
Initial support for Safari WebDriver in .NET
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
Internal refactoring and new Android options support
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
Internet Explorer driver integration for .NET
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
Introduce BiDi (Bidirectional) WebDriver API
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
Introduce BiDi code generator and augmentation infrastructure
This change adds the build-time code generator (BiDiGenerator) and the AugmenterProvider (BiDiProvider) that automatically injects the HasBiDi interface into WebDriver instances when a webSocketUrl capability is present. The generator creates Java types from the bidi\_schema.json, and the provider establishes the BiDi connection lazily on first use. The BiDi interface methods are deprecated for direct driver access, signaling that users should rely on the augmented interface rather than internal connection details.
java/src/org/openqa/selenium/bidi · high confidence
Introduce GraphQL API for Selenium Grid status and session data
This change adds a new GraphQL endpoint to the Selenium Grid, exposing grid topology, node health, and active session details via a typed schema (GridQuery, Node, Session, Slot). Users can query grid-level metrics (total slots, session count, queue size), inspect individual nodes (availability, stereotypes, OS info, session timeout), and retrieve active sessions with their capabilities, start time, and duration. The implementation introduces dedicated data fetchers (GridData, SessionData), model classes (Grid, Node, Session, Slot, OsInfo), and custom scalar types (Uri, Url) for safe serialization, along with a SessionNotFoundException for missing sessions. It also updates the build configuration to include the graphql-java and Caffeine dependencies.
java/src/org/openqa/selenium/grid/graphql · high confidence
Introduce Java Selenium Manager wrapper and prebuilt binary distribution
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
Introduce LocalDistributor for in-process Grid node management
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
Introduce LocalNode for standalone grid node execution
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
Introduce OneShotNode for Kubernetes-based single-session execution
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
Introduce ZeroMQ-based event bus implementation
Added a new ZeroMQ-backed event bus implementation for the Selenium Grid, including the \BoundZmqEventBus\ and \UnboundZmqEventBus\ classes, a \Topic\ class for event filtering, and \ZmqUtils\ for configuring socket heartbeats. This new component, built on the Jeromq library, provides an alternative transport mechanism for inter-node communication within the Grid, featuring configurable heartbeat intervals to prevent stale connections and retry policies for robust socket initialization.
java/src/org/openqa/selenium/events/zeromq · high confidence
Introduce idealized CDP domain abstractions with null-safety and session-scoped script pinning
The \org.openqa.selenium.devtools.idealized\ package now provides a cleaner, type-safe API for interacting with Chrome DevTools Protocol domains. New abstract classes for \Events\, \Javascript\, \Network\, and \Log\ expose high-level methods for managing console and JavaScript exception listeners, intercepting network traffic, and handling browser logs, while the \Domains\ interface aggregates these capabilities. The \Javascript\ domain introduces \pin()\ to persist scripts across page navigations, tracking them per CDP session to ensure they are correctly cleaned up when the session ends. Additionally, null-safety annotations (\@NullMarked\) have been added across the package to improve static analysis and code reliability.
java/src/org/openqa/selenium/devtools/idealized · high confidence
Introduce local in-memory session queue with batch processing and timeout handling
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
Introduce remote implementations for Grid Distributor and Session Map
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
Introduce remote session queue implementation
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
Introduction of RemoteNode for distributed grid communication
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
Introduction of Selenium Manager for automatic driver management
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
Java BiDi emulation API now supports scripting, network, and screen overrides
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
Java print options now support page margins, custom page sizes, and list-based page ranges
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
New .NET development and build guidelines
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
New Bazel build rules for packaging and driver management
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
New BiDi Emulation module with override commands
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
New BiDi Input module with file dialog events and pointer actions
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
New BiDi JSON converters for serialization
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
New BiDi Network module with interception and data collection capabilities
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
New BiDi Script module with comprehensive JavaScript execution and object handling
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
New BiDi Session module with capabilities, proxy, and subscription support
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
New BiDi browser capabilities: client window info and download behavior
Users can now configure download behavior (allowing or denying downloads with a specific destination folder) and retrieve detailed client window information (state, dimensions, position, and active status) via the new \DownloadBehavior\ and \ClientWindowInfo\ classes in the \org.openqa.selenium.bidi.browser\ package. These classes, marked as Beta, provide the data structures and builders needed to interact with the WebDriver BiDi protocol's browser management features.
java/src/org/openqa/selenium/bidi/browser · high confidence
New BiDi network data types and intercept phases
The \org.openqa.selenium.bidi.network\ package now includes the data model classes required for WebDriver BiDi network interception and monitoring. This adds types for request and response data (\RequestData\, \ResponseData\), timing information (\FetchTimingInfo\), authentication challenges (\AuthChallenge\), and initiator details (\Initiator\). It also introduces the \InterceptPhase\ enum to define interception points (before request sent, response started, auth required) and event classes like \BeforeRequestSent\ and \FetchError\. All classes are marked as \@Beta\ and include nullability annotations via \@NullMarked\.
java/src/org/openqa/selenium/bidi/network · high confidence
New CLI command infrastructure for Selenium Grid
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
New Chromium driver package with device casting, CDP, and network simulation capabilities
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
New Chromium-specific driver options and services for .NET
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
New DevTools event listeners for console and DOM mutations
The \org.openqa.selenium.devtools.events\ package now provides factory methods to create \EventType\ instances for browser console events (\consoleEvent\) and DOM attribute mutations (\domMutation\). These listeners automatically establish a Chrome DevTools Protocol session on the target WebDriver and inject a JavaScript mutation listener script to detect changes, allowing users to register handlers that receive structured event data (including the affected \WebElement\, attribute name, and value changes) without manual CDP command management.
java/src/org/openqa/selenium/devtools/events · high confidence
New Docker-based Dynamic Grid node implementation
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
New Grid UI with browser/OS icons and session management
The Grid UI has been replaced with a new React-based interface that displays browser and operating system logos (Chrome, Edge, Firefox, Opera, Safari, Android, Linux, Mac, Windows) in the overview and session views. The application now uses React Router for navigation between the Overview, Sessions, and Help pages, and polls the backend via GraphQL to show real-time grid status, session counts, and queue sizes.
javascript/grid-ui · high confidence
New HTTP-based Router server implementation
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
New JMX helper and MBean abstraction for Grid services
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
New Java API for BiDi Browser, Network, Storage, and Speculation modules
Users can now interact with WebDriver BiDi capabilities through new high-level classes in the \org.openqa.selenium.bidi.module\ package. The \Browser\ class exposes methods for managing user contexts and download behavior, while \Network\ provides controls for request interception, authentication handling, and cache behavior, along with event listeners for network activity. \Storage\ simplifies cookie management, and the \speculation\ package introduces support for prefetch status events. All new classes are marked as \@Beta\ and require a BiDi-capable WebDriver instance.
java/src/org/openqa/selenium/bidi/module · high confidence
New Java API for managing browser extensions via BiDi
This change introduces a new \webextension\ package within the BiDi module, providing the foundational classes for installing and uninstalling browser extensions. It adds \InstallExtensionParameters\ and \UninstallExtensionParameters\ to handle the data required for these operations, along with an \ExtensionData\ interface for extension metadata. All classes are marked as \@Beta\ and the package is null-marked, indicating this is a new, experimental capability for users who need to manage extensions programmatically.
java/src/org/openqa/selenium/bidi/webextension · high confidence
New Java Docker client library with version-aware API adapters
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
New Java classes for BiDi browsing context events and commands
This change introduces a new \org.openqa.selenium.bidi.browsingcontext\ package containing data models and parameters for the WebDriver BiDi browsing context module. It adds support for handling browsing context information (\BrowsingContextInfo\), navigation states (\NavigationInfo\, \NavigationResult\, \ReadinessState\), and history updates (\HistoryUpdated\). It also implements models for download lifecycle events (\DownloadInfo\, \DownloadEnded\, \DownloadCompleted\, \DownloadCanceled\) and user prompt interactions (\UserPromptOpened\, \UserPromptClosed\, \UserPromptType\). Additionally, it provides \LocateNodeParameters\ for the locate nodes command. All classes are marked as \@Beta\ and include JSON serialization/deserialization logic.
java/src/org/openqa/selenium/bidi/browsingcontext · high confidence
New Java storage module for WebDriver BiDi cookie operations
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
New Java types for WebDriver BiDi script execution and evaluation
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
New JavadocJarMaker tool for generating stable Javadoc JARs
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
New Kubernetes Dynamic Grid Node support
Selenium Grid nodes can now dynamically provision browser sessions as Kubernetes Jobs. This adds a new \org.openqa.selenium.grid.node.kubernetes\ package containing the \KubernetesSessionFactory\ and configuration flags (e.g., \--kubernetes-configs\, \--kubernetes-namespace\) that allow the Grid to spawn browser containers in a K8s cluster. The implementation supports inheriting Pod specs (like resource limits and service accounts) from the Node Pod, configuring video recording sidecars, and managing session assets, with the Kubernetes client library provided as a runtime extension.
java/src/org/openqa/selenium/grid/node/kubernetes · high confidence
New Node configuration and session factory components
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
New OpenTelemetry-based tracing API for HTTP interactions
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
New Python generators and runtime for WebDriver BiDi and Chrome DevTools Protocol
This change introduces the Python-side code generation and runtime infrastructure for the WebDriver BiDi protocol and the Chrome DevTools Protocol (CDP). It adds \generate\_bidi.py\ and \generate\_bidi\_protocol.py\ to produce Python type definitions and command classes from CDDL and binding-neutral schemas, respectively, and includes \generate.py\ for CDP module generation. The \py/private/\_script\_handlers.py\ module provides high-level helpers for the BiDi script module, including registries for console and JavaScript error handling, DOM mutation observation, and pinned script execution. A new \py/private/cdp.py\ module implements the low-level CDP connection using Trio and WebSocket, with configurable max message sizes. The \py/selenium/webdriver/common/\_bidi/serialization.py\ file provides the runtime support for serializing and deserializing BiDi payloads, including handling of unions, records, and optional fields. Corresponding unit tests are added for the BiDi serialization and transport layers.
selenium · high confidence
New Relay Node component for forwarding WebDriver sessions
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
New Speculation module for prefetch status events
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
New UI support classes for loadable components, popups, and selects
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
New W3C-compliant Actions API for advanced browser interactions
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
New WebDriver extension methods for screenshots and JavaScript execution
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
New WebDriverDecorator API for extending WebDriver behavior
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
New \`io\` module for file, zip, and stream utilities
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
New build, CI, and developer-experience scripts
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
New concurrent utility package for lazy initialization and guarded execution
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
New configuration module for Grid Session Map settings
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
New event args and shadow root event support in .NET EventFiringWebDriver
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
New event listener infrastructure for WebDriver
This change introduces a new \WebDriverListener\ interface and associated support classes in the \org.openqa.selenium.support.events\ package, enabling users to hook into WebDriver lifecycle events (such as navigation, element finding, and screenshot capture) via an \EventFiringDecorator\. The implementation includes a dedicated exception type (\WebDriverListenerException\) for listener errors and adopts nullability annotations via \jspecify\ for improved type safety.
java/src/org/openqa/selenium/support/events · high confidence
New grid command-line interface and shell completions
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
New grid data models and server-side event bus integration
This change introduces a new data package for the Selenium Grid that adds structured data models for session management (Session, CreateSessionRequest/Response, NewSessionResponse) and node lifecycle (Availability, NodeStatus). It also establishes a server-side event bus by adding event classes for node and session lifecycle changes, including NodeAdded, NodeRemoved, NodeRestarted, NodeDrainStarted/Complete, NodeHeartBeat, NodeRejected, NewSessionResponse, and SessionClosed. The SessionClosedEvent now carries rich context (SessionClosedData) with node ID, URI, capabilities, and timing, enabling sidecar services to perform actions like stopping video recording or collecting logs. Additionally, the DefaultSlotMatcher is updated to support semantic version comparison for browser versions, handle managed downloads capability matching, and improve matching logic for prefixed platform versions and extension capabilities.
java/src/org/openqa/selenium/grid/data · high confidence
New grid session package with nullability annotations
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
New grid web infrastructure for serving UI and handling requests
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
New internal Docker image reference and summary models
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
New internal logging system with file output and debug support
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
New internal utility classes and debug logging configuration
This change introduces several new internal helper classes in the \org.openqa.selenium.internal\ package: \Debug\ for managing debug mode via the \SE\_DEBUG\ environment variable and \selenium.debug\ system property, including a warning when \SE\_DEBUG\ overrides user settings; \Maps\ and \Sets\ for creating immutable, ordered, or sorted collections; and \Multimap\ for holding multiple values per key. Additionally, the package is now marked with \@NullMarked\ to enforce null-safety annotations.
java/src/org/openqa/selenium/internal · high confidence
New modular Node HTTP server implementation
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
New modular grid server configuration and event bus infrastructure
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
New modular slot selector package with GreedySlotSelector option
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
New remote HTTP client infrastructure and configuration model
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
New remote driver architecture and augmentation framework
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
New security configuration module for Selenium Grid
This change introduces a new \org.openqa.selenium.grid.security\ package that centralizes security-related configuration handling for the Grid. It adds \SecretOptions\ to manage registration secrets and server authentication, specifically allowing the system to derive a registration secret from the SSL certificate when HTTPS is enabled but no explicit secret is configured. The module also includes nullability annotations via \@NullMarked\ and is built as a standalone library with dependencies on core, config, JSON, HTTP, Guava, and JSpecify.
java/src/org/openqa/selenium/grid/security · high confidence
New session map HTTP handlers for Grid session management
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
New standalone SessionMap server command
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
Publish browser automation atoms as a standalone npm package
The JavaScript atoms (get-attribute, find-elements, isDisplayed) are now built with TypeScript and published as the \@selenium/atoms\ npm package. This allows external tooling to reuse Selenium's browser-compatibility logic for DOM queries and visibility checks, independent of the main WebDriver bindings.
javascript · high confidence
Redis-backed session queue with configurable tuning options
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
Ruby bindings add WebDriver BiDi protocol support and virtual authenticator capabilities
The Ruby bindings now include a low-level implementation of the WebDriver BiDi protocol, providing classes for browser management (user contexts, windows), session handling, and network interception (request, response, and authentication handlers). Additionally, support for the W3C Virtual Authenticator API is introduced, allowing users to manage credentials for WebAuthn flows. These changes are marked as private API and are intended to enable higher-level features in future releases.
selenium-webdriver · high confidence
Safari driver now supports browser permissions and debugger attachment
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
Selenium Java API core interfaces and models are introduced
The \java/src/org/openqa/selenium\ package now contains the foundational API definitions for the Selenium Java client, including core interfaces such as \Capabilities\, \JavascriptExecutor\, \Alert\, and \HasAuthentication\, as well as model classes like \Architecture\, \Dimension\, and \DeviceRotation\. This change establishes the public contract for browser capabilities, JavaScript execution (including script pinning), and element interaction, while also introducing new W3C-compliant exception classes like \DetachedShadowRootException\ and \ElementClickInterceptedException\ to provide more specific error reporting during test execution.
java/src/org/openqa/selenium · high confidence
Selenium WebDriver for JavaScript restructured with TypeScript atoms and BiDi support
The JavaScript bindings have been reorganized to improve build consistency and add modern protocol support. Internal modules are now isolated in a dedicated \lib/\ directory to clarify public API boundaries. Key element interaction operations—\isDisplayed\, \get\_attribute\, and \findElements\—have been migrated to TypeScript atoms, ensuring type safety and consistent behavior across the build system. Additionally, the library now includes native support for the WebDriver BiDi protocol, featuring a dedicated connection manager and new APIs for handling Federated Credential Management (FedCM) dialogs, allowing scripts to interact with modern identity provider prompts.
javascript/selenium-webdriver · high confidence
Standardize Java development environment and contributor guidance
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
Architecture
Centralized Bazel infrastructure for pinned browser and driver management
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
Grid distributor refactored into modular HTTP handlers and abstract state model
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
New driver service and command execution infrastructure
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
Rake build tasks are split into per-language files with a new Bazel test-indexing system
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
Behavioural changes
3 commits (0 fixes) modifying common/devtools/chromium
A change to existing behaviour in common/devtools/chromium — 3 commits, 9 files: “\[build\] Automated Browser Version Update (major) with CDP (\#18214)”; “\[build\] Automated Browser Version Update (major) with CDP (\#18131)”; “\[build\] Automated Browser Version Update (major) with CDP (\#18278)” (refs \#18214, \#18131, \#18278).
common/devtools/chromium · medium confidence · unverified
8 commits (0 fixes) modifying java/src/org/openqa/selenium/os
A change to existing behaviour in java/src/org/openqa/selenium/os — 8 commits, 3 files: “\[java\] Create new \io\ maven artifact and make SeleniumManager use that for executing command lines”; “Automatically format the code (\#12023)”; “Move java sources and tests into a single tree (\#9710)”; and 5 more (refs \#12023, \#9710, \#16865, \#16935, \#16776, …).
java/src/org/openqa/selenium/os · medium confidence · unverified
Added JSON extension methods for BiDi serialization
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
Adoption of implicit global usings in .NET support library
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
Build system now supports stubbed Selenium Manager for faster test cycles
The build configuration has been updated to allow Selenium Manager to be replaced by a stub during testing via the \--manager=stub\ or \--manager=host\ Bazel flags. This prevents pin updates from invalidating test caches, significantly speeding up test execution. The stub outputs placeholder SBOM and third-party notice files, while the full build (\--manager=download\ or \--manager=all\) continues to bundle the actual prebuilt binaries and compliance artifacts for Linux, macOS, Windows, and ARM64 architectures.
common/manager · high confidence
Chrome driver implementation refactored to use Selenium Manager and W3C compliance
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
Distributor server now returns HTTP 503 on /readyz when not ready
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
Firefox driver options and service configuration overhaul
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
Grid Router refactored with connection pooling and WebSocket performance improvements
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
Grid configuration system refactored with new implementation classes and TOML library migration
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
IE Driver adds Edge IE Mode support and refactors core components
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
IEDriver Command Handlers Refactored for W3C Compliance
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
Internet Explorer driver source files moved to new package structure
The Internet Explorer driver implementation files (including InternetExplorerDriver, InternetExplorerDriverService, and related classes) have been relocated to the java/src/org/openqa/selenium/ie directory. This change introduces a new BUILD.bazel build configuration for the driver module, updates package declarations to org.openqa.selenium.ie, and adds nullability annotations via jspecify to improve type safety. The driver service now uses DriverFinder for executable location and supports configurable logging levels and host binding through the builder pattern.
java/src/org/openqa/selenium/ie · high confidence
Introduce BrowsingContext module with context-aware event sources and command options
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
Introduction of W3C-compliant .NET Remote WebDriver implementation
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
Java DevTools module restructured with lazy augmentation and JSpecify null-safety
The Java DevTools implementation has been refactored to improve reliability and code quality. The DevTools interface is now augmented lazily, meaning the connection to the browser is not established until the first command is sent, which prevents unnecessary overhead for drivers that do not use DevTools. The module has also been migrated to use JSpecify annotations for null-safety, replacing previous Guava dependencies with standard Java libraries where possible. Additionally, the connection logic has been updated to allow users to provide a custom HttpClient configuration, and the version matching logic now uses a ServiceLoader-based approach for better extensibility.
java/src/org/openqa/selenium/devtools · high confidence
Java Edge driver implementation is restructured and extended with casting and CDP support
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
Java JSON library refactored with JSpecify nullability and Guava removal
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
Java bindings receive comprehensive nullability annotations and refactoring
The Java bindings have been updated with extensive JSpecify nullability annotations across core packages including \org.openqa.selenium\, \org.openqa.selenium.bidi\, and \org.openqa.selenium.remote\. This change introduces \@Nullable\ markers to fields and parameters in classes such as \Cookie\, \By\, \Point\, and \Capabilities\, improving static analysis and reducing runtime null-pointer exceptions. Additionally, the \Point\ class is now immutable, and the \Cookie\ class now supports the \sameSite\ attribute. The \BiDi\ connection logic has been refactored to use subscription IDs for listener management, and the \ModuleGenerator\ tool has been added to support Java module system generation.
{artifactId} · high confidence
Java build infrastructure migrated to JUnit 5 and Bazel rules\_jvm\_external
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
Java logging API restructured with new core interfaces and classes
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
Local session map package nullability and build configuration
The local session map module now includes explicit nullability annotations via the jspecify library, marking the package as null-marked to improve type safety for grid session management. Additionally, a Bazel build file has been added to define the local library, specifying its dependencies on core grid components, Caffeine, and jspecify, and setting visibility for related command and HTTPD packages.
java/src/org/openqa/selenium/grid/sessionmap/local · medium confidence
Migrate .NET test execution to Microsoft Testing Platform
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
Migrate Linux native event library to Bazel and add X11 event debugging tool
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
Migrate Python bindings to use Rust-based Selenium Manager
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
Native mouse hovering and modifier key state handling on Windows
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
New Bazel build rules and NuGet packaging for the .NET Support library
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
New Netty-based HTTP and WebSocket server implementation
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
New SessionQueue HTTP server with readiness checks and deprecated max-threads warning
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
New W3C WebDriver Actions API for Java
The \org.openqa.selenium.interactions\ package has been replaced with a new implementation aligned with the W3C WebDriver specification. Users can now use the \Actions\ builder class to compose complex gestures involving keyboards, pointers, and wheels via \Sequence\ objects. This new API introduces \InputSource\ and \SourceType\ abstractions (KEY, POINTER, WHEEL) and requires explicit handling of modifier key states, replacing the legacy \Keyboard\ and \Mouse\ classes.
java/src/org/openqa/selenium/interactions · high confidence
New configurable distributor settings and Redis backend support
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
New session request queue implementation for Selenium Grid
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
New structured and plain logging configuration for the Grid
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
Page Factory components moved to new package with null-safety annotations
The Page Factory implementation classes (including \DefaultElementLocator\, \DefaultFieldDecorator\, and related interfaces) have been relocated to the \org.openqa.selenium.support.pagefactory\ package. This move includes the addition of \@NullMarked\ annotations to the package-info files, indicating that the codebase in this area now enforces null-safety contracts for its public APIs.
java/src/org/openqa/selenium/support/pagefactory · high confidence
Page Factory locator builders use generics and JSpecify nullability annotations
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
Polyfills modern .NET compiler features for older runtimes
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
Python bindings now require Python 3.10+ and drop support for Python 3.9
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
Refactored IE driver input simulation into dedicated strategy classes
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
Refactored OpenTelemetry tracing implementation to use modern APIs
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
Refactored network utilities with improved port selection and host resolution
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
Relocate relative locator logic to support remote server execution
The \org.openqa.selenium.support.locators\ package has been restructured to enable the remote server to handle relative locators directly. This change introduces \RelativeLocatorScript.java\, which loads the \findElements\ JavaScript atom (copied from the TypeScript source via the new Bazel build rule) to execute relative locator logic on the server side, rather than relying on client-side evaluation. Additionally, the package is now marked with \@NullMarked\ via \package-info.java\ to enforce null-safety annotations.
java/src/org/openqa/selenium/support/locators · high confidence
Rewritten .NET DevTools code generator with .NET 8 and System.Text.Json
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
Ruby bindings now require Ruby 3.1 or later
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
Support UI package restructured with JSpecify null-safety and build rules
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
Updated BiDi schema with Mozilla-specific debugging, profiling, and extension commands
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. Also in this area: Updated browser versions and relaxed WebDriver BiDi schema validation.
common/bidi · high confidence
Updated Selenium mirror metadata to include version 4.49.0
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
Updated Visual Studio solution for IE Driver
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
Updated embedded JavaScript automation atoms for IE Driver
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
Vendor Closure Library and patch Bazel build rules
The Closure Library source code and its Bazel build files are now vendored into the repository, including the Apache 2.0 license file and BUILD targets for core modules like ARIA accessibility utilities and array helpers. To support this integration and improve build stability, several Bazel rules have been patched: rules\_rs toolchain names are shortened to avoid path length issues, rules\_ruby is patched to correctly bundle the JRuby interpreter in runfiles, rules\_jvm\_external is extended to allow excluding third-party prefixes from Javadoc generation, and a mirror fallback is added for Ubuntu .deb downloads to prevent build failures from intermittent network errors.
_third\party · high confidence
Wait conditions can now be cancelled and the wait logic is extensible
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
Fixes
W3C codec now normalizes class name and ID locators to CSS selectors
The W3C HTTP command codec in the remote codec package now converts \By.className()\ and \By.id()\ locators into CSS selectors before sending them to the browser. This change ensures that non-ASCII characters and special symbols in class names or IDs are properly escaped, fixing previous issues where these characters were incorrectly handled or left unescaped.
java/src/org/openqa/selenium/remote/codec · high confidence
Test coverage
4 commits adding/updating tests in dotnet/test/unit; 8 commits adding/updating tests in dotnet/test/testing.nunit; 8 commits adding/updating tests in dotnet/test/testing.nunit/Environment; Added .NET remote WebDriver integration tests; Added BiDi test fixture for WebDriver integration tests; Added BiDi test harness pages for logging, input actions, and script preloading; Added Firefox and IE WebDriver test suites; Added frames benchmark for Safari driver performance testing; Added interaction tests for pointer, keyboard, wheel, and drag-and-drop actions; 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 fixture pages for proxy and WebDriver scenarios; Added test fixture pages for window switching tests; 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 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; New test infrastructure and sample web pages for Selenium.
Dependencies
New .NET project structure and dependency management
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 54 → 54 (+0.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 43 → 49 (+5.6)
- Architecture 83 → 71 (-12.5)
- Maturity 72 → 82 (+9.4)
- Readiness 62 → 58 (-3.4)
- Security 59 → 53 (-6.2)
- Domain Modelling 100 → 100 (+0.0)
- Performance 60 → 58 (-2.2)
Resolved (145)
- AbstractHttpResponseCodec.decode (cognitive 23) (java/src/org/openqa/selenium/remote/codec/AbstractHttpResponseCodec.java)
- AbstractHttpResponseCodec.decode (cyclomatic 18) (java/src/org/openqa/selenium/remote/codec/AbstractHttpResponseCodec.java)
- Alias redundancy. Keys.BACKSPACE and Keys.BACK_SPACE are likely identical constants (one is a typo/alias for the other). While this aids user convenience, it clutters the public API with redundant names for the same value.
- Change coupling clique: ChromeDriverInfo.java, EdgeDriverInfo.java, GeckoDriverInfo.java, SafariDriverInfo.java, SafariTechPreviewDriverInfo.java (java/src/org/openqa/selenium/chrome/ChromeDriverInfo.java)
- Change coupling: DistributorServer.java ↔ LocalDistributor.java (java/src/org/openqa/selenium/grid/distributor/httpd/DistributorServer.java)
- Checkable ADR rule enforced only by prose: 17670. BiDi implementation boundaries (docs/decisions/17670-bidi-implementation-boundaries.md)
- ClassTooLong: DockerSessionFactory (java/src/org/openqa/selenium/grid/node/docker/DockerSessionFactory.java)
- Conflicting property type signatures. Similar to binary_location, debugger_address is listed with two types. This indicates a read-write property but is presented inconsistently.
- Conflicting property type signatures. The property binary_location is listed with two different return types (str and None). This suggests the property is read-write (getter returns str | None), but the API surface lists them as separate entries, which is confusing and inconsistent with standard property representation.
- Conflicting property type signatures. enable_webextensions is listed with two types, indicating a read-write property but presented inconsistently.
- Duplicate method signature across inheritance hierarchy. ArgOptions (likely Chrome/Edge specific options) duplicates ignore_local_proxy_environment_variables from BaseOptions. This is a clear redundancy in the public API surface.
- Duplicate method signature across inheritance hierarchy. Options (Chrome-specific) inherits from or duplicates BaseOptions. The enable_mobile method is defined in both, creating redundancy. While Options might override it, the signature is identical, suggesting BaseOptions should be the single source of truth or Options should not re-expose it if it doesn't change behavior.
- Duplicate property definition. ChromiumService inherits from Service (implied by structure) and re-declares the service_args property. This is redundant.
- Duplicated block (10 lines × 2) (java/src/org/openqa/selenium/By.java)
- Duplicated block (10 lines × 2) (java/src/org/openqa/selenium/grid/commands/CompletionCommand.java)
- Duplicated block (11 lines × 2) (java/src/org/openqa/selenium/bidi/log/ConsoleLogEntry.java)
- Duplicated block (11 lines × 2) (java/src/org/openqa/selenium/json/JsonInput.java)
- Duplicated block (11 lines × 2) (py/selenium/webdriver/firefox/remote_connection.py)
- Duplicated block (12 lines × 2) (java/src/org/openqa/selenium/grid/sessionmap/config/SessionMapOptions.java)
- Duplicated block (12 lines × 2) (java/src/org/openqa/selenium/json/JsonOutput.java)
- …and 125 more
New (374)
- Change coupling: ChromeDriverInfo.java ↔ GeckoDriverInfo.java (java/src/org/openqa/selenium/chrome/ChromeDriverInfo.java)
- Change coupling: EdgeDriverInfo.java ↔ GeckoDriverInfo.java (java/src/org/openqa/selenium/edge/EdgeDriverInfo.java)
- Change-coupling hub: SafariDriverInfo.java → ChromeDriverInfo.java, EdgeDriverInfo.java, GeckoDriverInfo.java, SafariTechPreviewDriverInfo.java (java/src/org/openqa/selenium/safari/SafariDriverInfo.java)
- ClassTooLong: JsonInput (java/src/org/openqa/selenium/json/JsonInput.java)
- ConstructorCoercer.tryDirectCoercion (cognitive 42) (java/src/org/openqa/selenium/json/ConstructorCoercer.java)
- ConstructorCoercer.tryDirectCoercion (cyclomatic 28) (java/src/org/openqa/selenium/json/ConstructorCoercer.java)
- Duplicated block (10 lines × 3) (java/src/org/openqa/selenium/devtools/v155/v155Events.java)
- Duplicated block (11 lines × 2) (py/selenium/webdriver/remote/shadowroot.py)
- Duplicated block (13 lines × 2) (java/src/org/openqa/selenium/grid/sessionmap/jdbc/JdbcBackedSessionMap.java)
- Duplicated block (13 lines × 2) (rust/src/rules.rs)
- Duplicated block (14 lines × 2) (java/src/org/openqa/selenium/json/JsonOutput.java)
- Duplicated block (14 lines × 3) (java/src/org/openqa/selenium/devtools/v155/v155Log.java)
- Duplicated block (15 lines × 2) (java/src/org/openqa/selenium/grid/node/docker/DockerSessionFactory.java)
- Duplicated block (15 lines × 4) (java/src/org/openqa/selenium/bidi/browsingcontext/DownloadInfo.java)
- Duplicated block (15–17 lines × 2) (java/src/org/openqa/selenium/grid/distributor/local/LocalDistributor.java)
- Duplicated block (16 lines × 3) (dotnet/src/webdriver/DevTools/v155/V155JavaScript.cs)
- Duplicated block (18 lines × 3) (dotnet/src/webdriver/DevTools/v155/V155Target.cs)
- Duplicated block (18 lines × 3) (java/src/org/openqa/selenium/devtools/v155/v155Log.java)
- Duplicated block (18 lines × 3) (java/src/org/openqa/selenium/devtools/v155/v155Network.java)
- Duplicated block (18 lines × 3) (java/src/org/openqa/selenium/devtools/v155/v155Network.java)
- …and 354 more
Changes since last survey
- 109 commits — 100 feature/other, 9 fixes
By area
- .github/workflows — 20 commits
- py/selenium — 11 commits
- java/src — 10 commits
- common/selenium_manager.bzl — 8 commits
- py/test — 8 commits
- (root) — 7 commits
- dotnet/test — 5 commits
- common/repositories.bzl — 4 commits
- rb/spec — 4 commits
- rust/src — 4 commits
- javascript/selenium-mcp — 3 commits
- rb/lib — 3 commits
- .github/rulesets — 2 commits
- java/test — 2 commits
- javascript/selenium-webdriver — 2 commits
- py/BUILD.bazel — 2 commits
- rake_tasks/dotnet.rake — 2 commits
- .github/pr-labeler-config.yml — 1 commit
- common/mirror — 1 commit
- common/src — 1 commit
Notable commits
- fix: [build] fix authors rake task so it can run on Windows
- fix: [build] fix rake git commands that break under cmd.exe on Windows
- fix: [java] Log remote-client diagnostics at a fixed FINE level (#18254)
- fix: [py] Fix Select escaping of trailing double quotes (#18292)
- fix: [py] fix race condition in test for browsing context handler removal
- fix: [py][rb] Fix tests failing after the browser version update (#18294)
- fix: [py][rb][js] Fix tests failing in the nightly CI run (#18289)
- fix: [rust] Fix Firefox and Electron download URLs on Windows arm64 (#18285)
- fix: fix(#18263): keep Selenium Manager stderr empty in --output json (#18268)
- change: Release selenium-4.52.0 (#18259)
- change: Update mirror info (Thu Oct 29 13:16:32 UTC 2026)
- change: [build] Add weekly CI check for Plausible pageview usage (#17900)
- change: [build] Automated Browser Version Update (#18302)
- change: [build] Automated Browser Version Update (#18311)
- change: [build] Automated Browser Version Update (major) (#18247)
- change: [build] Automated Browser Version Update (major) (#18298)
- change: [build] Automated Browser Version Update (major) with CDP (#18214)
- change: [build] Automated Browser Version Update (major) with CDP (#18278)
- change: [build] Automated CDDL Spec Update (#18248)
- change: [build] Automated Dependency Update (#18242)
- …and 89 more
Architecture
- Unchanged — 1 containers · 4 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 72e603c2c557d239b7698fa05d20e60cf793f8bf — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.