diff --git a/.github/workflows/playwright.yaml b/.github/workflows/playwright.yaml
new file mode 100644
index 000000000000..54e43bbcdccb
--- /dev/null
+++ b/.github/workflows/playwright.yaml
@@ -0,0 +1,96 @@
+name: Playwright tests
+on:
+  push:
+    paths-ignore:
+      - 'doc/**'
+      - 'packages/**'
+  pull_request:
+    paths-ignore:
+      - 'doc/**'
+      - 'packages/**'
+  schedule:
+    # Run at midnight UTC every Tuesday
+    - cron: '0 0 * * 2'
+env:
+  GALAXY_CONFIG_GALAXY_URL_PREFIX: '/galaxypf'
+  GALAXY_TEST_DBURI: 'postgresql://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
+  GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
+  GALAXY_TEST_SELENIUM_RETRIES: 1
+  GALAXY_TEST_SKIP_FLAKEY_TESTS_ON_ERROR: 1
+  GALAXY_TEST_SELENIUM_HEADLESS: 1
+  YARN_INSTALL_OPTS: --frozen-lockfile
+  GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  build-client:
+    uses: ./.github/workflows/build_client.yaml
+  test:
+    name: Test
+    needs: [build-client]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.9']
+        chunk: [0, 1, 2]
+    services:
+      postgres:
+        image: postgres:17
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: postgres
+        ports:
+          - 5432:5432
+    steps:
+      - if: github.event_name == 'schedule'
+        run: |
+          echo "GALAXY_CONFIG_OVERRIDE_METADATA_STRATEGY=extended" >> $GITHUB_ENV
+          echo "GALAXY_CONFIG_OVERRIDE_OUTPUTS_TO_WORKING_DIRECTORY=true" >> $GITHUB_ENV
+      - uses: actions/checkout@v5
+        with:
+          path: 'galaxy root'
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+          cache-dependency-path: 'galaxy root/requirements.txt'
+      - name: Get full Python version
+        id: full-python-version
+        shell: bash
+        run: echo "version=$(python -c 'import sys; print("-".join(str(v) for v in sys.version_info))')" >> $GITHUB_OUTPUT
+      - name: Cache galaxy venv
+        uses: actions/cache@v4
+        with:
+          path: 'galaxy root/.venv'
+          key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-playwright
+      - name: Install Playwright
+        run: |
+          pip install playwright
+          playwright install chromium --with-deps
+        working-directory: 'galaxy root'
+      - name: Restore client cache
+        uses: actions/cache@v4
+        with:
+          key: galaxy-static-${{ needs.build-client.outputs.commit-id }}
+          path: 'galaxy root/static'
+      - name: Run tests
+        run: ./run_tests.sh --coverage -playwright lib/galaxy_test/selenium -- --num-shards=3 --shard-id=${{ matrix.chunk }}
+        working-directory: 'galaxy root'
+      - uses: codecov/codecov-action@v5
+        with:
+          flags: playwright
+          working-directory: 'galaxy root'
+      - uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: Playwright test results (${{ matrix.python-version }}, ${{ matrix.chunk }})
+          path: 'galaxy root/run_playwright_tests.html'
+      - uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: Playwright debug info (${{ matrix.python-version }}, ${{ matrix.chunk }})
+          path: 'galaxy root/database/test_errors'
diff --git a/client/src/components/User/UserPreferences.vue b/client/src/components/User/UserPreferences.vue
index 3e7fd096a879..ede9aa55c77d 100644
--- a/client/src/components/User/UserPreferences.vue
+++ b/client/src/components/User/UserPreferences.vue
@@ -112,6 +112,9 @@ async function signOut() {
         okVariant: "danger",
         cancelTitle: "Cancel",
         cancelVariant: "outline-primary",
+        // data-description cannot be set for this so falling back to
+        // setting a class for DOM inspection.
+        modalClass: "sign-out-modal",
         centered: true,
     });
 
diff --git a/client/src/utils/navigation/navigation.yml b/client/src/utils/navigation/navigation.yml
index f0721c0b4960..38f8a505d5c3 100644
--- a/client/src/utils/navigation/navigation.yml
+++ b/client/src/utils/navigation/navigation.yml
@@ -139,8 +139,8 @@ change_user_address:
 
 sign_out:
   selectors:
-    cancel_button: '.modal-footer .btn-outline-primary'
-    sign_out_button: '.modal-footer .btn-danger'
+    cancel_button: '.sign-out-modal .modal-footer .btn-outline-primary'
+    sign_out_button: '.sign-out-modal .modal-footer .btn-danger'
 
 dataset_details:
   selectors:
diff --git a/lib/galaxy/objectstore/templates/models.py b/lib/galaxy/objectstore/templates/models.py
index 8f625d7973cc..b6aefcda1e22 100644
--- a/lib/galaxy/objectstore/templates/models.py
+++ b/lib/galaxy/objectstore/templates/models.py
@@ -14,6 +14,7 @@
 from typing_extensions import (
     Annotated,
     Literal,
+    TypeAlias,
 )
 
 from galaxy.objectstore.badges import (
@@ -39,7 +40,7 @@
 )
 
 ObjectStoreTemplateVariableType = TemplateVariableType
-ObjectStoreTemplateVariableValueType = TemplateVariableValueType
+ObjectStoreTemplateVariableValueType: TypeAlias = TemplateVariableValueType
 ObjectStoreTemplateType = Literal["aws_s3", "azure_blob", "boto3", "disk", "generic_s3", "onedata", "rucio", "irods"]
 
 
diff --git a/lib/galaxy/selenium/availability.py b/lib/galaxy/selenium/availability.py
new file mode 100644
index 000000000000..78d9262bfe8b
--- /dev/null
+++ b/lib/galaxy/selenium/availability.py
@@ -0,0 +1,131 @@
+"""Browser availability checking utilities for Selenium and Playwright.
+
+This module provides functions to check if browsers are available and properly
+configured for automated testing. These functions are used for conditional test
+skipping and diagnostic scripts.
+"""
+
+from functools import lru_cache
+
+from playwright.sync_api import sync_playwright
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+
+# Installation instruction constants
+SELENIUM_INSTALL_INSTRUCTIONS = (
+    "Install Chrome browser and chromedriver. See: https://chromedriver.chromium.org/getting-started"
+)
+
+PLAYWRIGHT_INSTALL_INSTRUCTIONS = "Install with: playwright install chromium"
+
+# Skip message constants for pytest
+SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE = f"Selenium Chrome browser not available. {SELENIUM_INSTALL_INSTRUCTIONS}"
+
+PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE = (
+    f"Playwright Chromium browser not available. {PLAYWRIGHT_INSTALL_INSTRUCTIONS}"
+)
+
+
+def is_selenium_browser_available() -> bool:
+    """
+    Check if Selenium WebDriver can launch Chrome browser.
+
+    Returns:
+        bool: True if Chrome browser is available and can be launched, False otherwise
+    """
+    try:
+        options = ChromeOptions()
+        options.add_argument("--headless=new")
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        driver = webdriver.Chrome(options=options)
+        driver.quit()
+        return True
+    except Exception:
+        return False
+
+
+def is_playwright_browser_available() -> bool:
+    """
+    Check if Playwright Chromium browser is installed and available.
+
+    Returns:
+        bool: True if Playwright Chromium is installed, False otherwise
+    """
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            browser.close()
+        return True
+    except Exception:
+        return False
+
+
+def get_selenium_availability_message() -> str:
+    """
+    Get a descriptive message about Selenium browser availability.
+
+    Returns:
+        str: Status message indicating if Selenium is available or how to enable it
+    """
+    if is_selenium_browser_available():
+        return "Selenium Chrome browser is available"
+    else:
+        return SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE
+
+
+def get_playwright_availability_message() -> str:
+    """
+    Get a descriptive message about Playwright browser availability.
+
+    Returns:
+        str: Status message indicating if Playwright is available or how to enable it
+    """
+    if is_playwright_browser_available():
+        return "Playwright Chromium browser is available"
+    else:
+        return PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE
+
+
+@lru_cache(maxsize=1)
+def check_selenium_cached() -> bool:
+    """
+    Check Selenium browser availability with caching.
+
+    This avoids repeatedly launching browsers during test collection.
+    Uses lru_cache with maxsize=1 to cache the result of the check.
+
+    Returns:
+        bool: True if Selenium Chrome browser is available
+    """
+    return is_selenium_browser_available()
+
+
+@lru_cache(maxsize=1)
+def check_playwright_cached() -> bool:
+    """
+    Check Playwright browser availability with caching.
+
+    This avoids repeatedly launching browsers during test collection.
+    Uses lru_cache with maxsize=1 to cache the result of the check.
+
+    Returns:
+        bool: True if Playwright Chromium browser is available
+    """
+    return is_playwright_browser_available()
+
+
+__all__ = (
+    # Constants
+    "SELENIUM_INSTALL_INSTRUCTIONS",
+    "PLAYWRIGHT_INSTALL_INSTRUCTIONS",
+    "SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE",
+    "PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE",
+    # Functions
+    "is_selenium_browser_available",
+    "is_playwright_browser_available",
+    "get_selenium_availability_message",
+    "get_playwright_availability_message",
+    "check_selenium_cached",
+    "check_playwright_cached",
+)
diff --git a/lib/galaxy/selenium/cli.py b/lib/galaxy/selenium/cli.py
index 109343ea5961..04feb67de292 100644
--- a/lib/galaxy/selenium/cli.py
+++ b/lib/galaxy/selenium/cli.py
@@ -4,15 +4,19 @@
 REMOTE_PORT_DESCRIPTION = "Selenium hub remote port to use (if remote driver in use)."
 GALAXY_URL_DESCRIPTION = "URL of Galaxy instance to target."
 HEADLESS_DESCRIPTION = "Use local selenium headlessly (native in chrome, otherwise this requires pyvirtualdisplay)."
+BACKEND_DESCRIPTION = "Browser automation backend to use (selenium or playwright)."
 
+from typing import Literal
 from urllib.parse import urljoin
 
 from .driver_factory import (
-    get_local_driver,
-    get_remote_driver,
+    ConfiguredDriver,
     virtual_display_if_enabled,
 )
-from .navigates_galaxy import NavigatesGalaxy
+from .navigates_galaxy import (
+    galaxy_timeout_handler,
+    NavigatesGalaxy,
+)
 
 
 def add_selenium_arguments(parser):
@@ -50,29 +54,50 @@ def add_selenium_arguments(parser):
         default="http://127.0.0.1:8080/",
         help=GALAXY_URL_DESCRIPTION,
     )
+    parser.add_argument(
+        "--backend",
+        default="selenium",
+        choices=["selenium", "playwright"],
+        help=BACKEND_DESCRIPTION,
+    )
 
     return parser
 
 
 class DriverWrapper(NavigatesGalaxy):
-    """Adapt argparse command-line options to a concrete Selenium driver."""
+    """Adapt argparse command-line options to a browser automation driver."""
 
     def __init__(self, args):
         browser = args.selenium_browser
-        self.display = virtual_display_if_enabled(args.selenium_headless)
-        if args.selenium_remote:
-            driver = get_remote_driver(
-                host=args.selenium_remote_host,
-                port=args.selenium_remote_port,
-                browser=browser,
-            )
-        else:
-            driver = get_local_driver(
-                browser=browser,
-            )
-        self.driver = driver
+        backend_type: Literal["selenium", "playwright"] = args.backend
+
+        # Validate remote option (Playwright doesn't support remote)
+        if backend_type == "playwright" and args.selenium_remote:
+            raise ValueError("Playwright backend does not support remote drivers")
+
+        # Set up virtual display for headless mode (Selenium only)
+        self.display = None
+        if backend_type == "selenium":
+            self.display = virtual_display_if_enabled(args.selenium_headless)
+
+        # Create configured driver with the specified backend
+        # TODO: parameterize timeout multiplier
+        self.configured_driver = ConfiguredDriver(
+            galaxy_timeout_handler(1.0),
+            browser=browser,
+            remote=args.selenium_remote,
+            remote_host=args.selenium_remote_host,
+            remote_port=args.selenium_remote_port,
+            headless=args.selenium_headless,
+            backend_type=backend_type,
+        )
         self.target_url = args.galaxy_url
 
+    @property
+    def _driver_impl(self):
+        """Provide driver implementation from configured_driver."""
+        return self.configured_driver.driver_impl
+
     def build_url(self, url="", for_selenium: bool = True):
         return urljoin(self.target_url, url)
 
@@ -87,17 +112,21 @@ def default_timeout(self):
         return 15
 
     def finish(self):
+        """Clean up driver and display resources."""
         exception = None
 
+        # Quit the driver (works for both backends via protocol)
         try:
-            self.driver.close()
+            self.quit()
         except Exception as e:
             exception = e
 
-        try:
-            self.display.stop()
-        except Exception as e:
-            exception = e
+        # Stop virtual display if used (Selenium only)
+        if self.display is not None:
+            try:
+                self.display.stop()
+            except Exception as e:
+                exception = e
 
         if exception is not None:
             raise exception
diff --git a/lib/galaxy/selenium/context.py b/lib/galaxy/selenium/context.py
index e71b8fda9755..b6996fa160fd 100644
--- a/lib/galaxy/selenium/context.py
+++ b/lib/galaxy/selenium/context.py
@@ -1,9 +1,6 @@
 import os
 from abc import abstractmethod
-from typing import (
-    Optional,
-    TYPE_CHECKING,
-)
+from typing import Optional
 from urllib.parse import urljoin
 
 import yaml
@@ -11,15 +8,22 @@
 from .driver_factory import ConfiguredDriver
 from .navigates_galaxy import NavigatesGalaxy
 
-if TYPE_CHECKING:
-    from selenium.webdriver.remote.webdriver import WebDriver
-
 
 class GalaxySeleniumContext(NavigatesGalaxy):
     url: str
     target_url_from_selenium: str
     configured_driver: ConfiguredDriver
 
+    @property
+    def _driver_impl(self):
+        """Provide driver implementation from configured_driver.
+
+        This property bridges the HasDriverProxy mixin to the ConfiguredDriver
+        used in the test framework. It allows NavigatesGalaxy methods to work
+        without requiring constructor changes in the test infrastructure.
+        """
+        return self.configured_driver.driver_impl
+
     def build_url(self, url: str, for_selenium: bool = True) -> str:
         if for_selenium:
             base = self.target_url_from_selenium
@@ -27,10 +31,6 @@ def build_url(self, url: str, for_selenium: bool = True) -> str:
             base = self.url
         return urljoin(base, url)
 
-    @property
-    def driver(self) -> "WebDriver":  # type: ignore[override]
-        return self.configured_driver.driver
-
     def screenshot(self, label: str):
         """If GALAXY_TEST_SCREENSHOTS_DIRECTORY is set create a screenshot there named <label>.png.
 
@@ -43,7 +43,7 @@ def screenshot(self, label: str):
         if target is None:
             return
 
-        self.driver.save_screenshot(target)
+        self.save_screenshot(target)
         return target
 
     @abstractmethod
diff --git a/lib/galaxy/selenium/driver_factory.py b/lib/galaxy/selenium/driver_factory.py
index 81dd7616561d..829320987daf 100644
--- a/lib/galaxy/selenium/driver_factory.py
+++ b/lib/galaxy/selenium/driver_factory.py
@@ -1,17 +1,40 @@
 import logging
 import os
-from typing import Union
+from typing import (
+    Any,
+    cast,
+    Literal,
+    Union,
+)
+
+# Playwright browser type names (matches BrowserType.name property)
+PlaywrightBrowserName = Literal["chromium", "firefox", "webkit"]
 
 try:
     from pyvirtualdisplay import Display
 except ImportError:
     Display = None
 
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:
+    sync_playwright = None  # type: ignore[assignment]
+
 from selenium import webdriver
 from selenium.webdriver.chrome.options import Options as ChromeOptions
 from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.safari.options import Options as SafariOptions
 
+from .has_driver import HasDriver
+from .has_driver_protocol import (
+    HasDriverProtocol,
+    TimeoutCallback,
+)
+from .has_playwright_driver import (
+    HasPlaywrightDriver,
+    PlaywrightResources,
+)
+
 logger = logging.getLogger("selenium.webdriver.remote.remote_connection")
 logger.setLevel(logging.WARNING)
 
@@ -24,51 +47,140 @@
 DEFAULT_SELENIUM_REMOTE = False
 DEFAULT_SELENIUM_REMOTE_PORT = "4444"
 DEFAULT_SELENIUM_REMOTE_HOST = "127.0.0.1"
+DEFAULT_BACKEND_TYPE: Literal["selenium", "playwright"] = "selenium"
 DEFAULT_WINDOW_WIDTH = 1280
 DEFAULT_WINDOW_HEIGHT = 1000
 VALID_LOCAL_BROWSERS = ["CHROME", "FIREFOX"]
+PLAYWRIGHT_UNAVAILABLE_MESSAGE = "playwright must be installed to use the playwright backend, install with 'pip install playwright' and run 'playwright install chromium'"
 PYVIRTUALDISPLAY_UNAVAILABLE_MESSAGE = "pyvirtualdisplay must be installed to run this test configuration and is not, install with 'pip install pyvirtualdisplay'"
+PLAYWRIGHT_REMOTE_UNSUPPORTED_MESSAGE = "Playwright backend does not support remote drivers (Selenium Grid). Use backend_type='selenium' for remote testing."
+
+
+class _SeleniumDriverImpl(HasDriver[Any]):
+    """Internal wrapper implementing HasDriver for ConfiguredDriver."""
+
+    def __init__(self, driver: WebDriver, timeout_handler: TimeoutCallback):
+        self.driver = driver
+        self._timeout_handler = timeout_handler
+
+    @property
+    def timeout_handler(self) -> TimeoutCallback:
+        """Return timeout value, using kwds override or default."""
+        return self._timeout_handler
+
+
+class _PlaywrightDriverImpl(HasPlaywrightDriver[Any]):
+    """Internal wrapper implementing HasPlaywrightDriver for ConfiguredDriver."""
+
+    def __init__(self, resources: PlaywrightResources, timeout_handler: TimeoutCallback):
+        self._playwright_resources = resources
+        self._timeout_handler = timeout_handler
+        self._current_frame = None
+
+    @property
+    def timeout_handler(self) -> TimeoutCallback:
+        """Return timeout value, using kwds override or default."""
+        return self._timeout_handler
 
 
 class ConfiguredDriver:
-    driver: WebDriver
+    """
+    Configured driver factory supporting both Selenium and Playwright backends.
+
+    This class creates and manages either a Selenium WebDriver or Playwright driver
+    based on the backend_type parameter. It provides a unified interface via
+    HasDriverProtocol for both implementations.
+
+    Attributes:
+        driver_impl: The HasDriverProtocol implementation (HasDriver or HasPlaywrightDriver)
+        config: Configuration dictionary for serialization
+        backend_type: Which backend is being used ("selenium" or "playwright")
+    """
+
+    driver_impl: HasDriverProtocol[Any]
+    config: dict[str, Any]
+    backend_type: Literal["selenium", "playwright"]
 
     def __init__(
         self,
-        browser=DEFAULT_SELENIUM_BROWSER,
-        remote=DEFAULT_SELENIUM_REMOTE,
-        remote_host=DEFAULT_SELENIUM_REMOTE_HOST,
-        remote_port=DEFAULT_SELENIUM_REMOTE_PORT,
-        headless=False,
+        timeout_handler: TimeoutCallback,
+        browser: str = DEFAULT_SELENIUM_BROWSER,
+        remote: bool = DEFAULT_SELENIUM_REMOTE,
+        remote_host: str = DEFAULT_SELENIUM_REMOTE_HOST,
+        remote_port: str = DEFAULT_SELENIUM_REMOTE_PORT,
+        headless: bool = False,
+        backend_type: Literal["selenium", "playwright"] = DEFAULT_BACKEND_TYPE,
     ):
+        """
+        Initialize a configured driver with the specified backend.
+
+        Args:
+            timeout_handler: Callback function that returns timeout value for wait operations
+            browser: Browser name ("auto", "CHROME", "FIREFOX", etc.)
+            remote: Whether to use remote Selenium Grid (Selenium only)
+            remote_host: Remote Selenium Grid host
+            remote_port: Remote Selenium Grid port
+            headless: Whether to run browser in headless mode
+            backend_type: Which backend to use ("selenium" or "playwright")
+
+        Raises:
+            Exception: If Playwright backend is requested with remote=True
+            Exception: If Playwright is not installed when backend_type="playwright"
+        """
+        self.backend_type = backend_type
         self.config = dict(
             browser=browser,
             remote=remote,
             remote_host=remote_host,
             remote_port=remote_port,
             headless=headless,
+            backend_type=backend_type,
         )
-        if remote:
-            driver = get_remote_driver(
-                host=remote_host,
-                port=remote_port,
-                browser=browser,
-            )
-        else:
-            driver = get_local_driver(
+
+        # Validate Playwright limitations
+        if backend_type == "playwright" and remote:
+            raise Exception(PLAYWRIGHT_REMOTE_UNSUPPORTED_MESSAGE)
+
+        if backend_type == "selenium":
+            # Create Selenium driver
+            if remote:
+                driver = get_remote_driver(
+                    host=remote_host,
+                    port=remote_port,
+                    browser=browser,
+                )
+            else:
+                driver = get_local_driver(
+                    browser=browser,
+                    headless=headless,
+                )
+            # Need larger than default window size for workflow index page, paired list creator.
+            driver.set_window_size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT)
+            self.driver_impl = cast(HasDriverProtocol, _SeleniumDriverImpl(driver, timeout_handler))
+
+        elif backend_type == "playwright":
+            # Create Playwright driver
+            resources = get_playwright_driver(
                 browser=browser,
                 headless=headless,
             )
-        # Need larger than default window size for workflow index page, paired list creator.
-        driver.set_window_size(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT)
-        self.driver = driver
+            self.driver_impl = cast(HasDriverProtocol, _PlaywrightDriverImpl(resources, timeout_handler))
 
-    def to_dict(self):
-        return self.config
+        else:
+            raise ValueError(f"Invalid backend_type: {backend_type}. Must be 'selenium' or 'playwright'")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize configuration to dictionary."""
+        return self.config.copy()
 
     @staticmethod
-    def from_dict(as_dict):
-        return ConfiguredDriver(**as_dict)
+    def from_dict(timeout_handler: TimeoutCallback, as_dict: dict[str, Any]) -> "ConfiguredDriver":
+        """Deserialize configuration from dictionary."""
+        return ConfiguredDriver(timeout_handler, **as_dict)
+
+    def quit(self) -> None:
+        """Clean up and close the driver."""
+        self.driver_impl.quit()
 
 
 def get_local_browser(browser):
@@ -109,6 +221,84 @@ def get_local_driver(browser=DEFAULT_BROWSER, headless=False) -> WebDriver:
         return driver_class(options=firefox_options)
 
 
+def get_playwright_browser_type(browser: str = DEFAULT_BROWSER) -> PlaywrightBrowserName:
+    """
+    Map Selenium browser names to Playwright browser types.
+
+    Args:
+        browser: Browser name (CHROME, FIREFOX, auto, etc.)
+
+    Returns:
+        Playwright browser type: 'chromium', 'firefox', or 'webkit'
+        This matches the BrowserType.name property values.
+
+    Raises:
+        NotImplementedError: If browser type has no direct Playwright mapping
+    """
+    if browser == "auto" or browser == "CHROME":
+        return "chromium"
+    elif browser == "FIREFOX":
+        return "firefox"
+    elif browser == "EDGE":
+        raise NotImplementedError(
+            f"Browser '{browser}' does not have a direct Playwright mapping. "
+            "EDGE uses Chromium under the hood - use 'CHROME' or 'auto' instead."
+        )
+    elif browser == "SAFARI":
+        raise NotImplementedError(
+            f"Browser '{browser}' does not have a direct Playwright mapping. "
+            "Safari uses WebKit - however, Playwright's 'webkit' is not identical to Safari. "
+            "If you need Safari-specific testing, use the Selenium backend instead."
+        )
+    else:
+        # Unknown browser type
+        raise NotImplementedError(
+            f"Browser '{browser}' is not supported with Playwright backend. "
+            f"Supported browsers: CHROME, FIREFOX, auto. Use backend_type='selenium' for other browsers."
+        )
+
+
+def get_playwright_driver(browser: str = DEFAULT_BROWSER, headless: bool = False) -> PlaywrightResources:
+    """
+    Create Playwright browser resources.
+
+    Args:
+        browser: Browser name to launch (CHROME, FIREFOX, auto, etc.)
+        headless: Whether to run in headless mode
+
+    Returns:
+        PlaywrightResources containing playwright, browser, and page instances
+
+    Raises:
+        Exception: If playwright is not installed
+    """
+    if sync_playwright is None:
+        raise Exception(PLAYWRIGHT_UNAVAILABLE_MESSAGE)
+
+    browser_type_name = get_playwright_browser_type(browser)
+    playwright = sync_playwright().start()
+
+    # Get the appropriate browser type
+    if browser_type_name == "firefox":
+        browser_type = playwright.firefox
+    elif browser_type_name == "webkit":
+        browser_type = playwright.webkit
+    else:
+        browser_type = playwright.chromium
+
+    # Launch browser with headless setting
+    browser_instance = browser_type.launch(headless=headless)
+
+    # Create page with viewport size matching Selenium's window size
+    page = browser_instance.new_page(viewport={"width": DEFAULT_WINDOW_WIDTH, "height": DEFAULT_WINDOW_HEIGHT})
+
+    return PlaywrightResources(
+        playwright=playwright,
+        browser=browser_instance,
+        page=page,
+    )
+
+
 def get_remote_driver(host, port, browser=DEFAULT_BROWSER) -> WebDriver:
     # docker run -d -p 4444:4444 -v /dev/shm:/dev/shm selenium/standalone-chrome:3.0.1-aluminum
     options: Union[webdriver.ChromeOptions, webdriver.FirefoxOptions, webdriver.EdgeOptions, SafariOptions]
@@ -166,6 +356,8 @@ def _which(file):
     "ConfiguredDriver",
     "get_local_driver",
     "get_remote_driver",
+    "get_playwright_browser_type",
     "is_virtual_display_available",
     "virtual_display_if_enabled",
+    "PlaywrightBrowserName",
 )
diff --git a/lib/galaxy/selenium/has_driver.py b/lib/galaxy/selenium/has_driver.py
index 4f73891ff560..66658bcbfb97 100644
--- a/lib/galaxy/selenium/has_driver.py
+++ b/lib/galaxy/selenium/has_driver.py
@@ -6,7 +6,12 @@
 
 import abc
 import threading
+from contextlib import contextmanager
 from typing import (
+    Any,
+    cast,
+    Generic,
+    Literal,
     Optional,
     Union,
 )
@@ -22,7 +27,9 @@
 from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support import expected_conditions as ec
+from selenium.webdriver.support.ui import Select
 from selenium.webdriver.support.wait import WebDriverWait
+from seletools.actions import drag_and_drop as seletools_drag_and_drop
 
 from galaxy.navigation.components import Target
 from galaxy.util import requests
@@ -31,6 +38,14 @@
     NullAxeResults,
     RealAxeResults,
 )
+from .has_driver_protocol import (
+    Cookie,
+    HasElementLocator,
+    TimeoutCallback,
+    WaitTypeT,
+)
+from .wait_methods_mixin import WaitMethodsMixin
+from .web_element_protocol import WebElementProtocol
 
 UNSPECIFIED_TIMEOUT = object()
 
@@ -49,13 +64,115 @@ def get_axe_script(script_url: str) -> str:
     return AXE_SCRIPT_HASH[script_url]
 
 
-class HasDriver:
+def _webelement_to_protocol(element: WebElement) -> WebElementProtocol:
+    """
+    Convert Selenium WebElement to WebElementProtocol type.
+
+    Selenium's WebElement satisfies WebElementProtocol at runtime, but mypy
+    doesn't recognize this because:
+    1. WebElement.find_element() has parameters typed as (by: Any, value: Any)
+       while our protocol requires (by: str, value: str | None)
+    2. WebElement.find_element() returns WebElement instead of WebElementProtocol
+
+    Since WebElement actually implements all required protocol methods correctly
+    at runtime, this cast is safe.
+    """
+    return cast(WebElementProtocol, element)
+
+
+def _webelements_to_protocol(elements: list[WebElement]) -> list[WebElementProtocol]:
+    """
+    Convert list of Selenium WebElements to list of WebElementProtocol.
+
+    See _webelement_to_protocol for why this type conversion is necessary.
+    """
+    return [cast(WebElementProtocol, element) for element in elements]
+
+
+def _protocol_to_webelement(element: WebElementProtocol) -> WebElement:
+    """See notes above for why these cannot be directly typed."""
+    return cast(WebElement, element)
+
+
+def _cookies_to_typed(cookies: list[dict]) -> list[Cookie]:
+    """
+    Convert Selenium's list[dict] cookies to list[Cookie].
+
+    Selenium's get_cookies() returns list[dict[Any, Any]], but the actual
+    dictionaries at runtime contain the correct Cookie keys. We use a TypedDict
+    to provide better type safety for cookie access. This cast is safe because
+    Selenium's cookie dictionaries contain all the keys defined in Cookie.
+    """
+    return cookies  # type: ignore[return-value]
+
+
+class TimeoutMessageMixin:
+    """Mixin providing timeout message formatting for driver abstractions."""
+
+    def _timeout_message(self, on_str: str) -> str:
+        """
+        Generate a timeout error message.
+
+        Args:
+            on_str: Description of what was being waited on
+
+        Returns:
+            Formatted timeout message string
+        """
+        return f"Timeout waiting on {on_str}."
+
+
+class HasDriver(TimeoutMessageMixin, WaitMethodsMixin, Generic[WaitTypeT]):
     by: type[By] = By
     keys: type[Keys] = Keys
     driver: WebDriver
     axe_script_url: str = DEFAULT_AXE_SCRIPT_URL
     axe_skip: bool = False
 
+    @property
+    def backend_type(self) -> Literal["selenium", "playwright"]:
+        """Identify this as the Selenium backend implementation."""
+        return "selenium"
+
+    @property
+    def current_url(self) -> str:
+        """
+        Get the current page URL.
+
+        Returns:
+            The current URL
+        """
+        return self.driver.current_url
+
+    @property
+    def page_source(self) -> str:
+        """
+        Get the HTML source of the current page.
+
+        Returns:
+            The page HTML as a string
+        """
+        return self.driver.page_source
+
+    @property
+    def page_title(self) -> str:
+        """
+        Get the title of the current page.
+
+        Returns:
+            The page title as a string
+        """
+        return self.driver.title
+
+    def navigate_to(self, url: str) -> None:
+        """
+        Navigate to a URL.
+
+        Args:
+            url: The URL to navigate to
+        """
+        self.driver.get(url)
+
     def re_get_with_query_params(self, params_str: str):
         driver = self.driver
         new_url = driver.current_url
@@ -97,8 +214,23 @@ def is_displayed(self, selector_template: Target) -> bool:
     def assert_selector_absent(self, selector: str):
         assert len(self.driver.find_elements(By.CSS_SELECTOR, selector)) == 0
 
-    def find_elements(self, selector_template: Target) -> list[WebElement]:
-        return self.driver.find_elements(*selector_template.element_locator)
+    def find_elements(self, selector_template: Target) -> list[WebElementProtocol]:
+        return _webelements_to_protocol(self.driver.find_elements(*selector_template.element_locator))
+
+    def find_element(self, selector_template: HasElementLocator) -> WebElementProtocol:
+        """
+        Find first element matching selector template (no waiting).
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple
+        """
+        # Dispatch on input type
+        if isinstance(selector_template, Target):
+            locator = selector_template.element_locator
+        else:
+            # It's a tuple (locator_type, value)
+            locator = selector_template
+        return _webelement_to_protocol(self.driver.find_element(*locator))
 
     def assert_absent(self, selector_template: Target) -> None:
         elements = self.find_elements(selector_template)
@@ -113,120 +245,87 @@ def assert_absent(self, selector_template: Target) -> None:
     def element_absent(self, selector_template: Target) -> bool:
         return len(self.find_elements(selector_template)) == 0
 
-    def switch_to_frame(self, name: str = "frame"):
-        return self._wait_on(ec.frame_to_be_available_and_switch_to_it((By.NAME, name)))
-
-    def wait_for_xpath(self, xpath: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.presence_of_element_located((By.XPATH, xpath)), f"XPATH selector [{xpath}] to become present", **kwds
-        )
-        return element
-
-    def wait_for_xpath_visible(self, xpath: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.visibility_of_element_located((By.XPATH, xpath)), f"XPATH selector [{xpath}] to become visible", **kwds
-        )
-        return element
-
-    def wait_for_selector(self, selector: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.presence_of_element_located((By.CSS_SELECTOR, selector)),
-            f"CSS selector [{selector}] to become present",
-            **kwds,
-        )
-        return element
-
-    def wait_for_present(self, selector_template: Target, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.presence_of_element_located(selector_template.element_locator),
-            f"{selector_template.description} to become present",
-            **kwds,
-        )
-        return element
-
-    def wait_for_visible(self, selector_template: Target, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.visibility_of_element_located(selector_template.element_locator),
-            f"{selector_template.description} to become visible",
-            **kwds,
-        )
-        return element
-
-    def wait_for_selector_visible(self, selector: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.visibility_of_element_located((By.CSS_SELECTOR, selector)),
-            f"CSS selector [{selector}] to become visible",
-            **kwds,
-        )
-        return element
-
-    def wait_for_selector_clickable(self, selector: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.element_to_be_clickable((By.CSS_SELECTOR, selector)),
-            f"CSS selector [{selector}] to become clickable",
-            **kwds,
-        )
-        return element
-
-    def wait_for_clickable(self, selector_template: Target, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.element_to_be_clickable(selector_template.element_locator),
-            f"{selector_template.description} to become clickable",
-            **kwds,
-        )
-        return element
-
-    def wait_for_selector_absent_or_hidden(self, selector: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.invisibility_of_element_located((By.CSS_SELECTOR, selector)),
-            f"CSS selector [{selector}] to become absent or hidden",
-            **kwds,
-        )
-        return element
-
-    def wait_for_selector_absent(self, selector: str, **kwds) -> WebElement:
-        element = self._wait_on(
-            lambda driver: len(driver.find_elements(By.CSS_SELECTOR, selector)) == 0,
-            f"CSS selector [{selector}] to become absent",
-            **kwds,
-        )
-        return element
-
-    def wait_for_element_count_of_at_least(self, selector_template: Target, n: int, **kwds) -> WebElement:
-        element = self._wait_on(
-            lambda driver: len(driver.find_elements(*selector_template.element_locator)) >= n,
-            f"{selector_template.description} to become visible",
-            **kwds,
-        )
-        return element
-
-    def wait_for_absent(self, selector_template: Target, **kwds) -> WebElement:
-        element = self._wait_on(
-            lambda driver: len(driver.find_elements(*selector_template.element_locator)) == 0,
-            f"{selector_template.description} to become absent",
-            **kwds,
+    def switch_to_frame(self, frame_reference: Union[str, int, WebElement] = "frame"):
+        """
+        Switch to an iframe or frame.
+
+        Args:
+            frame_reference: Can be:
+                - str: frame name or id (will wait for frame to be available)
+                - int: frame index
+                - WebElement: frame element
+
+        Returns:
+            The result of the switch operation
+        """
+        if isinstance(frame_reference, str):
+            # Try to switch by name first, if that fails, try by ID
+            # We use NAME as the locator because frame_to_be_available_and_switch_to_it
+            # checks both name and id attributes
+            return self._wait_on_selenium_condition(ec.frame_to_be_available_and_switch_to_it(frame_reference))
+        elif isinstance(frame_reference, int):
+            # Switch by index
+            return self.driver.switch_to.frame(frame_reference)
+        else:
+            # Assume it's a WebElement
+            return self.driver.switch_to.frame(frame_reference)
+
+    def switch_to_default_content(self):
+        """
+        Switch back to the default content (main page context).
+
+        This exits any iframe/frame context and returns to the top-level page.
+        """
+        self.driver.switch_to.default_content()
+
+    def get_cookies(self) -> list[Cookie]:
+        """
+        Get all cookies for the current domain.
+
+        Returns:
+            List of cookie dictionaries with keys like 'name', 'value', 'domain', 'path', etc.
+        """
+        return _cookies_to_typed(self.driver.get_cookies())
+
+    # Implementation of WaitMethodsMixin abstract methods for Selenium
+    def _wait_on_condition_present(self, locator_tuple: tuple, message: str, **kwds) -> WebElement:
+        """Wait for element to be present in DOM."""
+        return self._wait_on_selenium_condition(ec.presence_of_element_located(locator_tuple), message, **kwds)
+
+    def _wait_on_condition_visible(self, locator_tuple: tuple, message: str, **kwds) -> WebElement:
+        """Wait for element to be visible."""
+        return self._wait_on_selenium_condition(ec.visibility_of_element_located(locator_tuple), message, **kwds)
+
+    def _wait_on_condition_clickable(self, locator_tuple: tuple, message: str, **kwds) -> WebElement:
+        """Wait for element to be clickable."""
+        return self._wait_on_selenium_condition(ec.element_to_be_clickable(locator_tuple), message, **kwds)
+
+    def _wait_on_condition_invisible(self, locator_tuple: tuple, message: str, **kwds) -> WebElement:
+        """Wait for element to be invisible or absent."""
+        return self._wait_on_selenium_condition(ec.invisibility_of_element_located(locator_tuple), message, **kwds)
+
+    def _wait_on_condition_absent(self, locator_tuple: tuple, message: str, **kwds) -> WebElement:
+        """Wait for element to be completely absent from DOM."""
+        return self._wait_on_selenium_condition(
+            lambda driver: len(driver.find_elements(*locator_tuple)) == 0, message, **kwds
         )
-        return element
 
-    def wait_for_absent_or_hidden(self, selector_template: Target, **kwds) -> WebElement:
-        element = self._wait_on(
-            ec.invisibility_of_element_located(selector_template.element_locator),
-            f"{selector_template.description} to become absent or hidden",
-            **kwds,
+    def _wait_on_condition_count(self, locator_tuple: tuple, n: int, message: str, **kwds) -> WebElement:
+        """Wait for at least N elements."""
+        return self._wait_on_selenium_condition(
+            lambda driver: len(driver.find_elements(*locator_tuple)) >= n, message, **kwds
         )
-        return element
 
-    def wait_for_id(self, id: str, **kwds) -> WebElement:
-        return self._wait_on(ec.presence_of_element_located((By.ID, id)), f"presence of DOM ID [{id}]", **kwds)
+    # TODO: typevar...
+    def _wait_on_custom(self, condition_func, message: str, **kwds) -> Any:
+        """Wait on custom condition function."""
+        return self._wait_on_selenium_condition(condition_func, message, **kwds)
 
     def click(self, selector_template: Target):
         element = self.driver.find_element(*selector_template.element_locator)
         element.click()
 
-    def _timeout_message(self, on_str: str) -> str:
-        return f"Timeout waiting on {on_str}."
-
-    def _wait_on(self, condition, on_str: Optional[str] = None, **kwds):
+    def _wait_on_selenium_condition(self, condition, on_str: Optional[str] = None, **kwds):
         if on_str is None:
             on_str = str(condition)
         wait = self.wait(**kwds)
@@ -235,6 +334,38 @@ def _wait_on(self, condition, on_str: Optional[str] = None, **kwds):
     def action_chains(self):
         return ActionChains(self.driver)
 
+    def drag_and_drop(self, source: WebElementProtocol, target: WebElementProtocol) -> None:
+        """
+        Drag and drop from source element to target element.
+
+        Uses JavaScript-based drag and drop implementation for reliability.
+
+        Args:
+            source: The element to drag
+            target: The element to drop onto
+        """
+        seletools_drag_and_drop(self.driver, source, target)
+
+    def move_to_and_click(self, element: WebElementProtocol) -> None:
+        """
+        Move to an element and click it using ActionChains.
+
+        This is useful when a simple click doesn't work due to element positioning.
+
+        Args:
+            element: The element to move to and click
+        """
+        self.action_chains().move_to_element(element).click().perform()
+
+    def hover(self, element: WebElement) -> None:
+        """
+        Hover over an element (move mouse to element without clicking).
+
+        Args:
+            element: The element to hover over
+        """
+        self.action_chains().move_to_element(element).perform()
+
     def send_enter(self, element: Optional[WebElement] = None):
         self._send_key(Keys.ENTER, element)
 
@@ -256,12 +387,15 @@ def _send_key(self, key: str, element: Optional[WebElement] = None):
         else:
             element.send_keys(key)
 
+    @property
     @abc.abstractmethod
-    def timeout_for(self, **kwds) -> float: ...
+    def timeout_handler(self) -> TimeoutCallback:
+        """Get timeout handler for application specific wait types."""
+        ...
 
-    def wait(self, timeout=UNSPECIFIED_TIMEOUT, **kwds):
+    def wait(self, timeout=UNSPECIFIED_TIMEOUT, wait_type: Optional[WaitTypeT] = None, **kwds):
         if timeout is UNSPECIFIED_TIMEOUT:
-            timeout = self.timeout_for(**kwds)
+            timeout = self.timeout_handler(wait_type)
         return WebDriverWait(self.driver, timeout)
 
     def click_xpath(self, xpath: str):
@@ -301,23 +435,151 @@ def prepend_timeout_message(
         )
 
     def accept_alert(self):
-        try:
-            alert = self.driver.switch_to.alert
-            alert.accept()
-        finally:
-            self.driver.switch_to.default_content()
-
-    def find_element_by_link_text(self, text: str, element: Optional[WebElement] = None) -> WebElement:
-        return self._locator_aware(element).find_element(By.LINK_TEXT, text)
+        """
+        Return a context manager for accepting alerts.
 
-    def find_element_by_xpath(self, xpath: str, element: Optional[WebElement] = None) -> WebElement:
-        return self._locator_aware(element).find_element(By.XPATH, xpath)
+        For Selenium, the alert must exist before it can be accepted,
+        so we wait until the context exits to accept it.
 
-    def find_element_by_id(self, id: str, element: Optional[WebElement] = None) -> WebElement:
-        return self._locator_aware(element).find_element(By.ID, id)
+        Usage:
+            with driver.accept_alert():
+                driver.click_selector("#button-that-shows-alert")
+            # Alert is automatically accepted here
+        """
 
-    def find_element_by_selector(self, selector: str, element: Optional[WebElement] = None) -> WebElement:
-        return self._locator_aware(element).find_element(By.CSS_SELECTOR, selector)
+        @contextmanager
+        def _accept_alert_context():
+            try:
+                yield
+            finally:
+                # Accept the alert after the context block completes
+                try:
+                    alert = self.driver.switch_to.alert
+                    alert.accept()
+                finally:
+                    self.driver.switch_to.default_content()
+
+        return _accept_alert_context()
+
+    def execute_script(self, script: str, *args):
+        """
+        Execute JavaScript in the current browser context.
+
+        Args:
+            script: JavaScript code to execute
+            *args: Optional arguments to pass to the script (accessible as arguments[0], arguments[1], etc.)
+
+        Returns:
+            The return value of the script execution
+        """
+        return self.driver.execute_script(script, *args)
+
+    def set_local_storage(self, key: str, value: Union[str, float]) -> None:
+        """
+        Set a value in the browser's localStorage.
+
+        Args:
+            key: The localStorage key
+            value: The value to store (will be JSON-stringified if not a string)
+        """
+        self.execute_script(f"""window.localStorage.setItem("{key}", {value});""")
+
+    def remove_local_storage(self, key: str) -> None:
+        """
+        Remove a key from the browser's localStorage.
+
+        Args:
+            key: The localStorage key to remove
+        """
+        self.execute_script(f"""window.localStorage.removeItem("{key}");""")
+
+    def scroll_into_view(self, element: WebElement) -> None:
+        """
+        Scroll an element into view using JavaScript.
+
+        Args:
+            element: The element to scroll into view
+        """
+        self.execute_script("arguments[0].scrollIntoView(true);", element)
+
+    def set_element_value(self, element: WebElement, value: str) -> None:
+        """
+        Set an element's value property directly using JavaScript.
+
+        This is useful for contenteditable elements or when .clear() doesn't work.
+
+        Args:
+            element: The element to modify
+            value: The value to set
+        """
+        self.execute_script(f"arguments[0].value = '{value}';", element)
+
+    def execute_script_click(self, element: WebElement) -> None:
+        """
+        Click an element using JavaScript instead of Selenium's native click.
+
+        This is useful when Selenium's click is intercepted or the element is not clickable.
+
+        Args:
+            element: The element to click
+        """
+        self.execute_script("arguments[0].click();", element)
+
+    def find_element_by_link_text(self, text: str, element: Optional[WebElement] = None) -> WebElementProtocol:
+        return _webelement_to_protocol(self._locator_aware(element).find_element(By.LINK_TEXT, text))
+
+    def find_element_by_xpath(self, xpath: str, element: Optional[WebElement] = None) -> WebElementProtocol:
+        return _webelement_to_protocol(self._locator_aware(element).find_element(By.XPATH, xpath))
+
+    def find_element_by_id(self, id: str, element: Optional[WebElement] = None) -> WebElementProtocol:
+        return _webelement_to_protocol(self._locator_aware(element).find_element(By.ID, id))
+
+    def find_element_by_selector(self, selector: str, element: Optional[WebElement] = None) -> WebElementProtocol:
+        return _webelement_to_protocol(self._locator_aware(element).find_element(By.CSS_SELECTOR, selector))
+
+    def find_elements_by_selector(
+        self, selector: str, element: Optional[WebElement] = None
+    ) -> list[WebElementProtocol]:
+        """
+        Find multiple elements by CSS selector.
+
+        Args:
+            selector: CSS selector string
+            element: Optional parent element to search within
+
+        Returns:
+            List of WebElementProtocol elements
+        """
+        elements = self._locator_aware(element).find_elements(By.CSS_SELECTOR, selector)
+        return [_webelement_to_protocol(el) for el in elements]
+
+    def get_input_value(self, element: WebElementProtocol) -> str:
+        """
+        Get the value of an input element.
+
+        This provides a unified interface for getting input values across both
+        Selenium and Playwright backends. For Selenium, this uses get_attribute("value").
+
+        Args:
+            element: The input element to get the value from
+
+        Returns:
+            The current value of the input element, or empty string if no value
+        """
+        value = element.get_attribute("value")
+        return value if value is not None else ""
+
+    def select_by_value(self, selector_template: HasElementLocator, value: str) -> None:
+        """
+        Select an option from a <select> element by its value attribute.
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple for the select element
+            value: The value attribute of the option to select
+        """
+        select_element = _protocol_to_webelement(self.find_element(selector_template))
+        select = Select(select_element)
+        select.select_by_value(value)
 
     def axe_eval(self, context: Optional[str] = None, write_to: Optional[str] = None) -> AxeResults:
         if self.axe_skip:
@@ -331,19 +593,76 @@ def axe_eval(self, context: Optional[str] = None, write_to: Optional[str] = None
             axe.write_results(results, write_to)
         return RealAxeResults(results)
 
+    def save_screenshot(self, path: str) -> None:
+        """
+        Save a screenshot to the specified path.
+
+        Args:
+            path: File path where the screenshot should be saved
+        """
+        self.driver.save_screenshot(path)
+
+    def get_screenshot_as_png(self) -> bytes:
+        """
+        Capture a screenshot and return it as PNG bytes.
+
+        Returns:
+            PNG image data as bytes
+        """
+        return self.driver.get_screenshot_as_png()
+
+    def close(self) -> None:
+        """Cleanup the current browser tab/page."""
+        self.driver.close()
+
+    def quit(self) -> None:
+        """
+        Clean up and close the driver/browser.
+
+        This closes all windows/tabs and releases all system resources.
+        The driver cannot be used after calling this method.
+        """
+        self.driver.quit()
+
     def _locator_aware(self, element: Optional[WebElement] = None) -> HasFindElement:
         if element is None:
             return self.driver
         else:
             return element
 
+    def double_click(self, element: WebElement) -> None:
+        """
+        Double-click an element using ActionChains.
+
+        Args:
+            element: The element to double-click
+        """
+        action_chains = self.action_chains()
+        action_chains.move_to_element(element).double_click().perform()
+
+    def assert_absent_or_hidden_after_transitions(self, selector_template: Target, **kwds) -> None:
+        """
+        Assert element is absent or hidden (convenience method for subclasses to override with retry logic).
+
+        This is a basic implementation that calls assert_absent_or_hidden.
+        Subclasses may decorate or override this method with retry logic for handling
+        transitions where elements may become stale.
+
+        Args:
+            selector_template: Target selector for the element
+            **kwds: Additional keyword arguments
+        """
+        return self.assert_absent_or_hidden(selector_template, **kwds)
+
 
 def exception_indicates_click_intercepted(exception):
     return "click intercepted" in str(exception)
 
 
 def exception_indicates_not_clickable(exception):
-    return "not clickable" in str(exception)
+    selenium_not_clickable = "not clickable" in str(exception)
+    playwright_not_enabled = "element is not enabled" in str(exception)
+    return selenium_not_clickable or playwright_not_enabled
 
 
 def exception_indicates_stale_element(exception):
@@ -356,4 +675,5 @@ def exception_indicates_stale_element(exception):
     "exception_indicates_stale_element",
     "HasDriver",
     "SeleniumTimeoutException",
+    "TimeoutMessageMixin",
 )
diff --git a/lib/galaxy/selenium/has_driver_protocol.py b/lib/galaxy/selenium/has_driver_protocol.py
new file mode 100644
index 000000000000..bbe93bc85b5c
--- /dev/null
+++ b/lib/galaxy/selenium/has_driver_protocol.py
@@ -0,0 +1,552 @@
+"""Protocol defining the common interface for HasDriver and HasPlaywrightDriver.
+
+This Protocol captures the ~60+ methods that both implementations provide,
+allowing NavigatesGalaxy to work with either backend via composition.
+"""
+
+from abc import abstractmethod
+from typing import (
+    Any,
+    Callable,
+    ContextManager,
+    Generic,
+    Literal,
+    Optional,
+    Protocol,
+    TypedDict,
+    TypeVar,
+    Union,
+)
+
+from galaxy.navigation.components import Target
+from .axe_results import AxeResults
+from .web_element_protocol import WebElementProtocol
+
+# Type for element locators - can be either a Target or a Selenium-style (locator_type, value) tuple
+ElementLocatorTuple = tuple[str, str]  # e.g., ("css selector", "#id") or ("id", "test")
+HasElementLocator = Union[Target, ElementLocatorTuple]
+
+
+class Cookie(TypedDict, total=False):
+    """Cookie dictionary structure compatible with both Selenium and Playwright."""
+
+    name: str
+    value: str
+    domain: str
+    path: str
+    expires: float
+    httpOnly: bool
+    secure: bool
+    sameSite: Literal["Lax", "None", "Strict"]
+
+
+BackendType = Literal["selenium", "playwright"]
+WaitTypeT = TypeVar("WaitTypeT", contravariant=True)
+TimeoutCallback = Callable[[Optional[WaitTypeT]], float]
+
+
+def fixed_timeout_handler(timeout: float) -> TimeoutCallback:
+    """Return a fixed timeout callback for simple timeout_handler impls."""
+
+    def callback(wait_type=None) -> float:
+        return timeout
+
+    return callback
+
+
+class HasDriverProtocol(Protocol, Generic[WaitTypeT]):
+    """
+    Protocol defining the driver abstraction interface.
+
+    Both HasDriver (Selenium) and HasPlaywrightDriver (Playwright) implement
+    this protocol, allowing NavigatesGalaxy to work with either backend.
+
+    This protocol includes:
+    - Backend identification (backend_type)
+    - Navigation methods (navigate_to, re_get_with_query_params, current_url)
+    - Element finding (find_element_by_*, find_elements*)
+    - Wait methods (wait_for_*, wait_for_*_visible, etc.)
+    - Interaction methods (click_*, hover, drag_and_drop, etc.)
+    - Assertion methods (assert_*, selector_is_displayed, etc.)
+    - JavaScript execution (execute_script, set_element_value, etc.)
+    - Frame switching (switch_to_frame, switch_to_default_content)
+    - Storage & cookies (set_local_storage, get_cookies, etc.)
+    - Accessibility (axe_eval)
+    """
+
+    # Backend identification
+    @property
+    @abstractmethod
+    def backend_type(self) -> BackendType:
+        """Identify which backend implementation this is."""
+        ...
+
+    # Core timeout management
+    @property
+    @abstractmethod
+    def timeout_handler(self) -> TimeoutCallback:
+        """Get timeout handler for application specific wait types."""
+        ...
+
+    @abstractmethod
+    def wait(self, timeout=..., wait_type: Optional[WaitTypeT] = None, **kwds):
+        """Create a wait object with the specified timeout."""
+        ...
+
+    # Navigation
+    @property
+    @abstractmethod
+    def current_url(self) -> str:
+        """Get the current page URL."""
+        ...
+
+    @property
+    @abstractmethod
+    def page_source(self) -> str:
+        """Get the HTML source of the current page."""
+        ...
+
+    @property
+    @abstractmethod
+    def page_title(self) -> str:
+        """Get the title of the current page."""
+        ...
+
+    @abstractmethod
+    def navigate_to(self, url: str) -> None:
+        """Navigate to the specified URL."""
+        ...
+
+    @abstractmethod
+    def re_get_with_query_params(self, params_str: str):
+        """Navigate to current URL with additional query parameters."""
+        ...
+
+    # Element finding - by locator type
+    @abstractmethod
+    def find_element_by_id(self, id: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find element by ID attribute."""
+        ...
+
+    @abstractmethod
+    def find_element_by_selector(self, selector: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find element by CSS selector."""
+        ...
+
+    @abstractmethod
+    def find_element_by_xpath(self, xpath: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find element by XPath expression."""
+        ...
+
+    @abstractmethod
+    def find_element_by_link_text(self, text: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find link element by visible text."""
+        ...
+
+    @abstractmethod
+    def find_elements_by_selector(self, selector: str, element: Optional[Any] = None) -> list[WebElementProtocol]:
+        """Find all elements matching CSS selector."""
+        ...
+
+    @abstractmethod
+    def find_elements(self, selector_template: Target) -> list[WebElementProtocol]:
+        """Find all elements matching the Target selector template."""
+        ...
+
+    @abstractmethod
+    def find_element(self, selector_template: HasElementLocator) -> WebElementProtocol:
+        """
+        Find first element matching the selector template (no waiting).
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple
+        """
+        ...
+
+    # Wait methods - presence
+    @abstractmethod
+    def wait_for_xpath(self, xpath: str, **kwds) -> Any:
+        """Wait for element matching XPath to be present in DOM."""
+        ...
+
+    @abstractmethod
+    def wait_for_selector(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be present in DOM."""
+        ...
+
+    @abstractmethod
+    def wait_for_present(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be present in DOM."""
+        ...
+
+    @abstractmethod
+    def wait_for_id(self, id: str, **kwds) -> Any:
+        """Wait for element with ID to be present in DOM."""
+        ...
+
+    # Wait methods - visibility
+    @abstractmethod
+    def wait_for_xpath_visible(self, xpath: str, **kwds) -> Any:
+        """Wait for element matching XPath to be visible."""
+        ...
+
+    @abstractmethod
+    def wait_for_selector_visible(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be visible."""
+        ...
+
+    @abstractmethod
+    def wait_for_visible(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be visible."""
+        ...
+
+    # Wait methods - clickable
+    @abstractmethod
+    def wait_for_selector_clickable(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be clickable."""
+        ...
+
+    @abstractmethod
+    def wait_for_clickable(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be clickable."""
+        ...
+
+    # Wait methods - absence/hidden
+    @abstractmethod
+    def wait_for_selector_absent(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be absent from DOM."""
+        ...
+
+    @abstractmethod
+    def wait_for_absent(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be absent from DOM."""
+        ...
+
+    @abstractmethod
+    def wait_for_selector_absent_or_hidden(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be absent or hidden."""
+        ...
+
+    @abstractmethod
+    def wait_for_absent_or_hidden(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be absent or hidden."""
+        ...
+
+    # Wait methods - count
+    @abstractmethod
+    def wait_for_element_count_of_at_least(self, selector_template: Target, n: int, **kwds) -> Any:
+        """Wait for at least n elements matching Target to be present."""
+        ...
+
+    # Wait and interact
+    @abstractmethod
+    def wait_for_and_click(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be clickable and click it."""
+        ...
+
+    @abstractmethod
+    def wait_for_and_double_click(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be clickable and double-click it."""
+        ...
+
+    @abstractmethod
+    def _wait_on_custom(self, condition_func, message: str, **kwds) -> Any:
+        """Wait on custom condition function."""
+        ...
+
+    # Visibility checks
+    @abstractmethod
+    def selector_is_displayed(self, selector: str) -> bool:
+        """Check if element matching CSS selector is displayed."""
+        ...
+
+    @abstractmethod
+    def is_displayed(self, selector_template: Target) -> bool:
+        """Check if element matching Target is displayed."""
+        ...
+
+    @abstractmethod
+    def element_absent(self, selector_template: Target) -> bool:
+        """Check if element matching Target is absent from DOM."""
+        ...
+
+    # Assertions
+    @abstractmethod
+    def assert_xpath(self, xpath: str):
+        """Assert element matching XPath is present."""
+        ...
+
+    @abstractmethod
+    def assert_selector(self, selector: str):
+        """Assert element matching CSS selector is present."""
+        ...
+
+    @abstractmethod
+    def assert_selector_absent(self, selector: str):
+        """Assert element matching CSS selector is absent."""
+        ...
+
+    @abstractmethod
+    def assert_selector_absent_or_hidden(self, selector: str):
+        """Assert element matching CSS selector is absent or hidden."""
+        ...
+
+    @abstractmethod
+    def assert_absent(self, selector_template: Target) -> None:
+        """Assert element matching Target is absent."""
+        ...
+
+    @abstractmethod
+    def assert_absent_or_hidden(self, selector_template: Target):
+        """Assert element matching Target is absent or hidden."""
+        ...
+
+    @abstractmethod
+    def assert_disabled(self, selector_template: Target):
+        """Assert element matching Target is disabled."""
+        ...
+
+    @abstractmethod
+    def assert_absent_or_hidden_after_transitions(self, selector_template: Target, **kwds) -> None:
+        """Assert element is absent or hidden, retrying during transitions."""
+        ...
+
+    # Click methods
+    @abstractmethod
+    def click(self, selector_template: Target):
+        """Click element matching Target."""
+        ...
+
+    @abstractmethod
+    def click_xpath(self, xpath: str):
+        """Click element matching XPath."""
+        ...
+
+    @abstractmethod
+    def click_selector(self, selector: str):
+        """Click element matching CSS selector."""
+        ...
+
+    @abstractmethod
+    def click_label(self, text: str):
+        """Click link with visible text."""
+        ...
+
+    # Mouse interactions
+    @abstractmethod
+    def hover(self, element: WebElementProtocol) -> None:
+        """Hover mouse over element."""
+        ...
+
+    @abstractmethod
+    def move_to_and_click(self, element: WebElementProtocol) -> None:
+        """Move mouse to element and click."""
+        ...
+
+    @abstractmethod
+    def drag_and_drop(self, source: WebElementProtocol, target: WebElementProtocol) -> None:
+        """Drag source element and drop on target element."""
+        ...
+
+    @abstractmethod
+    def double_click(self, element: WebElementProtocol) -> None:
+        """Double-click element."""
+        ...
+
+    @abstractmethod
+    def action_chains(self):
+        """Get action chains object for complex interactions."""
+        ...
+
+    # Keyboard interactions
+    @abstractmethod
+    def send_enter(self, element: Optional[WebElementProtocol] = None):
+        """Send ENTER key to element or active element."""
+        ...
+
+    @abstractmethod
+    def send_escape(self, element: Optional[WebElementProtocol] = None):
+        """Send ESCAPE key to element or active element."""
+        ...
+
+    @abstractmethod
+    def send_backspace(self, element: Optional[WebElementProtocol] = None):
+        """Send BACKSPACE key to element or active element."""
+        ...
+
+    @abstractmethod
+    def aggressive_clear(self, element: WebElementProtocol) -> None:
+        """Clear input element value using JavaScript and backspaces (for when .clear() doesn't work)."""
+        ...
+
+    # Form interactions
+    @abstractmethod
+    def fill(self, form: WebElementProtocol, info: dict):
+        """Fill form with provided data."""
+        ...
+
+    @abstractmethod
+    def click_submit(self, form: WebElementProtocol):
+        """Click submit button in form."""
+        ...
+
+    @abstractmethod
+    def get_input_value(self, element: WebElementProtocol) -> str:
+        """
+        Get the value of an input element.
+
+        This provides a unified interface for getting input values across both
+        Selenium and Playwright backends.
+
+        Args:
+            element: The input element to get the value from
+
+        Returns:
+            The current value of the input element, or empty string if no value
+        """
+        ...
+
+    @abstractmethod
+    def select_by_value(self, selector_template: HasElementLocator, value: str) -> None:
+        """
+        Select an option from a <select> element by its value attribute.
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple for the select element
+            value: The value attribute of the option to select
+        """
+        ...
+
+    # Frame switching
+    @abstractmethod
+    def switch_to_frame(self, frame_reference: Union[str, int, Any] = "frame"):
+        """Switch to iframe by name, id, index, or element."""
+        ...
+
+    @abstractmethod
+    def switch_to_default_content(self):
+        """Switch back to main page content from iframe."""
+        ...
+
+    # JavaScript execution
+    @abstractmethod
+    def execute_script(self, script: str, *args):
+        """Execute JavaScript in the browser."""
+        ...
+
+    @abstractmethod
+    def execute_script_click(self, element: WebElementProtocol) -> None:
+        """Click element using JavaScript."""
+        ...
+
+    @abstractmethod
+    def set_element_value(self, element: WebElementProtocol, value: str) -> None:
+        """Set input element value using JavaScript."""
+        ...
+
+    @abstractmethod
+    def scroll_into_view(self, element: WebElementProtocol) -> None:
+        """Scroll element into viewport."""
+        ...
+
+    # Storage and cookies
+    @abstractmethod
+    def set_local_storage(self, key: str, value: Union[str, float]) -> None:
+        """Set localStorage item."""
+        ...
+
+    @abstractmethod
+    def remove_local_storage(self, key: str) -> None:
+        """Remove localStorage item."""
+        ...
+
+    @abstractmethod
+    def get_cookies(self) -> list[Cookie]:
+        """Get all browser cookies."""
+        ...
+
+    # Alert handling
+    @abstractmethod
+    def accept_alert(self) -> "ContextManager[None]":
+        """
+        Return a context manager for accepting browser alert dialogs.
+
+        Usage:
+            with driver.accept_alert():
+                driver.click_selector("#button-that-shows-alert")
+            # Alert is automatically accepted
+        """
+        ...
+
+    # Accessibility
+    @abstractmethod
+    def axe_eval(self, context: Optional[str] = None, write_to: Optional[str] = None) -> AxeResults:
+        """Run axe-core accessibility tests."""
+        ...
+
+    # Screenshots
+    @abstractmethod
+    def save_screenshot(self, path: str) -> None:
+        """Save a screenshot to the specified path."""
+        ...
+
+    @abstractmethod
+    def get_screenshot_as_png(self) -> bytes:
+        """
+        Capture a screenshot and return it as PNG bytes.
+
+        Returns:
+            PNG image data as bytes
+        """
+        ...
+
+    # Timeout utilities
+    @abstractmethod
+    def _timeout_message(self, on_str: str) -> str:
+        """
+        Generate a timeout error message.
+
+        Args:
+            on_str: Description of what was being waited on
+
+        Returns:
+            Formatted timeout message string
+        """
+        ...
+
+    @abstractmethod
+    def prepend_timeout_message(
+        self,
+        timeout_exception: Exception,
+        message: str,
+    ) -> Exception:
+        """Add context to timeout exception message."""
+        ...
+
+    # Lifecycle management
+    @abstractmethod
+    def close(self) -> None:
+        """Clean up and close the current page/tab."""
+        ...
+
+    @abstractmethod
+    def quit(self) -> None:
+        """
+        Clean up and close the driver/browser.
+
+        This closes all windows/tabs and releases all system resources.
+        The driver cannot be used after calling this method.
+        """
+        ...
+
+
+__all__ = (
+    "HasDriverProtocol",
+    "BackendType",
+    "TimeoutCallback",
+    "WaitTypeT",
+    "Cookie",
+    "fixed_timeout_handler",
+    "HasElementLocator",
+    "ElementLocatorTuple",
+)
diff --git a/lib/galaxy/selenium/has_driver_proxy.py b/lib/galaxy/selenium/has_driver_proxy.py
new file mode 100644
index 000000000000..4dd95f3e0a7d
--- /dev/null
+++ b/lib/galaxy/selenium/has_driver_proxy.py
@@ -0,0 +1,504 @@
+"""Proxy base class for delegating driver operations to a HasDriverProtocol implementation.
+
+This module provides HasDriverProxy, a mixin that implements the driver
+abstraction interface by delegating all operations to a pluggable implementation,
+and HasDriverProxyImpl, a concrete base class with constructor.
+NavigatesGalaxy extends this proxy to enable runtime backend selection.
+"""
+
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from typing import (
+    Any,
+    Generic,
+    Optional,
+    Union,
+)
+
+from galaxy.navigation.components import Target
+from .axe_results import AxeResults
+from .has_driver_protocol import (
+    BackendType,
+    Cookie,
+    HasDriverProtocol,
+    HasElementLocator,
+    TimeoutCallback,
+    WaitTypeT,
+)
+from .web_element_protocol import WebElementProtocol
+
+
+class HasDriverProxy(ABC, Generic[WaitTypeT]):
+    """
+    Proxy mixin that delegates all driver operations to an implementation.
+
+    This mixin provides composition over inheritance - it requires subclasses to
+    implement _driver_impl as a property that returns a HasDriverProtocol implementation.
+    All driver operations are forwarded to this implementation.
+
+    This is an abstract base class. Subclasses must implement _driver_impl as a property:
+
+    Usage as direct subclass:
+        class MyClass(HasDriverProxy):
+            def __init__(self):
+                self._impl = create_driver()  # Store in private attribute
+
+            @property
+            def _driver_impl(self):
+                return self._impl  # Return via property
+
+            def my_custom_method(self):
+                self.click_selector("#my-button")
+
+    Usage with HasDriverProxyImpl:
+        class MyClass(HasDriverProxyImpl):
+            def __init__(self):
+                driver_impl = create_driver()
+                super().__init__(driver_impl)  # Stores and provides via property
+
+    Attributes:
+        _driver_impl: Abstract property that must return a HasDriverProtocol implementation
+    """
+
+    @property
+    @abstractmethod
+    def _driver_impl(self) -> HasDriverProtocol[WaitTypeT]:
+        """Return the HasDriverProtocol implementation to delegate to.
+
+        Subclasses must implement this property to provide the driver implementation.
+        """
+        ...
+
+    @property
+    def backend_type(self) -> BackendType:
+        """Return the backend type of the driver implementation."""
+        return self._driver_impl.backend_type
+
+    # Core timeout management
+
+    @property
+    def timeout_handler(self) -> TimeoutCallback:
+        """Get timeout handler for application specific wait types."""
+        return self._driver_impl.timeout_handler
+
+    def wait(self, timeout=..., wait_type: Optional[WaitTypeT] = None, **kwds):
+        """Create a wait object with the specified timeout."""
+        return self._driver_impl.wait(timeout, wait_type=wait_type, **kwds)
+
+    # Navigation
+
+    @property
+    def current_url(self) -> str:
+        """Get the current page URL."""
+        return self._driver_impl.current_url
+
+    @property
+    def page_source(self) -> str:
+        """Get the HTML source of the current page."""
+        return self._driver_impl.page_source
+
+    @property
+    def page_title(self) -> str:
+        """Get the title of the current page."""
+        return self._driver_impl.page_title
+
+    def navigate_to(self, url: str) -> None:
+        """Navigate to the specified URL."""
+        self._driver_impl.navigate_to(url)
+
+    def re_get_with_query_params(self, params_str: str):
+        """Navigate to current URL with additional query parameters."""
+        return self._driver_impl.re_get_with_query_params(params_str)
+
+    # Element finding - by locator type
+
+    def find_element_by_id(self, id: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find element by ID attribute."""
+        return self._driver_impl.find_element_by_id(id, element)
+
+    def find_element_by_selector(self, selector: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find element by CSS selector."""
+        return self._driver_impl.find_element_by_selector(selector, element)
+
+    def find_element_by_xpath(self, xpath: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find element by XPath expression."""
+        return self._driver_impl.find_element_by_xpath(xpath, element)
+
+    def find_element_by_link_text(self, text: str, element: Optional[Any] = None) -> WebElementProtocol:
+        """Find link element by visible text."""
+        return self._driver_impl.find_element_by_link_text(text, element)
+
+    def find_elements_by_selector(self, selector: str, element: Optional[Any] = None) -> list[WebElementProtocol]:
+        """Find all elements matching CSS selector."""
+        return self._driver_impl.find_elements_by_selector(selector, element)
+
+    def find_elements(self, selector_template: Target) -> list[WebElementProtocol]:
+        """Find all elements matching the Target selector template."""
+        return self._driver_impl.find_elements(selector_template)
+
+    def find_element(self, selector_template: HasElementLocator) -> WebElementProtocol:
+        """
+        Find first element matching selector template (no waiting).
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple
+        """
+        return self._driver_impl.find_element(selector_template)
+
+    # Wait methods - presence
+
+    def wait_for_xpath(self, xpath: str, **kwds) -> Any:
+        """Wait for element matching XPath to be present in DOM."""
+        return self._driver_impl.wait_for_xpath(xpath, **kwds)
+
+    def wait_for_selector(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be present in DOM."""
+        return self._driver_impl.wait_for_selector(selector, **kwds)
+
+    def wait_for_present(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be present in DOM."""
+        return self._driver_impl.wait_for_present(selector_template, **kwds)
+
+    def wait_for_id(self, id: str, **kwds) -> Any:
+        """Wait for element with ID to be present in DOM."""
+        return self._driver_impl.wait_for_id(id, **kwds)
+
+    # Wait methods - visibility
+
+    def wait_for_xpath_visible(self, xpath: str, **kwds) -> Any:
+        """Wait for element matching XPath to be visible."""
+        return self._driver_impl.wait_for_xpath_visible(xpath, **kwds)
+
+    def wait_for_selector_visible(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be visible."""
+        return self._driver_impl.wait_for_selector_visible(selector, **kwds)
+
+    def wait_for_visible(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be visible."""
+        return self._driver_impl.wait_for_visible(selector_template, **kwds)
+
+    # Wait methods - clickable
+
+    def wait_for_selector_clickable(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be clickable."""
+        return self._driver_impl.wait_for_selector_clickable(selector, **kwds)
+
+    def wait_for_clickable(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be clickable."""
+        return self._driver_impl.wait_for_clickable(selector_template, **kwds)
+
+    # Wait methods - absence/hidden
+
+    def wait_for_selector_absent(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be absent from DOM."""
+        return self._driver_impl.wait_for_selector_absent(selector, **kwds)
+
+    def wait_for_absent(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be absent from DOM."""
+        return self._driver_impl.wait_for_absent(selector_template, **kwds)
+
+    def wait_for_selector_absent_or_hidden(self, selector: str, **kwds) -> Any:
+        """Wait for element matching CSS selector to be absent or hidden."""
+        return self._driver_impl.wait_for_selector_absent_or_hidden(selector, **kwds)
+
+    def wait_for_absent_or_hidden(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element matching Target to be absent or hidden."""
+        return self._driver_impl.wait_for_absent_or_hidden(selector_template, **kwds)
+
+    # Wait methods - count
+
+    def wait_for_element_count_of_at_least(self, selector_template: Target, n: int, **kwds) -> Any:
+        """Wait for at least n elements matching Target to be present."""
+        return self._driver_impl.wait_for_element_count_of_at_least(selector_template, n, **kwds)
+
+    # Wait and interact
+
+    def wait_for_and_click(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be clickable and click it."""
+        return self._driver_impl.wait_for_and_click(selector_template, **kwds)
+
+    def wait_for_and_double_click(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be clickable and double-click it."""
+        return self._driver_impl.wait_for_and_double_click(selector_template, **kwds)
+
+    # Custom wait abstraction
+    def _wait_on_custom(self, condition_func, message: str, **kwds) -> Any:
+        """Wait on custom condition function."""
+        return self._driver_impl._wait_on_custom(condition_func, message, **kwds)
+
+    # Visibility checks
+
+    def selector_is_displayed(self, selector: str) -> bool:
+        """Check if element matching CSS selector is displayed."""
+        return self._driver_impl.selector_is_displayed(selector)
+
+    def is_displayed(self, selector_template: Target) -> bool:
+        """Check if element matching Target is displayed."""
+        return self._driver_impl.is_displayed(selector_template)
+
+    def element_absent(self, selector_template: Target) -> bool:
+        """Check if element matching Target is absent from DOM."""
+        return self._driver_impl.element_absent(selector_template)
+
+    # Assertions
+
+    def assert_xpath(self, xpath: str):
+        """Assert element matching XPath is present."""
+        return self._driver_impl.assert_xpath(xpath)
+
+    def assert_selector(self, selector: str):
+        """Assert element matching CSS selector is present."""
+        return self._driver_impl.assert_selector(selector)
+
+    def assert_selector_absent(self, selector: str):
+        """Assert element matching CSS selector is absent."""
+        return self._driver_impl.assert_selector_absent(selector)
+
+    def assert_selector_absent_or_hidden(self, selector: str):
+        """Assert element matching CSS selector is absent or hidden."""
+        return self._driver_impl.assert_selector_absent_or_hidden(selector)
+
+    def assert_absent(self, selector_template: Target) -> None:
+        """Assert element matching Target is absent."""
+        self._driver_impl.assert_absent(selector_template)
+
+    def assert_absent_or_hidden(self, selector_template: Target):
+        """Assert element matching Target is absent or hidden."""
+        return self._driver_impl.assert_absent_or_hidden(selector_template)
+
+    def assert_disabled(self, selector_template: Target):
+        """Assert element matching Target is disabled."""
+        return self._driver_impl.assert_disabled(selector_template)
+
+    def assert_absent_or_hidden_after_transitions(self, selector_template: Target, **kwds) -> None:
+        """Assert element is absent or hidden, retrying during transitions."""
+        self._driver_impl.assert_absent_or_hidden_after_transitions(selector_template, **kwds)
+
+    # Click methods
+
+    def click(self, selector_template: Target):
+        """Click element matching Target."""
+        return self._driver_impl.click(selector_template)
+
+    def click_xpath(self, xpath: str):
+        """Click element matching XPath."""
+        return self._driver_impl.click_xpath(xpath)
+
+    def click_selector(self, selector: str):
+        """Click element matching CSS selector."""
+        return self._driver_impl.click_selector(selector)
+
+    def click_label(self, text: str):
+        """Click link with visible text."""
+        return self._driver_impl.click_label(text)
+
+    # Mouse interactions
+
+    def hover(self, element: WebElementProtocol) -> None:
+        """Hover mouse over element."""
+        self._driver_impl.hover(element)
+
+    def move_to_and_click(self, element: WebElementProtocol) -> None:
+        """Move mouse to element and click."""
+        self._driver_impl.move_to_and_click(element)
+
+    def drag_and_drop(self, source: WebElementProtocol, target: WebElementProtocol) -> None:
+        """Drag source element and drop on target element."""
+        self._driver_impl.drag_and_drop(source, target)
+
+    def double_click(self, element: WebElementProtocol) -> None:
+        """Double-click element."""
+        self._driver_impl.double_click(element)
+
+    def action_chains(self):
+        """Get action chains object for complex interactions."""
+        return self._driver_impl.action_chains()
+
+    # Keyboard interactions
+
+    def send_enter(self, element: Optional[WebElementProtocol] = None):
+        """Send ENTER key to element or active element."""
+        return self._driver_impl.send_enter(element)
+
+    def send_escape(self, element: Optional[WebElementProtocol] = None):
+        """Send ESCAPE key to element or active element."""
+        return self._driver_impl.send_escape(element)
+
+    def send_backspace(self, element: Optional[WebElementProtocol] = None):
+        """Send BACKSPACE key to element or active element."""
+        return self._driver_impl.send_backspace(element)
+
+    def aggressive_clear(self, element: WebElementProtocol) -> None:
+        """Clear input element value using JavaScript and backspaces (for when .clear() doesn't work)."""
+        self._driver_impl.aggressive_clear(element)
+
+    # Form interactions
+
+    def fill(self, form: WebElementProtocol, info: dict):
+        """Fill form with provided data."""
+        return self._driver_impl.fill(form, info)
+
+    def click_submit(self, form: WebElementProtocol):
+        """Click submit button in form."""
+        return self._driver_impl.click_submit(form)
+
+    def get_input_value(self, element: WebElementProtocol) -> str:
+        """
+        Get the value of an input element.
+
+        This provides a unified interface for getting input values across both
+        Selenium and Playwright backends.
+
+        Args:
+            element: The input element to get the value from
+
+        Returns:
+            The current value of the input element, or empty string if no value
+        """
+        return self._driver_impl.get_input_value(element)
+
+    def select_by_value(self, selector_template: HasElementLocator, value: str) -> None:
+        """
+        Select an option from a <select> element by its value attribute.
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple for the select element
+            value: The value attribute of the option to select
+        """
+        return self._driver_impl.select_by_value(selector_template, value)
+
+    # Frame switching
+
+    def switch_to_frame(self, frame_reference: Union[str, int, Any] = "frame"):
+        """Switch to iframe by name, id, index, or element."""
+        return self._driver_impl.switch_to_frame(frame_reference)
+
+    def switch_to_default_content(self):
+        """Switch back to main page content from iframe."""
+        return self._driver_impl.switch_to_default_content()
+
+    # JavaScript execution
+
+    def execute_script(self, script: str, *args):
+        """Execute JavaScript in the browser."""
+        return self._driver_impl.execute_script(script, *args)
+
+    def execute_script_click(self, element: WebElementProtocol) -> None:
+        """Click element using JavaScript."""
+        self._driver_impl.execute_script_click(element)
+
+    def set_element_value(self, element: WebElementProtocol, value: str) -> None:
+        """Set input element value using JavaScript."""
+        self._driver_impl.set_element_value(element, value)
+
+    def scroll_into_view(self, element: WebElementProtocol) -> None:
+        """Scroll element into viewport."""
+        self._driver_impl.scroll_into_view(element)
+
+    # Storage and cookies
+
+    def set_local_storage(self, key: str, value: Union[str, float]) -> None:
+        """Set localStorage item."""
+        self._driver_impl.set_local_storage(key, value)
+
+    def remove_local_storage(self, key: str) -> None:
+        """Remove localStorage item."""
+        self._driver_impl.remove_local_storage(key)
+
+    def get_cookies(self) -> list[Cookie]:
+        """Get all browser cookies."""
+        return self._driver_impl.get_cookies()
+
+    # Alert handling
+
+    def accept_alert(self):
+        """Accept browser alert dialog."""
+        return self._driver_impl.accept_alert()
+
+    # Accessibility
+
+    def axe_eval(self, context: Optional[str] = None, write_to: Optional[str] = None) -> AxeResults:
+        """Run axe-core accessibility tests."""
+        return self._driver_impl.axe_eval(context, write_to)
+
+    # Screenshots
+
+    def save_screenshot(self, path: str) -> None:
+        """Save a screenshot to the specified path."""
+        self._driver_impl.save_screenshot(path)
+
+    def get_screenshot_as_png(self) -> bytes:
+        """
+        Capture a screenshot and return it as PNG bytes.
+
+        Returns:
+            PNG image data as bytes
+        """
+        return self._driver_impl.get_screenshot_as_png()
+
+    # Timeout utilities
+
+    def _timeout_message(self, on_str: str) -> str:
+        """
+        Generate a timeout error message.
+
+        Args:
+            on_str: Description of what was being waited on
+
+        Returns:
+            Formatted timeout message string
+        """
+        return self._driver_impl._timeout_message(on_str)
+
+    def prepend_timeout_message(self, timeout_exception: Exception, message: str) -> Exception:
+        """Add context to timeout exception message."""
+        return self._driver_impl.prepend_timeout_message(timeout_exception, message)
+
+    # Cleanup
+    def close(self) -> None:
+        """Close the current browser/page."""
+        self._driver_impl.close()
+
+    def quit(self) -> None:
+        """Quit the driver and clean up resources."""
+        self._driver_impl.quit()
+
+
+class HasDriverProxyImpl(HasDriverProxy[WaitTypeT], Generic[WaitTypeT]):
+    """
+    Concrete implementation of HasDriverProxy with a constructor.
+
+    This class provides the constructor that accepts and stores a driver implementation,
+    then provides it via the _driver_impl property.
+
+    Use this as a base class when you can directly pass the driver implementation
+    to the constructor.
+
+    Usage:
+        class MyClass(HasDriverProxyImpl):
+            def __init__(self, config):
+                driver_impl = create_driver_from_config(config)
+                super().__init__(driver_impl)
+
+            def my_custom_method(self):
+                self.click_selector("#my-button")
+    """
+
+    def __init__(self, driver_impl: HasDriverProtocol[WaitTypeT]):
+        """
+        Initialize the proxy with a driver implementation.
+
+        Args:
+            driver_impl: An object implementing HasDriverProtocol (HasDriver or HasPlaywrightDriver)
+        """
+        self.__driver_impl_value = driver_impl
+
+    @property
+    def _driver_impl(self) -> HasDriverProtocol[WaitTypeT]:
+        """Return the stored driver implementation."""
+        return self.__driver_impl_value
+
+
+__all__ = ("HasDriverProxy", "HasDriverProxyImpl")
diff --git a/lib/galaxy/selenium/has_playwright_driver.py b/lib/galaxy/selenium/has_playwright_driver.py
new file mode 100644
index 000000000000..665894d52b64
--- /dev/null
+++ b/lib/galaxy/selenium/has_playwright_driver.py
@@ -0,0 +1,1146 @@
+"""Playwright-backed implementation of the HasDriver abstraction layer.
+
+This module provides a Playwright-based implementation that mirrors the API of
+has_driver.py, allowing Galaxy tests to run with either Selenium or Playwright
+backends with minimal code changes.
+
+Overview
+--------
+HasPlaywrightDriver provides a high-level interface for browser automation using
+Playwright, with the same API surface as HasDriver (Selenium-based). This allows
+test code to be backend-agnostic - the same test can run against both Selenium
+and Playwright implementations.
+
+Key Features
+------------
+- Element finding and interaction (click, hover, drag-and-drop, etc.)
+- Explicit wait methods for various element states (visible, clickable, absent, etc.)
+- Frame/iframe switching and navigation
+- JavaScript execution and page manipulation
+- Form filling and submission
+- Cookie management and local storage
+- Accessibility testing with axe-core
+- Exception handling and timeout management
+
+Usage Example
+-------------
+To use this mixin, create a class that provides the required attributes:
+
+    from playwright.sync_api import sync_playwright
+    from galaxy.selenium.has_playwright_driver import HasPlaywrightDriver
+
+    class MyTestClass(HasPlaywrightDriver):
+        def __init__(self, page):
+            self.page = page
+            self.default_timeout = 10.0
+
+        def timeout_for(self, **kwds):
+            return kwds.get("timeout", self.default_timeout)
+
+    # In your test
+    with sync_playwright() as p:
+        browser = p.chromium.launch()
+        page = browser.new_page()
+        test = MyTestClass(page)
+
+        # Use the high-level API
+        test.navigate_to("https://example.com")
+        test.click_selector("#my-button")
+        test.wait_for_selector_visible(".result")
+        element = test.find_element_by_id("content")
+
+API Compatibility with HasDriver
+---------------------------------
+This implementation maintains API compatibility with HasDriver (Selenium), with
+the following considerations:
+
+**Fully Compatible Methods:**
+- Element finding: find_element_by_id, find_element_by_selector, find_elements, etc.
+- Waiting: wait_for_selector, wait_for_visible, wait_for_clickable, etc.
+- Clicking: click_selector, click_xpath, click_label, etc.
+- Navigation: navigate_to, re_get_with_query_params
+- Assertions: assert_selector_absent_or_hidden, assert_disabled, etc.
+- JavaScript: execute_script, execute_script_click, set_element_value
+- Forms: fill, click_submit
+- Frames: switch_to_frame, switch_to_default_content
+- Accessibility: axe_eval (with context and write_to parameters)
+- Cookies: get_cookies
+- Storage: set_local_storage, remove_local_storage
+
+**Known Limitations:**
+1. wait_for_element_count_of_at_least() - Not implemented (raises NotImplementedError)
+   - Playwright doesn't have an equivalent to Selenium's element count waiting
+   - Use wait_for_present() and then check length of find_elements() instead
+
+Implementation Details
+----------------------
+**Locator Strategy:**
+Playwright uses CSS selectors and XPath natively. This implementation automatically
+converts Selenium locator strategies to Playwright selectors:
+- By.ID → #id
+- By.CLASS_NAME → .classname
+- By.CSS_SELECTOR → direct use
+- By.XPATH → direct use (Playwright supports XPath)
+- By.LINK_TEXT → text=...
+- By.NAME → [name="..."]
+
+**Wait Strategy:**
+Unlike Selenium's explicit WebDriverWait, Playwright has built-in auto-waiting for
+most actions. This implementation uses page.wait_for_selector() with different
+states: 'attached', 'detached', 'visible', 'hidden'.
+
+**Element References:**
+Returns WebElementProtocol-compatible PlaywrightElement wrappers around Playwright's
+ElementHandle objects. This provides a consistent interface across both backends.
+
+**Frame Handling:**
+Playwright doesn't have Selenium's "switch to" concept. This implementation tracks
+the current frame in _current_frame and uses _frame_or_page property to provide
+transparent access to the correct context.
+
+Thread Safety
+-------------
+This class is not thread-safe. Each Playwright Page should have its own
+HasPlaywrightDriver instance, and should only be accessed from a single thread.
+
+See Also
+--------
+- has_driver.py: The Selenium-based implementation with identical API
+- web_element_protocol.py: The WebElementProtocol interface for element compatibility
+- playwright_element.py: The PlaywrightElement wrapper implementation
+- wait_methods_mixin.py: Shared wait method implementations
+"""
+
+import abc
+from contextlib import contextmanager
+from typing import (
+    Any,
+    Generic,
+    NamedTuple,
+    Optional,
+    Union,
+)
+
+from playwright.sync_api import (
+    Browser,
+    ElementHandle,
+    Frame,
+    FrameLocator,
+    Page,
+    Playwright,
+    TimeoutError as PlaywrightTimeoutException,
+)
+
+from galaxy.navigation.components import Target
+from galaxy.util.wait import (
+    TimeoutAssertionError,
+    wait_on,
+)
+from .axe_results import (
+    AxeResults,
+    NullAxeResults,
+    RealAxeResults,
+)
+from .has_driver import (
+    DEFAULT_AXE_SCRIPT_URL,
+    get_axe_script,
+    TimeoutMessageMixin,
+)
+from .has_driver_protocol import (
+    BackendType,
+    Cookie,
+    HasElementLocator,
+    TimeoutCallback,
+    WaitTypeT,
+)
+from .playwright_element import PlaywrightElement
+from .wait_methods_mixin import WaitMethodsMixin
+from .web_element_protocol import WebElementProtocol
+
+UNSPECIFIED_TIMEOUT = object()
+
+
+class PlaywrightResources(NamedTuple):
+    """
+    Resources needed for Playwright driver lifecycle management.
+
+    This bundles together all the Playwright objects needed to properly
+    clean up a browser session.
+
+    Attributes:
+        playwright: Main Playwright instance (needs .stop() on cleanup)
+        browser: Browser instance (needs .close() on cleanup)
+        page: Page instance for browser automation
+    """
+
+    playwright: Playwright
+    browser: Browser
+    page: Page
+
+
+class PlaywrightKeys:
+    """Mapping of Selenium Keys to Playwright key names."""
+
+    ENTER = "Enter"
+    ESCAPE = "Escape"
+    BACKSPACE = "Backspace"
+    TAB = "Tab"
+    SPACE = " "
+    ARROW_DOWN = "ArrowDown"
+    ARROW_UP = "ArrowUp"
+    ARROW_LEFT = "ArrowLeft"
+    ARROW_RIGHT = "ArrowRight"
+
+
+class PlaywrightBy:
+    """Locator strategy constants matching Selenium's By class."""
+
+    ID = "id"
+    XPATH = "xpath"
+    LINK_TEXT = "link_text"
+    PARTIAL_LINK_TEXT = "partial_link_text"
+    NAME = "name"
+    TAG_NAME = "tag_name"
+    CLASS_NAME = "class_name"
+    CSS_SELECTOR = "css_selector"
+
+
+class HasPlaywrightDriver(TimeoutMessageMixin, WaitMethodsMixin, Generic[WaitTypeT]):
+    """Playwright-backed implementation of HasDriver interface."""
+
+    by: type[PlaywrightBy] = PlaywrightBy
+    keys: type[PlaywrightKeys] = PlaywrightKeys
+    axe_script_url: str = DEFAULT_AXE_SCRIPT_URL
+    axe_skip: bool = False
+    _current_frame: Optional[Union[Frame, FrameLocator]] = None
+    _playwright_resources: PlaywrightResources
+
+    @property
+    def page(self) -> Page:
+        """Access the Playwright Page from resources."""
+        return self._playwright_resources.page
+
+    @property
+    def backend_type(self) -> BackendType:
+        """Identify this as the Playwright backend implementation."""
+        return "playwright"
+
+    @property
+    @abc.abstractmethod
+    def timeout_handler(self) -> TimeoutCallback:
+        """Get timeout handler for application specific wait types."""
+        ...
+
+    def _selenium_locator_to_playwright_selector(self, by: str, value: str) -> str:
+        """
+        Convert Selenium By locator (with spaces) to Playwright selector.
+
+        Args:
+            by: Selenium locator strategy (e.g., 'class name', 'css selector')
+            value: Locator value
+
+        Returns:
+            Playwright-compatible selector string
+        """
+        if by == "id":
+            return f"#{value}"
+        elif by == "css selector":
+            return value
+        elif by == "xpath":
+            return f"xpath={value}"
+        elif by == "class name":
+            return f".{value}"
+        elif by == "name":
+            return f"[name='{value}']"
+        elif by == "tag name":
+            return value
+        elif by == "link text":
+            return f"text={value}"
+        elif by == "partial link text":
+            return f"text=/{value}/"
+        else:
+            raise ValueError(f"Unsupported Selenium locator strategy: {by}")
+
+    def _target_to_playwright_selector(self, target: Target) -> str:
+        """
+        Convert a Target object to Playwright selector.
+
+        Target objects use Selenium By constants, so we use the Selenium converter.
+
+        Args:
+            target: Target object with element_locator
+
+        Returns:
+            Playwright-compatible selector string
+        """
+        by, value = target.element_locator
+        return self._selenium_locator_to_playwright_selector(by, value)
+
+    @property
+    def current_url(self) -> str:
+        """
+        Get the current page URL.
+
+        Returns:
+            The current URL
+        """
+        return self.page.url
+
+    @property
+    def page_source(self) -> str:
+        """
+        Get the HTML source of the current page.
+
+        Returns:
+            The page HTML as a string
+        """
+        return self.page.content()
+
+    @property
+    def page_title(self) -> str:
+        """
+        Get the title of the current page.
+
+        Returns:
+            The page title as a string
+        """
+        return self.page.title()
+
+    def navigate_to(self, url: str) -> None:
+        """
+        Navigate to a URL.
+
+        Args:
+            url: The URL to navigate to
+        """
+        self.page.goto(url)
+
+    def re_get_with_query_params(self, params_str: str):
+        """Add query parameters to current URL and reload."""
+        current_url = self.page.url
+        if "?" not in current_url:
+            current_url += "?"
+        new_url = current_url + params_str
+        self.page.goto(new_url)
+
+    def assert_xpath(self, xpath: str):
+        """Assert element exists by XPath."""
+        selector = f"xpath={xpath}"
+        element = self._frame_or_page.locator(selector).first
+        assert element.count() > 0, f"Element not found with xpath: {xpath}"
+
+    def assert_selector(self, selector: str):
+        """Assert element exists by CSS selector."""
+        element = self._frame_or_page.locator(selector).first
+        assert element.count() > 0, f"Element not found with selector: {selector}"
+
+    def assert_selector_absent_or_hidden(self, selector: str):
+        """Assert element is absent or hidden."""
+        elements = self._frame_or_page.locator(selector).all()
+        for element in elements:
+            assert not element.is_visible()
+
+    def assert_absent_or_hidden(self, selector_template: Target):
+        """Assert element is absent or hidden using Target."""
+        selector = self._target_to_playwright_selector(selector_template)
+        elements = self._frame_or_page.locator(selector).all()
+        for element in elements:
+            assert not element.is_visible()
+
+    def assert_absent_or_hidden_after_transitions(self, selector_template: Target, **kwds) -> None:
+        """
+        Assert element is absent or hidden (convenience method for subclasses to override with retry logic).
+
+        This is a basic implementation that calls assert_absent_or_hidden.
+        Subclasses may decorate or override this method with retry logic for handling
+        transitions where elements may become stale.
+
+        Args:
+            selector_template: Target selector for the element
+            **kwds: Additional keyword arguments
+        """
+        return self.assert_absent_or_hidden(selector_template, **kwds)
+
+    def assert_disabled(self, selector_template: Target):
+        """Assert element is disabled."""
+        selector = self._target_to_playwright_selector(selector_template)
+        elements = self._frame_or_page.locator(selector).all()
+        assert len(elements) > 0, f"No elements found for {selector_template.description}"
+        for element in elements:
+            assert not element.is_enabled()
+
+    def selector_is_displayed(self, selector: str) -> bool:
+        """Check if element is displayed."""
+        element = self._frame_or_page.locator(selector).first
+        return element.is_visible()
+
+    def is_displayed(self, selector_template: Target) -> bool:
+        """Check if element is displayed using Target."""
+        selector = self._target_to_playwright_selector(selector_template)
+        element = self._frame_or_page.locator(selector).first
+        return element.is_visible()
+
+    def assert_selector_absent(self, selector: str):
+        """Assert element is completely absent from DOM."""
+        count = self._frame_or_page.locator(selector).count()
+        assert count == 0, f"Expected 0 elements but found {count} for selector: {selector}"
+
+    def find_elements(self, selector_template: Target) -> list[WebElementProtocol]:
+        """
+        Find all elements matching the Target selector.
+
+        Args:
+            selector_template: Target selector
+
+        Returns:
+            List of PlaywrightElement objects
+        """
+        selector = self._target_to_playwright_selector(selector_template)
+        locator = self._frame_or_page.locator(selector)
+        # Get all element handles and wrap them
+        count = locator.count()
+        return [PlaywrightElement(locator.nth(i).element_handle(), self) for i in range(count)]
+
+    def find_element(self, selector_template: HasElementLocator) -> WebElementProtocol:
+        """
+        Find first element matching selector template (no waiting).
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple
+        """
+        # Dispatch on input type
+        if isinstance(selector_template, Target):
+            selector = self._target_to_playwright_selector(selector_template)
+        else:
+            # It's a tuple (locator_type, value)
+            selector = self._selenium_locator_to_playwright_selector(*selector_template)
+        element_handle = self._frame_or_page.locator(selector).first.element_handle()
+        return PlaywrightElement(element_handle, self)
+
+    def assert_absent(self, selector_template: Target) -> None:
+        """Assert element is absent using Target."""
+        elements = self.find_elements(selector_template)
+        if len(elements) != 0:
+            description = selector_template.description
+            any_displayed = False
+            for element in elements:
+                # Check if visible
+                any_displayed = any_displayed or element.is_displayed()
+            msg = f"Expected DOM elements [{elements}] to be empty for selector target {description} - any actually displayed? [{any_displayed}]"
+            raise AssertionError(msg)
+
+    def element_absent(self, selector_template: Target) -> bool:
+        """Check if element is absent."""
+        return len(self.find_elements(selector_template)) == 0
+
+    def find_element_by_link_text(self, text: str, element: Optional[ElementHandle] = None) -> WebElementProtocol:
+        """Find element by link text."""
+        if element is not None:
+            # Find within element context - need to use element as locator root
+            raise NotImplementedError("Finding within element context not yet implemented")
+        selector = f"text={text}"
+        element_handle = self._frame_or_page.locator(selector).first.element_handle()
+        return PlaywrightElement(element_handle, self)
+
+    def find_element_by_xpath(self, xpath: str, element: Optional[ElementHandle] = None) -> WebElementProtocol:
+        """Find element by XPath."""
+        if element is not None:
+            raise NotImplementedError("Finding within element context not yet implemented")
+        selector = f"xpath={xpath}"
+        element_handle = self._frame_or_page.locator(selector).first.element_handle()
+        return PlaywrightElement(element_handle, self)
+
+    def find_element_by_id(self, id: str, element: Optional[ElementHandle] = None) -> WebElementProtocol:
+        """Find element by ID."""
+        if element is not None:
+            raise NotImplementedError("Finding within element context not yet implemented")
+        selector = f"#{id}"
+        element_handle = self._frame_or_page.locator(selector).first.element_handle()
+        return PlaywrightElement(element_handle, self)
+
+    def find_element_by_selector(self, selector: str, element: Optional[ElementHandle] = None) -> WebElementProtocol:
+        """Find element by CSS selector."""
+        if element is not None:
+            raise NotImplementedError("Finding within element context not yet implemented")
+        element_handle = self._frame_or_page.locator(selector).first.element_handle()
+        return PlaywrightElement(element_handle, self)
+
+    def find_elements_by_selector(
+        self, selector: str, element: Optional[ElementHandle] = None
+    ) -> list[WebElementProtocol]:
+        """
+        Find multiple elements by CSS selector.
+
+        Args:
+            selector: CSS selector string
+            element: Optional parent element to search within (not yet implemented)
+
+        Returns:
+            List of WebElementProtocol elements
+        """
+        if element is not None:
+            raise NotImplementedError("Finding within element context not yet implemented")
+        element_handles = self._frame_or_page.locator(selector).all()
+        return [PlaywrightElement(handle.element_handle(), self) for handle in element_handles]
+
+    def get_input_value(self, element: WebElementProtocol) -> str:
+        """
+        Get the value of an input element.
+
+        This provides a unified interface for getting input values across both
+        Selenium and Playwright backends. For Playwright, this uses the
+        PlaywrightElement's get_attribute("value") which internally uses
+        input_value() for proper value retrieval.
+
+        Args:
+            element: The input element to get the value from
+
+        Returns:
+            The current value of the input element, or empty string if no value
+        """
+        # The PlaywrightElement.get_attribute("value") already handles the
+        # special case of using input_value() for input elements
+        value = element.get_attribute("value")
+        return value if value is not None else ""
+
+    def select_by_value(self, selector_template: HasElementLocator, value: str) -> None:
+        """
+        Select an option from a <select> element by its value attribute.
+
+        Args:
+            selector_template: Either a Target or a (locator_type, value) tuple for the select element
+            value: The value attribute of the option to select
+        """
+        # Dispatch on input type
+        if isinstance(selector_template, Target):
+            selector = self._target_to_playwright_selector(selector_template)
+        else:
+            # It's a tuple (locator_type, value)
+            selector = self._selenium_locator_to_playwright_selector(*selector_template)
+        self._frame_or_page.locator(selector).first.select_option(value=value)
+
+    def _timeout_in_ms(self, timeout=UNSPECIFIED_TIMEOUT, wait_type: Optional[WaitTypeT] = None, **kwds) -> float:
+        """
+        Convert timeout from seconds to milliseconds.
+
+        Returns:
+            Timeout in milliseconds for Playwright
+        """
+
+        if timeout is UNSPECIFIED_TIMEOUT:
+            timeout = self.timeout_handler(wait_type)
+
+        return timeout * 1000
+
+    # Implementation of WaitMethodsMixin abstract methods for Playwright
+    def _wait_on_condition_present(self, locator_tuple: tuple, message: str, **kwds) -> WebElementProtocol:
+        """Wait for element to be present in DOM."""
+        timeout_ms = self._timeout_in_ms(**kwds)
+        selector = self._selenium_locator_to_playwright_selector(*locator_tuple)
+        try:
+            if self._current_frame is not None:
+                frame_locator = self._frame_or_page
+                frame_locator.locator(selector).wait_for(state="attached", timeout=timeout_ms)
+                element_handle = frame_locator.locator(selector).first.element_handle()
+            else:
+                self._frame_or_page.wait_for_selector(selector, state="attached", timeout=timeout_ms)
+                element_handle = self._frame_or_page.locator(selector).first.element_handle()
+            return PlaywrightElement(element_handle, self)
+        except PlaywrightTimeoutException as e:
+            raise PlaywrightTimeoutException(self._timeout_message(message)) from e
+
+    def _wait_on_condition_visible(self, locator_tuple: tuple, message: str, **kwds) -> WebElementProtocol:
+        """Wait for element to be visible."""
+        timeout_ms = self._timeout_in_ms(**kwds)
+        selector = self._selenium_locator_to_playwright_selector(*locator_tuple)
+        try:
+            if self._current_frame is not None:
+                frame_locator = self._frame_or_page
+                frame_locator.locator(selector).wait_for(state="visible", timeout=timeout_ms)
+                element_handle = frame_locator.locator(selector).first.element_handle()
+            else:
+                self._frame_or_page.wait_for_selector(selector, state="visible", timeout=timeout_ms)
+                element_handle = self._frame_or_page.locator(selector).first.element_handle()
+            return PlaywrightElement(element_handle, self)
+        except PlaywrightTimeoutException as e:
+            raise PlaywrightTimeoutException(self._timeout_message(message)) from e
+
+    def _wait_on_condition_clickable(self, locator_tuple: tuple, message: str, **kwds) -> WebElementProtocol:
+        """Wait for element to be clickable."""
+        timeout_ms = self._timeout_in_ms(**kwds)
+        selector = self._selenium_locator_to_playwright_selector(*locator_tuple)
+        try:
+            # Playwright doesn't have explicit "clickable" state, use visible + enabled
+            all_locator = self._frame_or_page.locator(selector)
+            locator = all_locator.first
+            self._frame_or_page.wait_for_selector(selector, state="visible", timeout=timeout_ms)
+
+            # Wait for element to be enabled
+            def is_enabled() -> bool:
+                return locator.is_enabled()
+
+            wait_on(is_enabled, "locator to be enabled", timeout=timeout_ms / 1000)
+
+            element_handle = locator.element_handle()
+            return PlaywrightElement(element_handle, self)
+        except TimeoutAssertionError as e:
+            # found the element but it never became enabled, TODO: richer error message
+            raise PlaywrightTimeoutException(self._timeout_message(message)) from e
+        except PlaywrightTimeoutException as e:
+            raise PlaywrightTimeoutException(self._timeout_message(message)) from e
+
+    def _wait_on_condition_invisible(self, locator_tuple: tuple, message: str, **kwds) -> None:
+        """Wait for element to be invisible or absent."""
+        timeout_ms = self._timeout_in_ms(**kwds)
+        selector = self._selenium_locator_to_playwright_selector(*locator_tuple)
+        try:
+            self._frame_or_page.wait_for_selector(selector, state="hidden", timeout=timeout_ms)
+            return None
+        except PlaywrightTimeoutException as e:
+            raise PlaywrightTimeoutException(self._timeout_message(message)) from e
+
+    def _wait_on_condition_absent(self, locator_tuple: tuple, message: str, **kwds) -> None:
+        """Wait for element to be completely absent from DOM."""
+        timeout_ms = self._timeout_in_ms(**kwds)
+        selector = self._selenium_locator_to_playwright_selector(*locator_tuple)
+        try:
+            self._frame_or_page.wait_for_selector(selector, state="detached", timeout=timeout_ms)
+            return None
+        except PlaywrightTimeoutException as e:
+            raise PlaywrightTimeoutException(self._timeout_message(message)) from e
+
+    def _wait_on_condition_count(self, locator_tuple: tuple, n: int, message: str, **kwds) -> None:
+        """Wait for at least N elements."""
+        raise NotImplementedError("wait_for_element_count_of_at_least not yet implemented for Playwright")
+
+    # TODO: typevar here Any needs to be return type of condition_func thunk.
+    def _wait_on_custom(self, condition_func, message: str, **kwds) -> Any:
+        """Wait on custom condition function."""
+        timeout = kwds.get("timeout", UNSPECIFIED_TIMEOUT)
+        if timeout is UNSPECIFIED_TIMEOUT:
+            timeout = self.timeout_handler(kwds.get("wait_type"))
+
+        return wait_on(condition_func, message, timeout)
+
+    def _unwrap_element(self, element: WebElementProtocol) -> ElementHandle:
+        """
+        Unwrap a PlaywrightElement to get the underlying ElementHandle.
+
+        Args:
+            element: WebElementProtocol (PlaywrightElement wrapper)
+
+        Returns:
+            The underlying ElementHandle
+        """
+        if isinstance(element, PlaywrightElement):
+            return element.element_handle
+        # For type safety, this should always be a PlaywrightElement in this driver
+        raise TypeError(f"Expected PlaywrightElement, got {type(element)}")
+
+    def double_click(self, element: WebElementProtocol) -> None:
+        """
+        Double-click an element.
+
+        Args:
+            element: The element to double-click
+        """
+        self._double_click(self._unwrap_element(element))
+
+    def _double_click(self, element: ElementHandle) -> None:
+        """Internal implementation of double-click."""
+        element.dblclick()
+
+    def click(self, selector_template: Target) -> None:
+        """
+        Click an element using Target selector.
+
+        Args:
+            selector_template: Target selector for the element
+        """
+        selector = self._target_to_playwright_selector(selector_template)
+        self._frame_or_page.locator(selector).first.click()
+
+    def click_xpath(self, xpath: str) -> None:
+        """
+        Click element by XPath.
+
+        Args:
+            xpath: XPath selector
+        """
+        selector = f"xpath={xpath}"
+        self._frame_or_page.locator(selector).first.click()
+
+    def click_label(self, text: str) -> None:
+        """
+        Click link by text.
+
+        Args:
+            text: Link text to click
+        """
+        selector = f"text={text}"
+        self._frame_or_page.locator(selector).first.click()
+
+    def click_selector(self, selector: str) -> None:
+        """
+        Click element by CSS selector.
+
+        Args:
+            selector: CSS selector
+        """
+        self._frame_or_page.locator(selector).first.click()
+
+    def send_enter(self, element: Optional[WebElementProtocol] = None) -> None:
+        """
+        Send ENTER key.
+
+        Args:
+            element: Optional element to send key to. If None, sends to page.
+        """
+        if element is None:
+            self.page.keyboard.press(self.keys.ENTER)
+        else:
+            self._send_key_to_element(self.keys.ENTER, self._unwrap_element(element))
+
+    def send_escape(self, element: Optional[WebElementProtocol] = None) -> None:
+        """
+        Send ESCAPE key.
+
+        Args:
+            element: Optional element to send key to. If None, sends to page.
+        """
+        if element is None:
+            self.page.keyboard.press(self.keys.ESCAPE)
+        else:
+            self._send_key_to_element(self.keys.ESCAPE, self._unwrap_element(element))
+
+    def send_backspace(self, element: Optional[WebElementProtocol] = None) -> None:
+        """
+        Send BACKSPACE key.
+
+        Args:
+            element: Optional element to send key to. If None, sends to page.
+        """
+        if element is None:
+            self.page.keyboard.press(self.keys.BACKSPACE)
+        else:
+            self._send_key_to_element(self.keys.BACKSPACE, self._unwrap_element(element))
+
+    def aggressive_clear(self, element: WebElementProtocol) -> None:
+        """
+        Clear input element value using JavaScript and backspaces.
+
+        This is useful when a simple .clear() doesn't work due to event handlers
+        or framework-specific behavior.
+
+        Args:
+            element: The input element to clear
+        """
+        unwrapped = self._unwrap_element(element)
+        # First clear via JavaScript
+        self.page.evaluate("element => element.value = ''", unwrapped)
+        # Then send backspaces to trigger any input events
+        for _ in range(25):
+            unwrapped.press(self.keys.BACKSPACE)
+
+    def _send_key_to_element(self, key: str, element: ElementHandle) -> None:
+        """
+        Internal: Send a key press to a specific element.
+
+        Args:
+            key: The key to send
+            element: ElementHandle to send key to
+        """
+        element.press(key)
+
+    def hover(self, element: WebElementProtocol) -> None:
+        """
+        Hover over an element (move mouse to element without clicking).
+
+        Args:
+            element: The element to hover over
+        """
+        self._hover(self._unwrap_element(element))
+
+    def _hover(self, element: ElementHandle) -> None:
+        """Internal implementation of hover."""
+        element.hover()
+
+    def move_to_and_click(self, element: WebElementProtocol) -> None:
+        """
+        Move to an element and click it.
+
+        This is useful when a simple click doesn't work due to element positioning.
+
+        Args:
+            element: The element to move to and click
+        """
+        self._move_to_and_click(self._unwrap_element(element))
+
+    def _move_to_and_click(self, element: ElementHandle) -> None:
+        """Internal implementation of move_to_and_click."""
+        element.hover()
+        element.click()
+
+    def drag_and_drop(self, source: WebElementProtocol, target: WebElementProtocol) -> None:
+        """
+        Drag and drop from source element to target element.
+
+        Uses Playwright's drag and drop functionality via JavaScript.
+
+        Args:
+            source: The element to drag
+            target: The element to drop onto
+        """
+        self._drag_and_drop(self._unwrap_element(source), self._unwrap_element(target))
+
+    def _drag_and_drop(self, source: ElementHandle, target: ElementHandle) -> None:
+        """
+        Internal implementation of drag and drop.
+
+        Uses JavaScript to simulate drag and drop events.
+        """
+        self.page.evaluate(
+            """
+            (elements) => {
+                const [source, target] = elements;
+                const dataTransfer = new DataTransfer();
+                const dragstart = new DragEvent('dragstart', { dataTransfer, bubbles: true });
+                const dragover = new DragEvent('dragover', { dataTransfer, bubbles: true });
+                const drop = new DragEvent('drop', { dataTransfer, bubbles: true });
+                source.dispatchEvent(dragstart);
+                target.dispatchEvent(dragover);
+                target.dispatchEvent(drop);
+            }
+            """,
+            [source, target],
+        )
+
+    def action_chains(self):
+        """
+        Return action chains object (for Playwright, returns None as not needed).
+
+        Playwright handles actions differently than Selenium, so this method
+        returns None to maintain API compatibility.
+
+        Returns:
+            None (Playwright doesn't use ActionChains pattern)
+        """
+        # Playwright doesn't use action chains - return a placeholder object
+        # that indicates it exists but isn't used the same way
+        return self
+
+    def switch_to_frame(self, frame_reference: Union[str, int, ElementHandle, PlaywrightElement] = "frame"):
+        """
+        Switch to an iframe or frame.
+
+        Playwright handles frames differently than Selenium - it doesn't have a "switch"
+        concept. Instead, we store the frame reference so subsequent operations can
+        use the appropriate frame context.
+
+        Args:
+            frame_reference: Can be:
+                - str: frame name or id
+                - int: frame index
+                - ElementHandle: frame element
+                - WebElementProtocol: PlaywrightElement wrapping a frame element
+
+        Note: In Playwright, after calling this method, you should use the frame
+        context for subsequent operations. This implementation updates the internal
+        state to track the current frame.
+        """
+        if isinstance(frame_reference, str):
+            # Find frame by name or id
+            # Try as name attribute first
+            frame = self.page.frame(name=frame_reference)
+            if frame is None:
+                # Try as frame locator by name attribute selector
+                frame_locator = self.page.frame_locator(f"[name='{frame_reference}']")
+                # Store the frame locator for future use
+                self._current_frame = frame_locator
+            else:
+                self._current_frame = frame
+        elif isinstance(frame_reference, int):
+            # Get frame by index
+            frames = self.page.frames
+            if frame_reference < len(frames):
+                self._current_frame = frames[frame_reference]
+            else:
+                raise ValueError(f"Frame index {frame_reference} out of range")
+        elif isinstance(frame_reference, PlaywrightElement):
+            # Unwrap PlaywrightElement to get ElementHandle, then get frame
+            element_handle = self._unwrap_element(frame_reference)
+            self._current_frame = element_handle.content_frame()
+        else:
+            # Assume it's an ElementHandle representing a frame
+            # Get the content_frame from the element
+            self._current_frame = frame_reference.content_frame()
+
+    def switch_to_default_content(self):
+        """
+        Switch back to the default content (main page context).
+
+        This exits any iframe/frame context and returns to the top-level page.
+        """
+        self._current_frame = None
+
+    @property
+    def _frame_or_page(self):
+        """Get the current frame or page for operations."""
+        return self._current_frame if hasattr(self, "_current_frame") and self._current_frame else self.page
+
+    def execute_script(self, script: str, *args):
+        """
+        Execute JavaScript in the current browser context.
+
+        Args:
+            script: JavaScript code to execute
+            *args: Arguments to pass to the script (accessible via arguments[0], arguments[1], etc.)
+
+        Returns:
+            The result of the script execution
+        """
+        # Playwright's evaluate() passes a single argument to the JS function
+        # We need to make it look like Selenium's arguments object
+        # The trick is to receive the array and make it available as 'arguments'
+        wrapped_script = f"""
+        (args) => {{
+            const arguments = args || [];
+            {script}
+        }}
+        """
+
+        # Unwrap any PlaywrightElement wrappers to get ElementHandles
+        unwrapped_args = [
+            self._unwrap_element(arg) if isinstance(arg, (PlaywrightElement, WebElementProtocol)) else arg
+            for arg in args
+        ]
+
+        if unwrapped_args:
+            return self.page.evaluate(wrapped_script, unwrapped_args)
+        else:
+            return self.page.evaluate(wrapped_script, [])
+
+    def set_local_storage(self, key: str, value: str) -> None:
+        """
+        Set a value in the browser's localStorage.
+
+        Args:
+            key: Storage key
+            value: Value to store (will be JSON serialized)
+        """
+        self.execute_script(f"""window.localStorage.setItem("{key}", {value});""")
+
+    def remove_local_storage(self, key: str) -> None:
+        """
+        Remove a key from the browser's localStorage.
+
+        Args:
+            key: Storage key to remove
+        """
+        self.execute_script(f"""window.localStorage.removeItem("{key}");""")
+
+    def scroll_into_view(self, element: WebElementProtocol) -> None:
+        """
+        Scroll an element into view using JavaScript.
+
+        Args:
+            element: The element to scroll into view
+        """
+        self._scroll_into_view(self._unwrap_element(element))
+
+    def _scroll_into_view(self, element: ElementHandle) -> None:
+        """Internal implementation of scroll_into_view."""
+        # Playwright has a built-in scroll_into_view_if_needed, but for consistency
+        # with Selenium implementation, we'll use JavaScript
+        self.execute_script("arguments[0].scrollIntoView(true);", element)
+
+    def set_element_value(self, element: WebElementProtocol, value: str) -> None:
+        """
+        Set an element's value property directly using JavaScript.
+
+        Args:
+            element: The element to modify
+            value: The value to set
+        """
+        self._set_element_value(self._unwrap_element(element), value)
+
+    def _set_element_value(self, element: ElementHandle, value: str) -> None:
+        """Internal implementation of set_element_value."""
+        self.execute_script(f"arguments[0].value = '{value}';", element)
+
+    def execute_script_click(self, element: WebElementProtocol) -> None:
+        """
+        Click an element using JavaScript.
+
+        Args:
+            element: The element to click
+        """
+        self._execute_script_click(self._unwrap_element(element))
+
+    def _execute_script_click(self, element: ElementHandle) -> None:
+        """Internal implementation of execute_script_click."""
+        self.execute_script("arguments[0].click();", element)
+
+    def get_cookies(self) -> list[Cookie]:
+        """
+        Get all cookies for the current domain.
+
+        Returns:
+            List of cookie dictionaries
+        """
+        # Playwright stores cookies in the browser context
+        # Playwright returns list[playwright._impl._api_structures.Cookie] which is
+        # structurally compatible with our Cookie TypedDict but mypy sees them as
+        # invariant types. This is safe because both have the same keys at runtime.
+        return self.page.context.cookies()  # type: ignore[return-value]
+
+    def fill(self, form: WebElementProtocol, info: dict) -> None:
+        """
+        Fill form fields with provided data.
+
+        Args:
+            form: The form element
+            info: Dictionary mapping field names/IDs to values
+        """
+        for key, value in info.items():
+            try:
+                # Try by name first
+                input_element = form.find_element("name", key)
+            except Exception:
+                # Fall back to ID
+                input_element = form.find_element("id", key)
+            input_element.send_keys(value)
+
+    def click_submit(self, form: WebElementProtocol) -> None:
+        """
+        Click the submit button on a form.
+
+        Args:
+            form: The form element
+        """
+        submit_button = form.find_element("css selector", "input[type='submit']")
+        submit_button.click()
+
+    def accept_alert(self):
+        """
+        Return a context manager for accepting alerts.
+
+        For Playwright, the dialog handler must be set up before the alert is triggered,
+        so we set it up when entering the context.
+
+        Usage:
+            with driver.accept_alert():
+                driver.click_selector("#button-that-shows-alert")
+            # Alert is automatically accepted by the handler
+        """
+
+        @contextmanager
+        def _accept_alert_context():
+            # Set up the dialog handler before yielding
+            def handle_dialog(dialog):
+                dialog.accept()
+
+            self.page.once("dialog", handle_dialog)
+            try:
+                yield
+            finally:
+                # Handler is automatically removed after one use (once())
+                pass
+
+        return _accept_alert_context()
+
+    def prepend_timeout_message(
+        self, timeout_exception: PlaywrightTimeoutException, message: str
+    ) -> PlaywrightTimeoutException:
+        """
+        Prepend a custom message to a timeout exception.
+
+        Args:
+            timeout_exception: The original timeout exception
+            message: Message to prepend
+
+        Returns:
+            New PlaywrightTimeoutException with prepended message
+        """
+        msg = message
+        if hasattr(timeout_exception, "message") and timeout_exception.message:
+            msg += f" {timeout_exception.message}"
+        return PlaywrightTimeoutException(msg)
+
+    def axe_eval(self, context: Optional[str] = None, write_to: Optional[str] = None) -> AxeResults:
+        """
+        Run axe-core accessibility tests on the current page.
+
+        Args:
+            context: Optional CSS selector to limit the scope of testing
+            write_to: Optional file path to write results to
+
+        Returns:
+            AxeResults object with test results
+        """
+        if self.axe_skip:
+            return NullAxeResults()
+
+        # Load and inject axe-core script
+        content = get_axe_script(self.axe_script_url)
+        self.page.evaluate(content)
+
+        if context is None and self._current_frame is not None:
+            if isinstance(self._current_frame, Frame):
+                context = f"iframe#{self._current_frame.name}"
+            else:
+                raise NotImplementedError("Playwright frame locators not yet supported for axe context")
+
+        # Run axe with optional context
+        # Playwright's evaluate() handles promises automatically
+        if context:
+            results = self.page.evaluate(f"axe.run({context!r})")
+        else:
+            results = self.page.evaluate("axe.run()")
+
+        if write_to is not None:
+            import json
+
+            with open(write_to, "w") as f:
+                json.dump(results, f, indent=2)
+
+        return RealAxeResults(results)
+
+    def save_screenshot(self, path: str) -> None:
+        """
+        Save a screenshot to the specified path.
+
+        Args:
+            path: File path where the screenshot should be saved
+        """
+        self.page.screenshot(path=path)
+
+    def get_screenshot_as_png(self) -> bytes:
+        """
+        Capture a screenshot and return it as PNG bytes.
+
+        Returns:
+            PNG image data as bytes
+        """
+        return self.page.screenshot()
+
+    def close(self) -> None:
+        """Cleanup the current browser tab/page."""
+        self._playwright_resources.browser.close()
+
+    def quit(self) -> None:
+        """
+        Clean up and close the driver/browser.
+
+        This closes all windows/tabs and releases all system resources.
+        The driver cannot be used after calling this method.
+        """
+        self.close()
+        self._playwright_resources.playwright.stop()
+
+
+__all__ = (
+    "HasPlaywrightDriver",
+    "PlaywrightResources",
+    "PlaywrightTimeoutException",
+)
diff --git a/lib/galaxy/selenium/navigates_galaxy.py b/lib/galaxy/selenium/navigates_galaxy.py
index e363410127f6..713ac50ce63a 100644
--- a/lib/galaxy/selenium/navigates_galaxy.py
+++ b/lib/galaxy/selenium/navigates_galaxy.py
@@ -23,15 +23,17 @@
     Literal,
     NamedTuple,
     Optional,
+    TYPE_CHECKING,
     Union,
 )
 
 import yaml
 from selenium.webdriver.common.by import By
-from selenium.webdriver.remote.webdriver import WebDriver
-from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions as ec
-from seletools.actions import drag_and_drop
+
+if TYPE_CHECKING:
+    from selenium.webdriver.remote.webdriver import WebDriver
 
 from galaxy.navigation.components import (
     Component,
@@ -42,15 +44,16 @@
     DEFAULT_SOCKET_TIMEOUT,
     requests,
 )
-from . import sizzle
+from galaxy.util.wait import wait_on
 from .has_driver import (
     exception_indicates_click_intercepted,
     exception_indicates_not_clickable,
     exception_indicates_stale_element,
-    HasDriver,
     SeleniumTimeoutException,
 )
+from .has_driver_proxy import HasDriverProxy
 from .smart_components import SmartComponent
+from .web_element_protocol import WebElementProtocol
 
 # Test case data
 DEFAULT_PASSWORD = "123456"
@@ -94,6 +97,16 @@ class WAIT_TYPES:
     HISTORY_POLL = WaitType("history_poll", 3)
 
 
+def galaxy_timeout_handler(timeout_multiplier: float = 1):
+
+    def callback(wait_type: Optional[WaitType] = None) -> float:
+        if wait_type is None:
+            wait_type = DEFAULT_WAIT_TYPE
+        return wait_type.default_length * timeout_multiplier
+
+    return callback
+
+
 # Choose a moderate wait type for operations that don't specify a type.
 DEFAULT_WAIT_TYPE = WAIT_TYPES.DATABASE_OPERATION
 
@@ -217,7 +230,7 @@ class ColumnDefinition:
     default_value: Optional[str] = None
 
 
-class NavigatesGalaxy(HasDriver):
+class NavigatesGalaxy(HasDriverProxy[WaitType]):
     """Class with helpers methods for driving components of the Galaxy interface.
 
     In most cases, methods for interacting with Galaxy components that appear in
@@ -234,8 +247,44 @@ class NavigatesGalaxy(HasDriver):
     workflow_editor_click_option instead of click_workflow_editor_option.
     """
 
-    timeout_multiplier: float
-    driver: WebDriver
+    @property
+    def driver(self) -> "WebDriver":
+        """
+        Access the underlying Selenium WebDriver.
+
+        This property provides direct access to the Selenium driver when using
+        the Selenium backend. For Playwright backend, this raises NotImplementedError.
+
+        Returns:
+            WebDriver: The Selenium WebDriver instance
+
+        Raises:
+            NotImplementedError: If using Playwright backend
+        """
+        if self._driver_impl.backend_type == "selenium":
+            # Safe to access driver attribute when backend is Selenium
+            return self._driver_impl.driver  # type: ignore[attr-defined]
+        else:
+            raise NotImplementedError("Functionality cannot be run with Playwright yet.")
+
+    @property
+    def page(self):
+        """
+        Access the underlying Playwright Page.
+
+        This property provides direct access to the Playwright page when using
+        the Playwright backend. For Selenium backend, this raises NotImplementedError.
+
+        Returns:
+            Page: The Playwright Page instance
+
+        Raises:
+            NotImplementedError: If using Selenium backend
+        """
+        if self._driver_impl.backend_type == "playwright":
+            return self._driver_impl.page  # type: ignore[attr-defined]
+        else:
+            raise NotImplementedError("Functionality cannot be run with Selenium yet.")
 
     @abstractmethod
     def build_url(self, url: str, for_selenium: bool = True) -> str:
@@ -260,7 +309,7 @@ def screenshot_if(self, label: Optional[str]) -> Optional[str]:
     def get(self, url: str = ""):
         """Expand supplied relative URL and navigate to page using Selenium driver."""
         full_url = self.build_url(url)
-        return self.driver.get(full_url)
+        return self.navigate_to(full_url)
 
     @property
     def navigation(self) -> Component:
@@ -280,7 +329,7 @@ def wait_length(self, wait_type: WaitType) -> float:
         `timeout_multiplier` is used in production CI tests to reduce transient failures
         in a uniform way across test suites to expand waiting.
         """
-        return wait_type.default_length * self.timeout_multiplier
+        return self.timeout_handler(wait_type)
 
     def sleep_for(self, wait_type: WaitType) -> None:
         """Sleep on the Python client side for the specified wait_type.
@@ -297,9 +346,6 @@ def sleep_for_seconds(self, duration: float) -> None:
         """
         time.sleep(duration)
 
-    def timeout_for(self, wait_type: WaitType = DEFAULT_WAIT_TYPE, **kwd) -> float:
-        return self.wait_length(wait_type)
-
     def home(self) -> None:
         """Return to root Galaxy page and wait for some basic widgets to appear."""
         self.get()
@@ -315,41 +361,41 @@ def go_to_workflow_landing(self, uuid: str, public: Literal["false", "true"], cl
         path = f"workflow_landings/{uuid}?public={public}"
         if client_secret:
             path = f"{path}&client_secret={client_secret}"
-        self.driver.get(self.build_url(path))
+        self.navigate_to(self.build_url(path))
         self.components.workflow_run.run_workflow.wait_for_visible()
 
     def go_to_trs_search(self) -> None:
-        self.driver.get(self.build_url("workflows/trs_search"))
+        self.navigate_to(self.build_url("workflows/trs_search"))
         self.components.masthead._.wait_for_visible()
 
     def go_to_trs_by_id(self) -> None:
-        self.driver.get(self.build_url("workflows/trs_import"))
+        self.navigate_to(self.build_url("workflows/trs_import"))
         self.components.masthead._.wait_for_visible()
 
     def go_to_workflow_sharing(self, workflow_id: str) -> None:
-        self.driver.get(self.build_url(f"workflows/sharing?id={workflow_id}"))
+        self.navigate_to(self.build_url(f"workflows/sharing?id={workflow_id}"))
 
     def go_to_workflow_export(self, workflow_id: str) -> None:
-        self.driver.get(self.build_url(f"workflows/export?id={workflow_id}"))
+        self.navigate_to(self.build_url(f"workflows/export?id={workflow_id}"))
 
     def go_to_history_sharing(self, history_id: str) -> None:
-        self.driver.get(self.build_url(f"histories/sharing?id={history_id}"))
+        self.navigate_to(self.build_url(f"histories/sharing?id={history_id}"))
 
     def go_to_import_zip(self) -> None:
-        self.driver.get(self.build_url("import/zip"))
+        self.navigate_to(self.build_url("import/zip"))
         self.components.masthead._.wait_for_visible()
 
     def switch_to_main_panel(self):
-        self.driver.switch_to.frame(GALAXY_MAIN_FRAME_ID)
+        self.switch_to_frame(GALAXY_MAIN_FRAME_ID)
 
     @contextlib.contextmanager
     def local_storage(self, key: str, value: Union[float, str]):
         """Method decorator to modify localStorage for the scope of the supplied context."""
-        self.driver.execute_script(f"""window.localStorage.setItem("{key}", {value});""")
+        self.set_local_storage(key, value)
         try:
             yield
         finally:
-            self.driver.execute_script(f"""window.localStorage.removeItem("{key}");""")
+            self.remove_local_storage(key)
 
     @contextlib.contextmanager
     def main_panel(self):
@@ -358,16 +404,16 @@ def main_panel(self):
             self.switch_to_main_panel()
             yield
         finally:
-            self.driver.switch_to.default_content()
+            self.switch_to_default_content()
 
     @contextlib.contextmanager
     def visualization_panel(self):
         """Decorator to operate within the context of Galaxy's visualization frame."""
         try:
-            self.driver.switch_to.frame(GALAXY_VISUALIZATION_FRAME_ID)
+            self.switch_to_frame(GALAXY_VISUALIZATION_FRAME_ID)
             yield
         finally:
-            self.driver.switch_to.default_content()
+            self.switch_to_default_content()
 
     def api_get(self, endpoint, data=None, raw=False):
         data = data or {}
@@ -399,7 +445,7 @@ def _handle_response(self, response: requests.Response, raw: bool = False):
             return response.json() if response.content else None
 
     def get_galaxy_session(self):
-        for cookie in self.driver.get_cookies():
+        for cookie in self.get_cookies():
             if cookie["name"] == "galaxysession":
                 return cookie["value"]
 
@@ -480,7 +526,7 @@ def _latest_history_item(self) -> Optional[dict[str, Any]]:
             return None
 
     def wait_for_history(self, assert_ok=True):
-        def history_becomes_terminal(driver):
+        def history_becomes_terminal(driver=None):
             current_history_id = self.current_history_id()
             state = self.api_get(f"histories/{current_history_id}")["state"]
             if state not in ["running", "queued", "new", "ready"]:
@@ -488,8 +534,9 @@ def history_becomes_terminal(driver):
             else:
                 return None
 
-        timeout = self.timeout_for(wait_type=WAIT_TYPES.JOB_COMPLETION)
-        final_state = self.wait(timeout=timeout).until(history_becomes_terminal)
+        final_state = self._wait_on_custom(
+            history_becomes_terminal, "history to become terminal", wait_type=WAIT_TYPES.JOB_COMPLETION
+        )
         if assert_ok:
             assert final_state == "ok", final_state
         return final_state
@@ -518,6 +565,17 @@ def history_panel_item_component(self, history_item=None, hid=None, multi_histor
         assert hid
         return self.content_item_by_attributes(hid=hid, multi_history_panel=multi_history_panel)
 
+    def _wait_on(
+        self,
+        f,
+        on_str: Optional[str] = None,
+        timeout: Optional[float] = None,
+        wait_type: WaitType = WAIT_TYPES.JOB_COMPLETION,
+    ):
+        if timeout is None:
+            timeout = self.wait_length(wait_type=wait_type)
+        return wait_on(f, on_str or "custom wait", timeout)
+
     def wait_for_history_to_have_hid(self, history_id, hid):
         def get_hids():
             contents = self.api_get(f"histories/{history_id}/contents")
@@ -527,13 +585,16 @@ def get_hids():
                 raise Exception(f"Expected list of contents, got {type(contents)} for {contents}")
             return [d["hid"] for d in contents]
 
-        def history_has_hid(driver):
+        def history_has_hid(driver=None):
             hids = get_hids()
             return any(h == hid for h in hids)
 
-        timeout = self.timeout_for(wait_type=WAIT_TYPES.JOB_COMPLETION)
+        timeout = self.wait_length(wait_type=WAIT_TYPES.JOB_COMPLETION)
         try:
-            self.wait(timeout).until(history_has_hid)
+            if self.backend_type == "playwright":
+                wait_on(history_has_hid, f"history {history_id} to have hid {hid}", timeout)
+            else:
+                self.wait(timeout).until(history_has_hid)
         except SeleniumTimeoutException as e:
             hids = get_hids()
             message = f"Timeout waiting for history {history_id} to have hid {hid} - have hids {hids}"
@@ -563,8 +624,16 @@ def history_panel_wait_for_hid_visible(self, hid, allowed_force_refreshes=0, mul
     def hid_to_history_item(self, hid, current_history_id=None):
         if current_history_id is None:
             current_history_id = self.current_history_id()
-        contents = self.api_get(f"histories/{current_history_id}/contents")
-        history_item = [d for d in contents if d["hid"] == hid][0]
+        contents = self.api_get(f"histories/{current_history_id}/contents", raw=True)
+        if contents.status_code != 200:
+            raise Exception(
+                f"Error getting history contents when searching for hid {hid}: {contents.status_code} {contents.content}"
+            )
+        contents_json = contents.json()
+        matching_history_items = [d for d in contents_json if d["hid"] == hid]
+        if len(matching_history_items) == 0:
+            raise Exception(f"Failed to find hid {hid} in history {current_history_id} contents: {contents}.")
+        history_item = matching_history_items[0]
         return history_item
 
     def history_item_wait_for(self, history_item_selector, allowed_force_refreshes):
@@ -655,7 +724,7 @@ def select_grid_operation(self, item_name, option_label):
         popup_menu_button = target_item.find_element(By.CSS_SELECTOR, "button")
         popup_menu_button.click()
         popup_option = target_item.find_element(
-            By.CSS_SELECTOR, f"[data-description='grid operation {option_label.lower()}'"
+            By.CSS_SELECTOR, f"[data-description='grid operation {option_label.lower()}']"
         )
         popup_option.click()
 
@@ -665,9 +734,8 @@ def select_history_card_operation(self, card_name, action_selector, is_in_extra=
         if is_in_extra:
             target_card.find_element(By.CSS_SELECTOR, '[id^="g-card-extra-actions-history-"]').click()
 
-        action_chains = self.action_chains()
         action_selector = target_card.find_element(By.CSS_SELECTOR, action_selector)
-        action_chains.move_to_element(action_selector).click().perform()
+        self.move_to_and_click(action_selector)
 
     def edit_dataset_dbkey(self, dbkey_text):
         # precondition: need to be on the dataset edit component
@@ -723,17 +791,17 @@ def toggle_card_selection_in_list(self, list_selector, item_names):
         cards = self.components.histories.history_cards.all()
 
         for card in cards:
-            card_name = card.find_element(self.by.CSS_SELECTOR, '[id^="g-card-title-link-history-"]').text
+            card_name = card.find_element(By.CSS_SELECTOR, '[id^="g-card-title-link-history-"]').text
             if card_name in item_names:
-                checkbox = card.find_element(self.by.CSS_SELECTOR, 'input[id^="g-card-select-history-"]')
+                checkbox = card.find_element(By.CSS_SELECTOR, 'input[id^="g-card-select-history-"]')
                 # bootstrap vue checkbox seems to be hidden by label, but the label is not interactable
-                self.driver.execute_script("$(arguments[0]).click();", checkbox)
+                self.execute_script("$(arguments[0]).click();", checkbox)
 
     def check_advanced_search_filter(self, filter_name):
         filter_div = self.wait_for_selector(f"[data-description='filter {filter_name}']")
-        checkbox = filter_div.find_element(self.by.CSS_SELECTOR, "input")
+        checkbox = filter_div.find_element(By.CSS_SELECTOR, "input")
         # bootstrap vue checkbox seems to be hidden by label, but the label is not interactable
-        self.driver.execute_script("$(arguments[0]).click();", checkbox)
+        self.execute_script("$(arguments[0]).click();", checkbox)
 
     def published_grid_search_for(self, search_term=None):
         return self._inline_search_for(
@@ -884,13 +952,11 @@ def wait_for_logged_in(self):
                 raise NotLoggedInException(e, user_info, dom_message)
 
     def click_center(self):
-        action_chains = self.action_chains()
-        center_element = self.driver.find_element(By.CSS_SELECTOR, "#center")
-        action_chains.move_to_element(center_element).click().perform()
+        center_element = self.find_element_by_selector("#center")
+        self.move_to_and_click(center_element)
 
     def hover_over(self, target):
-        action_chains = self.action_chains()
-        action_chains.move_to_element(target).perform()
+        self.hover(target)
 
     def perform_single_upload(self, test_path, **kwd) -> HistoryEntry:
         before_latest_history_item = self.latest_history_entry()
@@ -1078,10 +1144,15 @@ def upload_build(self, tab="collection"):
             self.wait_for_selector_absent_or_hidden(build_selector)
 
     def upload_queue_local_file(self, test_path, tab_id="regular"):
-        self.wait_for_and_click_selector(f"div#{tab_id} button#btn-local")
-
-        file_upload = self.wait_for_selector(f'div#{tab_id} input[type="file"]')
-        file_upload.send_keys(test_path)
+        if self.backend_type == "playwright":
+            with self.page.expect_file_chooser() as fc_info:
+                self.wait_for_and_click_selector(f"div#{tab_id} button#btn-local")
+            file_chooser = fc_info.value
+            file_chooser.set_files(test_path)
+        else:
+            self.wait_for_and_click_selector(f"div#{tab_id} button#btn-local")
+            file_upload = self.wait_for_selector(f'div#{tab_id} input[type="file"]')
+            file_upload.send_keys(test_path)
 
     def upload_paste_data(self, pasted_content, tab_id="regular"):
         tab_locator = f"div#{tab_id}"
@@ -1321,7 +1392,7 @@ def workflow_editor_connect(self, source, sink, screenshot_partial=None):
             ac.perform()
             self.sleep_for(self.wait_types.UX_RENDER)
             self.screenshot(screenshot_partial)
-        drag_and_drop(self.driver, source_element, sink_element)
+        self.drag_and_drop(source_element, sink_element)
 
     def workflow_editor_source_sink_terminal_ids(self, source, sink):
         editor = self.components.workflow_editor
@@ -1471,8 +1542,7 @@ def workflow_editor_enter_column_definition(self, column_definition: ColumnDefin
         self.sleep_for(self.wait_types.UX_RENDER)
         if column_definition.optional:
             elem = editor.column_definition_optional_by_index(index=index).wait_for_present()
-            action_chains = self.action_chains()
-            action_chains.move_to_element(elem).click().perform()
+            self.move_to_and_click(elem)
             self.sleep_for(self.wait_types.UX_RENDER)
 
         if column_definition.default_value is not None:
@@ -1632,7 +1702,7 @@ def libraries_index_search_for(self, text):
         search_box = self.libraries_index_click_search()
         search_box.clear()
         search_box.send_keys(text)
-        value = search_box.get_attribute("value")
+        value = self.get_input_value(search_box)
         assert value == text, value
 
     def libraries_folder_create(self, name):
@@ -1698,9 +1768,14 @@ def wait_for_overlays_cleared(self):
         self.wait_for_selector_absent_or_hidden(".toast", wait_type=WAIT_TYPES.UX_POPUP)
 
     def clear_tooltips(self, selector_to_move="#center"):
-        action_chains = self.action_chains()
-        center_element = self.driver.find_element(By.CSS_SELECTOR, selector_to_move)
-        action_chains.move_to_element(center_element).perform()
+        if self.backend_type == "selenium":
+            action_chains = self.action_chains()
+            center_element = self.find_element_by_selector(selector_to_move)
+            action_chains.move_to_element(center_element).perform()
+        else:
+            page = self.page
+            center_element = page.locator(selector_to_move)
+            center_element.hover()
         self.wait_for_selector_absent_or_hidden(".b-tooltip", wait_type=WAIT_TYPES.UX_POPUP)
 
     def pages_index_table_elements(self):
@@ -1746,7 +1821,7 @@ def workflow_index_click_search(self):
 
     def workflow_index_get_current_filter(self):
         filter_element = self.components.workflows.search_box.wait_for_and_click()
-        return filter_element.get_attribute("value")
+        return self.get_input_value(filter_element)
 
     def workflow_index_search_for(self, search_term=None):
         return self._inline_search_for(
@@ -1765,7 +1840,7 @@ def workflow_rename(self, new_name, workflow_index=0):
         workflow.find_element(By.CSS_SELECTOR, ".g-card-rename").click()
         self.components.workflows.rename_input.wait_for_visible().clear()
         self.components.workflows.rename_input.wait_for_and_send_keys(new_name)
-        self.components.workflows.rename_input.wait_for_and_send_keys(self.keys.ENTER)
+        self.components.workflows.rename_input.wait_for_and_send_keys(Keys.ENTER)
 
     def workflow_delete_by_name(self, name):
         self.workflow_index_search_for(name)
@@ -1940,13 +2015,13 @@ def tool_open(self, tool_id, outer=False):
         else:
             tool_link = self.components.tool_panel.tool_link(tool_id=tool_id)
         tool_element = tool_link.wait_for_present()
-        self.driver.execute_script("arguments[0].scrollIntoView(true);", tool_element)
+        self.scroll_into_view(tool_element)
         tool_link.wait_for_and_click()
 
     def datasource_tool_open(self, tool_id):
         tool_link = self.components.tool_panel.data_source_tool_link(tool_id=tool_id)
         tool_element = tool_link.wait_for_present()
-        self.driver.execute_script("arguments[0].scrollIntoView(true);", tool_element)
+        self.scroll_into_view(tool_element)
         tool_link.wait_for_and_click()
 
     def run_environment_test_tool(self, inttest_value="42", select_storage: Optional[str] = None):
@@ -2035,13 +2110,6 @@ def click_activity_workflow(self):
     def click_button_new_workflow(self):
         self.wait_for_and_click(self.navigation.workflows.selectors.new_button)
 
-    def wait_for_sizzle_selector_clickable(self, selector):
-        element = self._wait_on(
-            sizzle.sizzle_selector_clickable(selector),
-            f"sizzle/jQuery selector [{selector}] to become clickable",
-        )
-        return element
-
     @retry_during_transitions
     def click_history_options(self):
         component = self.components.history_panel.options_button_icon
@@ -2058,14 +2126,7 @@ def click_history_option(self, option_label_or_component):
         self.click_history_options()
 
         if isinstance(option_label_or_component, str):
-            option_label = option_label_or_component
-            # Click labeled option
-            self.wait_for_visible(self.navigation.history_panel.options_menu)
-            menu_item_sizzle_selector = self.navigation.history_panel.options_menu_item(
-                option_label=option_label
-            ).selector
-            menu_selection_element = self.wait_for_sizzle_selector_clickable(menu_item_sizzle_selector)
-            menu_selection_element.click()
+            raise AssertionError("option_label_or_component must be a component, strings no longer supported")
         else:
             option_component = option_label_or_component
             option_component.wait_for_and_click()
@@ -2128,7 +2189,7 @@ def history_panel_rename(self, new_name):
         # a simple .clear() doesn't work here since we perform a .blur because of that
         self.aggressive_clear(editable_text_input_element)
         editable_text_input_element.send_keys(new_name)
-        editable_text_input_element.send_keys(self.keys.ENTER)
+        self.send_enter(editable_text_input_element)
         return editable_text_input_element
 
     def history_panel_name_input(self):
@@ -2233,7 +2294,7 @@ def history_panel_item_click_visualization_menu(self, hid):
     def history_panel_item_available_visualizations_elements(self, hid):
         # Precondition: viz menu has been opened with history_panel_item_click_visualization_menu
         viz_menu_selectors = f"{self.history_panel_item_selector(hid)} a.visualization-link"
-        return self.driver.find_elements(By.CSS_SELECTOR, viz_menu_selectors)
+        return self.find_elements_by_selector(viz_menu_selectors)
 
     def history_panel_item_get_tags(self, hid):
         item_component = self.history_panel_item_component(hid=hid)
@@ -2428,7 +2489,7 @@ def run_tour(self, path, skip_steps=None, sleep_on_steps=None, tour_callback=Non
             self.run_tour_step(step, i, tour_callback)
 
     def tour_wait_for_clickable_element(self, selector):
-        timeout = self.timeout_for(wait_type=WAIT_TYPES.JOB_COMPLETION)
+        timeout = self.wait_length(wait_type=WAIT_TYPES.JOB_COMPLETION)
         wait = self.wait(timeout=timeout)
         timeout_message = self._timeout_message(f"Tour CSS selector [{selector}] to become clickable")
         element = wait.until(
@@ -2438,7 +2499,7 @@ def tour_wait_for_clickable_element(self, selector):
         return element
 
     def tour_wait_for_element_present(self, selector):
-        timeout = self.timeout_for(wait_type=WAIT_TYPES.JOB_COMPLETION)
+        timeout = self.wait_length(wait_type=WAIT_TYPES.JOB_COMPLETION)
         wait = self.wait(timeout=timeout)
         timeout_message = self._timeout_message(f"Tour CSS selector [{selector}] to become present")
         element = wait.until(
@@ -2498,7 +2559,7 @@ def assert_absent_or_hidden_after_transitions(self, selector):
 
         See details above for more information about this.
         """
-        return self.assert_absent_or_hidden(selector)
+        return super().assert_absent_or_hidden_after_transitions(selector)
 
     def assert_tooltip_text(self, element, expected: Union[str, HasText], sleep: int = 0, click_away: bool = True):
         if hasattr(expected, "text"):
@@ -2579,7 +2640,7 @@ def run_tour_step(self, step, step_index: int, tour_callback):
     @retry_during_transitions
     def _tour_wait_for_and_click_element(self, selector):
         element = self.tour_wait_for_clickable_element(selector)
-        self.driver.execute_script("arguments[0].click();", element)
+        self.execute_script_click(element)
 
     @retry_during_transitions
     def wait_for_and_click_selector(self, selector):
@@ -2589,16 +2650,11 @@ def wait_for_and_click_selector(self, selector):
 
     @retry_during_transitions
     def wait_for_and_click(self, selector_template):
-        element = self.wait_for_clickable(selector_template)
-        element.click()
-        return element
+        return super().wait_for_and_click(selector_template)
 
     @retry_during_transitions
     def wait_for_and_double_click(self, selector_template):
-        element = self.wait_for_clickable(selector_template)
-        action_chains = self.action_chains()
-        action_chains.move_to_element(element).double_click().perform()
-        return element
+        return super().wait_for_and_double_click(selector_template)
 
     def set_history_annotation(self, annotation, clear_text=False):
         toggle = self.history_element("editor toggle")
@@ -2781,8 +2837,8 @@ def tutorial_mode_activate(self):
 
     def mouse_drag(
         self,
-        from_element: WebElement,
-        to_element: Optional[WebElement] = None,
+        from_element: WebElementProtocol,
+        to_element: Optional[WebElementProtocol] = None,
         from_offset=(0, 0),
         to_offset=(0, 0),
         via_offsets: Optional[list[tuple[int, int]]] = None,
diff --git a/lib/galaxy/selenium/playwright_element.py b/lib/galaxy/selenium/playwright_element.py
new file mode 100644
index 000000000000..2dd6fcfc340e
--- /dev/null
+++ b/lib/galaxy/selenium/playwright_element.py
@@ -0,0 +1,207 @@
+"""Playwright element wrapper that implements WebElementProtocol.
+
+This module provides PlaywrightElement, a wrapper around Playwright's ElementHandle
+that implements the WebElementProtocol interface, making it compatible with code
+written for Selenium's WebElement.
+"""
+
+from typing import (
+    Optional,
+    TYPE_CHECKING,
+)
+
+from playwright.sync_api import ElementHandle
+
+if TYPE_CHECKING:
+    from .web_element_protocol import WebElementProtocol
+
+
+class PlaywrightElement:
+    """
+    Wrapper around Playwright ElementHandle that implements WebElementProtocol.
+
+    This adapter makes Playwright's ElementHandle compatible with Selenium's
+    WebElement API, allowing the same code to work with both backends.
+    """
+
+    def __init__(self, element_handle: ElementHandle, driver):
+        """
+        Initialize PlaywrightElement wrapper.
+
+        Args:
+            element_handle: The Playwright ElementHandle to wrap
+            driver: The HasPlaywrightDriver instance (for find_element operations)
+        """
+        self._element = element_handle
+        self._driver = driver
+
+    @property
+    def text(self) -> str:
+        """
+        Get the visible text content of the element.
+
+        Maps to Playwright's text_content() method.
+        """
+        content = self._element.text_content()
+        return content.strip() if content is not None else ""
+
+    def click(self) -> None:
+        """Click the element."""
+        self._element.click()
+
+    def send_keys(self, *value: str) -> None:
+        """
+        Send keys to the element (type text).
+
+        Playwright requires elements to be focused before typing, so we click first.
+
+        Args:
+            *value: Text strings to type (will be concatenated)
+        """
+        text = "".join(str(v) for v in value)
+        # Playwright requires focus before typing
+        self._element.click()
+        self._element.type(text)
+
+    def clear(self) -> None:
+        """
+        Clear the text of an input or textarea element.
+
+        Uses Playwright's fill() method with empty string.
+        """
+        self._element.fill("")
+
+    def get_attribute(self, name: str) -> Optional[str]:
+        """
+        Get the value of an element attribute.
+
+        For input elements, "value" is special-cased to use input_value()
+        to match Selenium behavior.
+
+        Args:
+            name: The attribute name
+
+        Returns:
+            The attribute value, or None if not found
+        """
+        # Special case: for input elements, "value" needs to use input_value()
+        if name == "value":
+            try:
+                # Try to get input value (works for input/textarea/select)
+                return self._element.input_value()
+            except Exception:
+                # Fall back to regular attribute if not an input element
+                pass
+        return self._element.get_attribute(name)
+
+    def is_displayed(self) -> bool:
+        """
+        Check if the element is visible on the page.
+
+        Maps to Playwright's is_visible() method.
+        """
+        return self._element.is_visible()
+
+    def is_enabled(self) -> bool:
+        """
+        Check if the element is enabled (not disabled).
+
+        Maps to Playwright's is_enabled() method.
+        """
+        return self._element.is_enabled()
+
+    def submit(self) -> None:
+        """
+        Submit a form element.
+
+        Uses JavaScript to trigger form submission.
+        """
+        self._element.evaluate("(el) => el.form ? el.form.submit() : el.submit()")
+
+    def find_element(self, by: str = "id", value: Optional[str] = None) -> "WebElementProtocol":
+        """
+        Find a child element within this element.
+
+        Delegates to the driver's element finding logic.
+
+        Args:
+            by: The locator strategy (e.g., "id", "css selector")
+            value: The locator value
+
+        Returns:
+            A PlaywrightElement wrapping the found ElementHandle
+        """
+        # Convert the locator to Playwright selector
+        from .has_playwright_driver import HasPlaywrightDriver
+
+        if isinstance(self._driver, HasPlaywrightDriver):
+            if value is None:
+                raise ValueError("value parameter is required")
+            selector = self._driver._selenium_locator_to_playwright_selector(by, value)
+            # Use ElementHandle's query_selector to find within this element
+            found_element = self._element.query_selector(selector)
+            if found_element:
+                return PlaywrightElement(found_element, self._driver)
+            raise Exception(f"No element found with {by}='{value}'")
+
+        raise NotImplementedError("find_element within element not yet fully implemented")
+
+    def find_elements(self, by: str = "id", value: Optional[str] = None) -> list["WebElementProtocol"]:
+        """
+        Find all child elements matching the locator within this element.
+
+        Delegates to the driver's element finding logic.
+
+        Args:
+            by: The locator strategy (e.g., "css selector", "xpath")
+            value: The locator value
+
+        Returns:
+            List of PlaywrightElement instances
+        """
+        from .has_playwright_driver import HasPlaywrightDriver
+
+        if isinstance(self._driver, HasPlaywrightDriver):
+            if value is None:
+                raise ValueError("value parameter is required")
+            selector = self._driver._selenium_locator_to_playwright_selector(by, value)
+            found_elements = self._element.query_selector_all(selector)
+            return [PlaywrightElement(elem, self._driver) for elem in found_elements]
+
+        raise NotImplementedError("find_elements within element not yet fully implemented")
+
+    def content_frame(self):
+        """
+        Get the frame associated with this iframe/frame element.
+
+        Returns:
+            The Frame associated with this element, or None if not a frame element
+        """
+        return self._element.content_frame()
+
+    def value_of_css_property(self, property_name: str) -> str:
+        """
+        Get the value of a CSS property for this element.
+
+        Uses JavaScript's window.getComputedStyle() to get the computed value
+        of the specified CSS property.
+
+        Args:
+            property_name: The CSS property name (e.g., "color", "display", "font-size")
+
+        Returns:
+            The computed CSS property value as a string
+        """
+        value = self._element.evaluate(
+            "(element, propName) => window.getComputedStyle(element).getPropertyValue(propName)", property_name
+        )
+        return str(value) if value is not None else ""
+
+    # Expose the underlying ElementHandle for special cases
+    @property
+    def element_handle(self) -> ElementHandle:
+        """Get the underlying Playwright ElementHandle (for advanced use cases)."""
+        return self._element
+
+
+__all__ = ("PlaywrightElement",)
diff --git a/lib/galaxy/selenium/scripts/dump_tour.py b/lib/galaxy/selenium/scripts/dump_tour.py
index c87fb6628776..f1c34d6f4475 100755
--- a/lib/galaxy/selenium/scripts/dump_tour.py
+++ b/lib/galaxy/selenium/scripts/dump_tour.py
@@ -36,7 +36,7 @@ def __init__(self, driver_wrapper, output):
 
     def handle_step(self, step, step_index: int):
         time.sleep(0.5)
-        self.driver_wrapper.driver.save_screenshot(f"{self.output}/{step_index}.png")
+        self.driver_wrapper.save_screenshot(f"{self.output}/{step_index}.png")
         time.sleep(0.5)
 
 
diff --git a/lib/galaxy/selenium/sizzle.py b/lib/galaxy/selenium/sizzle.py
deleted file mode 100644
index f3421c697255..000000000000
--- a/lib/galaxy/selenium/sizzle.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""Utilities for using sizzle (jQuery-style) selectors with Selenium."""
-
-import json
-
-from selenium.common.exceptions import NoSuchElementException
-from selenium.webdriver.support.wait import WebDriverWait
-
-from .has_driver import exception_indicates_stale_element
-
-SIZZLE_LOAD_TIMEOUT = 5
-SIZZLE_URL = "//cdnjs.cloudflare.com/ajax/libs/sizzle/1.10.18/sizzle.js"
-
-
-def sizzle_selector_clickable(selector):
-    def ec(driver):
-        elements = find_elements_by_sizzle(driver, selector)
-        if not elements:
-            return False
-        element = elements[0]
-        try:
-            clickable = element.is_displayed() and element.is_enabled()
-        except Exception as e:
-            # Handle the case where the element is detached between when it is
-            # discovered and when it is checked - it is likely changing quickly
-            # and the next pass will be the final state. If not, this should be
-            # wrapped in a wait anyway - so no problems there. For other
-            # non-custom selectors I believe this all happens on the Selenium
-            # server and so there is likely no need to handle this case - they
-            # are effectively atomic.
-            if exception_indicates_stale_element(e):
-                return None
-
-            raise
-        if clickable:
-            return element
-        else:
-            return None
-
-    return ec
-
-
-def sizzle_presence_of_selector(selector):
-    def ec(driver):
-        elements = find_elements_by_sizzle(driver, selector)
-        if not elements:
-            return False
-        element = elements[0]
-        try:
-            displayed = element.is_displayed()
-        except Exception as e:
-            # See note above insizzle_selector_clickable about this exception.
-            if exception_indicates_stale_element(e):
-                return None
-
-            raise
-
-        if displayed:
-            return element
-        else:
-            return None
-
-    return ec
-
-
-def find_element_by_sizzle(driver, sizzle_selector: str):
-    """
-    Finds an element by sizzle selector.
-
-    :param sizzle_selector: The sizzle selector to use when finding element.
-    """
-    if elements := driver.find_elements_by_sizzle(sizzle_selector):
-        return elements[0]
-    else:
-        raise NoSuchElementException(f"Unable to locate element by Sizzle: {sizzle_selector}")
-
-
-def find_elements_by_sizzle(driver, sizzle_selector: str):
-    """
-    Finds elements by sizzle selector.
-
-    :param sizzle_selector: The sizzle selector to use when finding elements.
-    """
-    if not _is_sizzle_loaded(driver):
-        _inject_sizzle(driver, SIZZLE_URL, SIZZLE_LOAD_TIMEOUT)
-    elements = driver.execute_script(_make_sizzle_string(sizzle_selector))
-    return elements
-
-
-def _inject_sizzle(driver, sizzle_url, timeout):
-    script = f"""
-        if(typeof(window.$) != "undefined") {{
-            // Just reuse jQuery if it is available, avoids potential amd problems
-            // that have cropped up with Galaxy for instance.
-            window.Sizzle = window.$;
-        }} else {{
-            var _s = document.createElement("script");
-            _s.type = "text/javascript";
-            _s.src = "{sizzle_url}";
-            var _h = document.getElementsByTagName("head")[0];
-            _h.appendChild(_s);
-        }}
-    """
-    driver.execute_script(script)
-    wait = WebDriverWait(driver, timeout)
-    wait.until(lambda d: _is_sizzle_loaded(d), f"Can't inject Sizzle in {timeout} seconds")
-
-
-def _is_sizzle_loaded(driver):
-    script = 'return typeof(Sizzle) != "undefined";'
-    return driver.execute_script(script)
-
-
-def _make_sizzle_string(sizzle_selector):
-    # Use json.dumps to escape quotes
-    selector = json.dumps(sizzle_selector)
-    return f"return Sizzle({selector});"
-
-
-__all__ = (
-    "find_element_by_sizzle",
-    "find_elements_by_sizzle",
-    "sizzle_selector_clickable",
-    "sizzle_presence_of_selector",
-)
diff --git a/lib/galaxy/selenium/smart_components.py b/lib/galaxy/selenium/smart_components.py
index d5c50b71ad70..6392c39b2066 100644
--- a/lib/galaxy/selenium/smart_components.py
+++ b/lib/galaxy/selenium/smart_components.py
@@ -3,8 +3,6 @@
     TYPE_CHECKING,
 )
 
-from selenium.webdriver.support.select import Select
-
 from galaxy.navigation.components import (
     Component,
     Target,
@@ -15,8 +13,7 @@
 )
 
 if TYPE_CHECKING:
-    # TODO: ideally this after refactoring things this should be galaxy.selenium.has_driver.HasDriver -John
-    from galaxy.selenium.navigates_galaxy import NavigatesGalaxy
+    from galaxy.selenium.has_driver_protocol import HasDriverProtocol
 
 
 class SmartComponent:
@@ -27,7 +24,7 @@ class SmartComponent:
     click themselves, etc.... More "magic", but much cleaner usage.
     """
 
-    def __init__(self, component, has_driver: "NavigatesGalaxy"):
+    def __init__(self, component, has_driver: "HasDriverProtocol"):
         self._component = component
         self._has_driver = has_driver
 
@@ -49,7 +46,7 @@ def _wrap(self, simple_object):
 class SmartTarget:
     """Wrap a Target with driver aware methods."""
 
-    def __init__(self, target, has_driver: "NavigatesGalaxy"):
+    def __init__(self, target, has_driver: "HasDriverProtocol"):
         self._target = target
         self._has_driver = has_driver
 
@@ -69,7 +66,7 @@ def _wrap(self, simple_object):
             return simple_object
 
     def all(self):
-        return self._has_driver.driver.find_elements(*self._target.element_locator)
+        return self._has_driver.find_elements(self._target)
 
     def wait_for_element_count_of_at_least(self, n: int, **kwds):
         self._has_driver.wait_for_element_count_of_at_least(self._target, n, **kwds)
@@ -83,9 +80,6 @@ def wait_for_and_double_click(self, **kwds):
     def wait_for_visible(self, **kwds):
         return self._has_driver.wait_for_visible(self._target, **kwds)
 
-    def wait_for_select(self, **kwds):
-        return Select(self.wait_for_visible(**kwds))
-
     def wait_for_clickable(self, **kwds):
         return self._has_driver.wait_for_clickable(self._target, **kwds)
 
@@ -93,7 +87,8 @@ def wait_for_text(self, **kwds):
         return self._has_driver.wait_for_visible(self._target, **kwds).text
 
     def wait_for_value(self, **kwds):
-        return self._has_driver.wait_for_visible(self._target, **kwds).get_attribute("value")
+        element = self._has_driver.wait_for_visible(self._target, **kwds)
+        return self._has_driver.get_input_value(element)
 
     @property
     def is_displayed(self):
@@ -126,9 +121,8 @@ def assert_disabled(self, **kwds):
 
     def data_value(self, attribute: str):
         full_attribute = f"data-{attribute}"
-        attribute_value = (
-            self._has_driver.driver.find_element(*self._target.element_locator).get_attribute(full_attribute) or ""
-        )
+        element = self._has_driver.find_element(self._target)
+        attribute_value = element.get_attribute(full_attribute) or ""
         return attribute_value
 
     def assert_data_value(self, attribute: str, expected_value: str):
@@ -137,12 +131,17 @@ def assert_data_value(self, attribute: str, expected_value: str):
             raise AssertionError(message)
 
     def has_class(self, class_name):
-        classes_str = self._has_driver.driver.find_element(*self._target.element_locator).get_attribute("class") or ""
+        element = self._has_driver.find_element(self._target)
+        classes_str = element.get_attribute("class") or ""
         return class_name in classes_str.split(" ")
 
     def wait_for_and_send_keys(self, *text):
         self.wait_for_visible().send_keys(*text)
 
+    def wait_for_and_send_enter(self):
+        # TODO: add to unit test
+        self._has_driver.send_enter(self.wait_for_visible())
+
     def wait_for_and_clear_and_send_keys(self, *text):
         dom_element = self.wait_for_visible()
         dom_element.clear()
diff --git a/lib/galaxy/selenium/wait_methods_mixin.py b/lib/galaxy/selenium/wait_methods_mixin.py
new file mode 100644
index 000000000000..a8c56ec7200a
--- /dev/null
+++ b/lib/galaxy/selenium/wait_methods_mixin.py
@@ -0,0 +1,163 @@
+"""Mixin providing common wait methods that work across Selenium and Playwright."""
+
+from typing import Any
+
+from galaxy.navigation.components import Target
+
+
+class WaitMethodsMixin:
+    """
+    Mixin providing high-level wait methods.
+
+    This mixin abstracts wait operations to work with both Selenium and Playwright
+    by delegating to implementation-specific condition methods.
+    """
+
+    def wait_for_xpath(self, xpath: str, **kwds) -> Any:
+        """Wait for element to be present by XPath."""
+        return self._wait_on_condition_present(("xpath", xpath), f"XPATH selector [{xpath}] to become present", **kwds)
+
+    def wait_for_xpath_visible(self, xpath: str, **kwds) -> Any:
+        """Wait for element to be visible by XPath."""
+        return self._wait_on_condition_visible(("xpath", xpath), f"XPATH selector [{xpath}] to become visible", **kwds)
+
+    def wait_for_selector(self, selector: str, **kwds) -> Any:
+        """Wait for element to be present by CSS selector."""
+        return self._wait_on_condition_present(
+            ("css selector", selector), f"CSS selector [{selector}] to become present", **kwds
+        )
+
+    def wait_for_present(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be present using Target."""
+        return self._wait_on_condition_present(
+            selector_template.element_locator, f"{selector_template.description} to become present", **kwds
+        )
+
+    def wait_for_visible(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be visible using Target."""
+        return self._wait_on_condition_visible(
+            selector_template.element_locator, f"{selector_template.description} to become visible", **kwds
+        )
+
+    def wait_for_selector_visible(self, selector: str, **kwds) -> Any:
+        """Wait for element to be visible by CSS selector."""
+        return self._wait_on_condition_visible(
+            ("css selector", selector), f"CSS selector [{selector}] to become visible", **kwds
+        )
+
+    def wait_for_selector_clickable(self, selector: str, **kwds) -> Any:
+        """Wait for element to be clickable by CSS selector."""
+        return self._wait_on_condition_clickable(
+            ("css selector", selector), f"CSS selector [{selector}] to become clickable", **kwds
+        )
+
+    def wait_for_clickable(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be clickable using Target."""
+        return self._wait_on_condition_clickable(
+            selector_template.element_locator, f"{selector_template.description} to become clickable", **kwds
+        )
+
+    def wait_for_selector_absent_or_hidden(self, selector: str, **kwds) -> Any:
+        """Wait for element to be absent or hidden by CSS selector."""
+        return self._wait_on_condition_invisible(
+            ("css selector", selector), f"CSS selector [{selector}] to become absent or hidden", **kwds
+        )
+
+    def wait_for_selector_absent(self, selector: str, **kwds) -> Any:
+        """Wait for element to be absent by CSS selector."""
+        return self._wait_on_condition_absent(
+            ("css selector", selector), f"CSS selector [{selector}] to become absent", **kwds
+        )
+
+    def wait_for_element_count_of_at_least(self, selector_template: Target, n: int, **kwds) -> Any:
+        """Wait for at least N elements matching Target."""
+        return self._wait_on_condition_count(
+            selector_template.element_locator,
+            n,
+            f"{selector_template.description} to have at least {n} elements",
+            **kwds,
+        )
+
+    def wait_for_absent(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be absent using Target."""
+        return self._wait_on_condition_absent(
+            selector_template.element_locator, f"{selector_template.description} to become absent", **kwds
+        )
+
+    def wait_for_absent_or_hidden(self, selector_template: Target, **kwds) -> Any:
+        """Wait for element to be absent or hidden using Target."""
+        return self._wait_on_condition_invisible(
+            selector_template.element_locator, f"{selector_template.description} to become absent or hidden", **kwds
+        )
+
+    def wait_for_id(self, id: str, **kwds) -> Any:
+        """Wait for element to be present by ID."""
+        return self._wait_on_condition_present(("id", id), f"presence of DOM ID [{id}]", **kwds)
+
+    def wait_for_and_click(self, selector_template: Target, **kwds) -> Any:
+        """
+        Wait for element to be clickable and then click it.
+
+        Args:
+            selector_template: Target selector for the element
+            **kwds: Additional keyword arguments for wait (e.g., timeout)
+
+        Returns:
+            The clicked element
+        """
+        element = self.wait_for_clickable(selector_template, **kwds)
+        element.click()
+        return element
+
+    def wait_for_and_double_click(self, selector_template: Target, **kwds) -> Any:
+        """
+        Wait for element to be clickable and then double-click it.
+
+        Requires implementing class to provide double_click(element) method.
+
+        Args:
+            selector_template: Target selector for the element
+            **kwds: Additional keyword arguments for wait (e.g., timeout)
+
+        Returns:
+            The double-clicked element
+        """
+        element = self.wait_for_clickable(selector_template, **kwds)
+        self.double_click(element)
+        return element
+
+    # Abstract methods that must be implemented by subclasses
+    def _wait_on_condition_present(self, locator_tuple: tuple, message: str, **kwds) -> Any:
+        """Wait for element to be present in DOM."""
+        raise NotImplementedError()
+
+    def _wait_on_condition_visible(self, locator_tuple: tuple, message: str, **kwds) -> Any:
+        """Wait for element to be visible."""
+        raise NotImplementedError()
+
+    def _wait_on_condition_clickable(self, locator_tuple: tuple, message: str, **kwds) -> Any:
+        """Wait for element to be clickable."""
+        raise NotImplementedError()
+
+    def _wait_on_condition_invisible(self, locator_tuple: tuple, message: str, **kwds) -> Any:
+        """Wait for element to be invisible or absent."""
+        raise NotImplementedError()
+
+    def _wait_on_condition_absent(self, locator_tuple: tuple, message: str, **kwds) -> Any:
+        """Wait for element to be completely absent from DOM."""
+        raise NotImplementedError()
+
+    def _wait_on_condition_count(self, locator_tuple: tuple, n: int, message: str, **kwds) -> Any:
+        """Wait for at least N elements."""
+        raise NotImplementedError()
+
+    def _wait_on_custom(self, condition_func, message: str, **kwds) -> Any:
+        """Wait on custom condition function."""
+        raise NotImplementedError()
+
+    def double_click(self, element) -> None:
+        """Double-click an element (must be implemented by subclass)."""
+        raise NotImplementedError()
+
+
+__all__ = ("WaitMethodsMixin",)
diff --git a/lib/galaxy/selenium/web_element_protocol.py b/lib/galaxy/selenium/web_element_protocol.py
new file mode 100644
index 000000000000..238a955b6f71
--- /dev/null
+++ b/lib/galaxy/selenium/web_element_protocol.py
@@ -0,0 +1,82 @@
+"""Protocol for unified WebElement interface.
+
+This module defines a Protocol that abstracts the common WebElement API
+used in navigates_galaxy.py and tests. Both Selenium WebElement and our
+PlaywrightElement wrapper implement this protocol.
+"""
+
+from typing import (
+    Optional,
+    Protocol,
+    runtime_checkable,
+)
+
+
+@runtime_checkable
+class WebElementProtocol(Protocol):
+    """
+    Protocol defining the WebElement API used in Galaxy Selenium tests.
+
+    This protocol captures the subset of WebElement methods that are actually
+    used in navigates_galaxy.py and test code. Both Selenium's WebElement and
+    our PlaywrightElement wrapper implement this protocol.
+
+    Methods used (from navigates_galaxy.py usage analysis):
+    - .text (31 uses) - Get visible text content
+    - .click() (39 uses) - Click the element
+    - .send_keys() (28 uses) - Type text into element
+    - .clear() (21 uses) - Clear input field
+    - .get_attribute() (7 uses) - Get element attribute
+    - .is_displayed() (4 uses) - Check if element is visible
+    - .submit() (8 uses) - Submit form
+    - .find_element() (33 uses) - Find child element
+    - .find_elements() (25 uses) - Find child elements
+    """
+
+    @property
+    def text(self) -> str:
+        """Get the visible text content of the element."""
+        ...
+
+    def click(self) -> None:
+        """Click the element."""
+        ...
+
+    def send_keys(self, *value: str) -> None:
+        """Send keys to the element (type text)."""
+        ...
+
+    def clear(self) -> None:
+        """Clear the text of an input or textarea element."""
+        ...
+
+    def get_attribute(self, name: str) -> Optional[str]:
+        """Get the value of an element attribute."""
+        ...
+
+    def is_displayed(self) -> bool:
+        """Check if the element is visible on the page."""
+        ...
+
+    def is_enabled(self) -> bool:
+        """Check if the element is enabled (not disabled)."""
+        ...
+
+    def submit(self) -> None:
+        """Submit a form element."""
+        ...
+
+    def find_element(self, by: str = "id", value: Optional[str] = None) -> "WebElementProtocol":
+        """Find a child element within this element."""
+        ...
+
+    def find_elements(self, by: str = "id", value: Optional[str] = None) -> list["WebElementProtocol"]:
+        """Find all child elements matching the locator within this element."""
+        ...
+
+    def value_of_css_property(self, property_name: str) -> str:
+        """Get the value of a CSS property for this element."""
+        ...
+
+
+__all__ = ("WebElementProtocol",)
diff --git a/lib/galaxy/tool_util/verify/wait.py b/lib/galaxy/tool_util/verify/wait.py
index 4fbe6ad3373f..c581e1a953b9 100644
--- a/lib/galaxy/tool_util/verify/wait.py
+++ b/lib/galaxy/tool_util/verify/wait.py
@@ -1,50 +1,9 @@
 """Abstraction for waiting on API conditions to become true."""
 
-import time
-from typing import (
-    Callable,
-    Optional,
-    Union,
+from galaxy.util.wait import (
+    timeout_type,
+    TimeoutAssertionError,
+    wait_on,
 )
 
-DEFAULT_POLLING_BACKOFF = 0
-DEFAULT_POLLING_DELTA = 0.25
-
-TIMEOUT_MESSAGE_TEMPLATE = "Timed out after {} seconds waiting on {}."
-timeout_type = Union[int, float]
-
-
-def wait_on(
-    function: Callable,
-    desc: str,
-    timeout: timeout_type,
-    delta: timeout_type = DEFAULT_POLLING_DELTA,
-    polling_backoff: timeout_type = DEFAULT_POLLING_BACKOFF,
-    sleep_: Optional[Callable] = None,
-):
-    """Wait for function to return non-None value.
-
-    Grow the polling interval (initially ``delta`` defaulting to 0.25 seconds)
-    incrementally by the supplied ``polling_backoff`` (defaulting to 0).
-
-    Throw a TimeoutAssertionError if the supplied timeout is reached without
-    supplied function ever returning a non-None value.
-    """
-    sleep = sleep_ or time.sleep
-    total_wait = 0.0
-    while True:
-        if total_wait > timeout:
-            raise TimeoutAssertionError(TIMEOUT_MESSAGE_TEMPLATE.format(total_wait, desc))
-        value = function()
-        if value is not None:
-            return value
-        total_wait += delta
-        sleep(delta)
-        delta += polling_backoff
-
-
-class TimeoutAssertionError(AssertionError):
-    """Derivative of AssertionError indicating wait_on exceeded max time."""
-
-    def __init__(self, message):
-        super().__init__(message)
+__all__ = ("wait_on", "TimeoutAssertionError", "timeout_type")
diff --git a/lib/galaxy/util/wait.py b/lib/galaxy/util/wait.py
new file mode 100644
index 000000000000..4fbe6ad3373f
--- /dev/null
+++ b/lib/galaxy/util/wait.py
@@ -0,0 +1,50 @@
+"""Abstraction for waiting on API conditions to become true."""
+
+import time
+from typing import (
+    Callable,
+    Optional,
+    Union,
+)
+
+DEFAULT_POLLING_BACKOFF = 0
+DEFAULT_POLLING_DELTA = 0.25
+
+TIMEOUT_MESSAGE_TEMPLATE = "Timed out after {} seconds waiting on {}."
+timeout_type = Union[int, float]
+
+
+def wait_on(
+    function: Callable,
+    desc: str,
+    timeout: timeout_type,
+    delta: timeout_type = DEFAULT_POLLING_DELTA,
+    polling_backoff: timeout_type = DEFAULT_POLLING_BACKOFF,
+    sleep_: Optional[Callable] = None,
+):
+    """Wait for function to return non-None value.
+
+    Grow the polling interval (initially ``delta`` defaulting to 0.25 seconds)
+    incrementally by the supplied ``polling_backoff`` (defaulting to 0).
+
+    Throw a TimeoutAssertionError if the supplied timeout is reached without
+    supplied function ever returning a non-None value.
+    """
+    sleep = sleep_ or time.sleep
+    total_wait = 0.0
+    while True:
+        if total_wait > timeout:
+            raise TimeoutAssertionError(TIMEOUT_MESSAGE_TEMPLATE.format(total_wait, desc))
+        value = function()
+        if value is not None:
+            return value
+        total_wait += delta
+        sleep(delta)
+        delta += polling_backoff
+
+
+class TimeoutAssertionError(AssertionError):
+    """Derivative of AssertionError indicating wait_on exceeded max time."""
+
+    def __init__(self, message):
+        super().__init__(message)
diff --git a/lib/galaxy_test/selenium/conftest.py b/lib/galaxy_test/selenium/conftest.py
index 4e717b1f1a03..e257637681ee 100644
--- a/lib/galaxy_test/selenium/conftest.py
+++ b/lib/galaxy_test/selenium/conftest.py
@@ -2,13 +2,14 @@
 
 import pytest
 
-from galaxy_test.driver.driver_util import GalaxyTestDriver
 from galaxy_test.selenium.framework import SeleniumTestCase
 
 
 @pytest.fixture(scope="session")
 def real_driver():
     if not os.environ.get("GALAXY_TEST_ENVIRONMENT_CONFIGURED"):
+        from galaxy_test.driver.driver_util import GalaxyTestDriver
+
         driver = GalaxyTestDriver()
         driver.setup(SeleniumTestCase)
         try:
diff --git a/lib/galaxy_test/selenium/framework.py b/lib/galaxy_test/selenium/framework.py
index a7bc6032edec..b8399ed2ee24 100644
--- a/lib/galaxy_test/selenium/framework.py
+++ b/lib/galaxy_test/selenium/framework.py
@@ -12,6 +12,7 @@
 )
 from typing import (
     Any,
+    cast,
     Optional,
     TYPE_CHECKING,
 )
@@ -28,8 +29,13 @@
 from galaxy.selenium.axe_results import assert_baseline_accessible
 from galaxy.selenium.context import GalaxySeleniumContext
 from galaxy.selenium.has_driver import DEFAULT_AXE_SCRIPT_URL
+from galaxy.selenium.has_driver_protocol import (
+    BackendType,
+    HasDriverProtocol,
+)
 from galaxy.selenium.navigates_galaxy import (
     exception_seems_to_indicate_transition,
+    galaxy_timeout_handler,
     NavigatesGalaxy,
     retry_during_transitions,
 )
@@ -65,6 +71,61 @@
 except ImportError:
     GalaxyTestDriver = None  # type: ignore[misc,assignment]
 
+
+def _load_config_file() -> None:
+    """
+    Load test configuration from YAML file if GALAXY_TEST_END_TO_END_CONFIG is set.
+
+    This matches the configuration format used for Jupyter-based testing.
+    Explicit environment variables take precedence over config file values.
+    """
+    config_file = os.environ.get("GALAXY_TEST_END_TO_END_CONFIG")
+    if not config_file:
+        return
+
+    # Expand user paths like ~/config.yml
+    config_file = os.path.expanduser(config_file)
+
+    if not os.path.exists(config_file):
+        raise FileNotFoundError(
+            f"GALAXY_TEST_END_TO_END_CONFIG is set to '{config_file}' but file does not exist. "
+            f"Please check the path or unset GALAXY_TEST_END_TO_END_CONFIG."
+        )
+
+    try:
+        with open(config_file) as f:
+            config = yaml.safe_load(f)
+    except Exception as e:
+        raise ValueError(f"Failed to load GALAXY_TEST_END_TO_END_CONFIG '{config_file}': {e}") from e
+
+    if not isinstance(config, dict):
+        raise ValueError(
+            f"GALAXY_TEST_END_TO_END_CONFIG '{config_file}' must contain a YAML dictionary, got {type(config)}"
+        )
+
+    # Map config keys to environment variables
+    # Only set if not already present (explicit env vars take precedence)
+    key_mapping = {
+        "local_galaxy_url": "GALAXY_TEST_EXTERNAL",
+        "login_email": "GALAXY_TEST_SELENIUM_USER_EMAIL",
+        "login_password": "GALAXY_TEST_SELENIUM_USER_PASSWORD",
+        "admin_api_key": "GALAXY_TEST_SELENIUM_ADMIN_API_KEY",
+        "admin_email": "GALAXY_TEST_SELENIUM_ADMIN_USER_EMAIL",
+        "admin_password": "GALAXY_TEST_SELENIUM_ADMIN_USER_PASSWORD",
+        "selenium_galaxy_url": "GALAXY_TEST_EXTERNAL_FROM_SELENIUM",
+    }
+
+    for config_key, env_var in key_mapping.items():
+        if config_key in config and config[config_key] is not None:
+            if env_var not in os.environ:
+                os.environ[env_var] = str(config[config_key])
+
+    os.environ["GALAXY_TEST_ENVIRONMENT_CONFIGURED"] = "1"
+
+
+# Load config file before reading environment variables
+_load_config_file()
+
 DEFAULT_TIMEOUT_MULTIPLIER = 1
 DEFAULT_TEST_ERRORS_DIRECTORY = os.path.abspath("database/test_errors")
 DEFAULT_SELENIUM_HEADLESS = "auto"
@@ -76,6 +137,8 @@
 TIMEOUT_MULTIPLIER = float(os.environ.get("GALAXY_TEST_TIMEOUT_MULTIPLIER", DEFAULT_TIMEOUT_MULTIPLIER))
 GALAXY_TEST_ERRORS_DIRECTORY = os.environ.get("GALAXY_TEST_ERRORS_DIRECTORY", DEFAULT_TEST_ERRORS_DIRECTORY)
 GALAXY_TEST_SCREENSHOTS_DIRECTORY = os.environ.get("GALAXY_TEST_SCREENSHOTS_DIRECTORY", None)
+# Driver backend can be ["selenium", "playwright"]
+GALAXY_TEST_DRIVER_BACKEND = os.environ.get("GALAXY_TEST_DRIVER_BACKEND", "selenium")
 # Test browser can be ["CHROME", "FIREFOX"]
 GALAXY_TEST_SELENIUM_BROWSER = os.environ.get("GALAXY_TEST_SELENIUM_BROWSER", driver_factory.DEFAULT_SELENIUM_BROWSER)
 GALAXY_TEST_SELENIUM_REMOTE = os.environ.get("GALAXY_TEST_SELENIUM_REMOTE", driver_factory.DEFAULT_SELENIUM_REMOTE)
@@ -108,6 +171,56 @@
 """
 
 
+def selenium_only(reason: str = "Test requires Selenium-specific functionality"):
+    """Mark test as Selenium-only, skip if running with Playwright backend.
+
+    Args:
+        reason: Explanation for why this test requires Selenium
+
+    Usage:
+        @selenium_only("Uses Selenium Select class which requires tag_name attribute")
+        def test_custom_select_element(self):
+            ...
+    """
+
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            backend = os.environ.get("GALAXY_TEST_DRIVER_BACKEND", "selenium")
+            if backend == "playwright":
+                raise unittest.SkipTest(f"Selenium-only test: {reason}")
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def playwright_only(reason: str = "Test requires Playwright-specific functionality"):
+    """Mark test as Playwright-only, skip if running with Selenium backend.
+
+    Args:
+        reason: Explanation for why this test requires Playwright
+
+    Usage:
+        @playwright_only("Uses Playwright-specific network interception")
+        def test_network_request_logging(self):
+            ...
+    """
+
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            backend = os.environ.get("GALAXY_TEST_DRIVER_BACKEND", "selenium")
+            if backend == "selenium":
+                raise unittest.SkipTest(f"Playwright-only test: {reason}")
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 def managed_history(f):
     """Ensure a Selenium test has a distinct, named history.
 
@@ -162,9 +275,9 @@ def write_file(name, content, raw=False):
         # Try to use the Selenium driver to recover more debug information, but don't
         # throw an exception if the connection is broken in some way.
         try:
-            self.driver.save_screenshot(os.path.join(target_directory, "last.png"))
-            write_file("page_source.txt", self.driver.page_source)
-            write_file("DOM.txt", self.driver.execute_script("return document.documentElement.outerHTML"))
+            self.save_screenshot(os.path.join(target_directory, "last.png"))
+            write_file("page_source.txt", self.page_source)
+            write_file("DOM.txt", self.execute_script("return document.documentElement.outerHTML"))
         except Exception:
             formatted_exception = traceback.format_exc()
             print(f"Failed to use test driver to recover debug information from Selenium: {formatted_exception}")
@@ -241,8 +354,8 @@ def exception_is_assertion_or_transition(e: Exception) -> bool:
 class TestSnapshot:
     __test__ = False  # Prevent pytest from discovering this class (issue #12071)
 
-    def __init__(self, driver, index: int, description: str):
-        self.screenshot_binary = driver.get_screenshot_as_png()
+    def __init__(self, has_driver: HasDriverProtocol, index: int, description: str):
+        self.screenshot_binary = has_driver.get_screenshot_as_png()
         self.description = description
         self.index = index
         self.exc = traceback.format_exc()
@@ -298,8 +411,6 @@ class TestWithSeleniumMixin(GalaxyTestSeleniumContext, UsesApiTestCaseMixin, Use
     # tests or may be required if you have no external internet access
     axe_skip = GALAXY_TEST_SKIP_AXE
 
-    timeout_multiplier = TIMEOUT_MULTIPLIER
-
     def assert_baseline_accessibility(self):
         axe_results = self.axe_eval()
         assert_baseline_accessible(axe_results)
@@ -347,7 +458,7 @@ def snapshot(self, description: str):
         This information will be automatically written to a per-test directory created for all
         failed tests.
         """
-        self.snapshots.append(TestSnapshot(self.driver, len(self.snapshots), description))
+        self.snapshots.append(TestSnapshot(self, len(self.snapshots), description))
 
     def get_download_path(self):
         """Returns default download path"""
@@ -393,13 +504,14 @@ def reset_driver_and_session(self):
         self._try_setup_with_driver()
 
     def setup_driver_and_session(self):
-        self.display = driver_factory.virtual_display_if_enabled(use_virtual_display())
+        virtual_display_enabled = use_virtual_display()
+        self.display = driver_factory.virtual_display_if_enabled(virtual_display_enabled)
         self.configured_driver = get_configured_driver()
         self._setup_galaxy_logging()
 
     def _setup_galaxy_logging(self):
         self.home()
-        self.driver.execute_script(SETUP_LOGGING_JS)
+        self.execute_script(SETUP_LOGGING_JS)
 
     def login(self):
         if GALAXY_TEST_SELENIUM_USER_EMAIL:
@@ -417,18 +529,24 @@ def login(self):
 
     def tear_down_driver(self):
         exception = None
-        try:
-            self.driver.close()
-        except Exception as e:
-            if "cannot kill Chrome" in str(e):
-                print(f"Ignoring likely harmless error in Selenium shutdown {e}")
-            else:
+        if self.backend_type == "playwright":
+            try:
+                self.quit()
+            except Exception as e:
                 exception = e
+        else:
+            try:
+                self.close()
+            except Exception as e:
+                if "cannot kill Chrome" in str(e):
+                    print(f"Ignoring likely harmless error in Selenium shutdown {e}")
+                else:
+                    exception = e
 
-        try:
-            self.display.stop()
-        except Exception as e:
-            exception = e
+            try:
+                self.display.stop()
+            except Exception as e:
+                exception = e
 
         if exception is not None:
             raise exception
@@ -705,12 +823,16 @@ def default_web_host_for_selenium_tests():
 
 
 def get_configured_driver():
+    backend_type = GALAXY_TEST_DRIVER_BACKEND
+    assert backend_type in ["selenium", "playwright"], f"Unknown GALAXY_TEST_DRIVER_BACKEND [{backend_type}]"
     return driver_factory.ConfiguredDriver(
+        galaxy_timeout_handler(TIMEOUT_MULTIPLIER),
         browser=GALAXY_TEST_SELENIUM_BROWSER,
         remote=asbool(GALAXY_TEST_SELENIUM_REMOTE),
         remote_host=GALAXY_TEST_SELENIUM_REMOTE_HOST,
         remote_port=GALAXY_TEST_SELENIUM_REMOTE_PORT,
         headless=headless_selenium(),
+        backend_type=cast(BackendType, backend_type),
     )
 
 
@@ -731,19 +853,21 @@ def headless_selenium():
 
 
 def use_virtual_display():
+    using_selenium = GALAXY_TEST_DRIVER_BACKEND == "selenium"
     if asbool(GALAXY_TEST_SELENIUM_REMOTE):
         return False
 
     if GALAXY_TEST_SELENIUM_HEADLESS == "auto":
         if (
-            driver_factory.is_virtual_display_available()
+            using_selenium
+            and driver_factory.is_virtual_display_available()
             and not driver_factory.get_local_browser(GALAXY_TEST_SELENIUM_BROWSER) == "CHROME"
         ):
             return True
         else:
             return False
     else:
-        return asbool(GALAXY_TEST_SELENIUM_HEADLESS)
+        return using_selenium and asbool(GALAXY_TEST_SELENIUM_HEADLESS)
 
 
 class SeleniumSessionGetPostMixin:
diff --git a/lib/galaxy_test/selenium/jupyter/galaxy_selenium_context.yml.sample b/lib/galaxy_test/selenium/jupyter/galaxy_selenium_context.yml.sample
index 30036506c749..8c02fda0c337 100644
--- a/lib/galaxy_test/selenium/jupyter/galaxy_selenium_context.yml.sample
+++ b/lib/galaxy_test/selenium/jupyter/galaxy_selenium_context.yml.sample
@@ -6,3 +6,7 @@ login_password: mycoolpassw0rd
 #selenium_galaxy_url:
 # Setup an admin API key if needed for testing populators & fixture creation.
 #admin_api_key:
+
+# Some selenium tests depend on an admin username and password
+#admin_email: admin@example.com
+#admin_password: mycoolpassw0rdbutlongerbecuaseiamanadmin
diff --git a/lib/galaxy_test/selenium/test_admin_app.py b/lib/galaxy_test/selenium/test_admin_app.py
index 8b48eac653be..33d210a32b87 100644
--- a/lib/galaxy_test/selenium/test_admin_app.py
+++ b/lib/galaxy_test/selenium/test_admin_app.py
@@ -1,6 +1,7 @@
 from galaxy_test.base.decorators import requires_admin
 from galaxy_test.base.populators import flakey
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -9,6 +10,7 @@
 class TestAdminApp(SeleniumTestCase):
     run_as_admin = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_html_allowlist(self):
@@ -37,6 +39,7 @@ def test_html_allowlist(self):
         self.sleep_for(self.wait_types.UX_RENDER)
         self.screenshot("admin_allowlist_converter_sanitized")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @flakey
     @requires_admin
@@ -100,6 +103,7 @@ def test_admin_toolshed(self):
         self.sleep_for(self.wait_types.UX_TRANSITION)
         self.screenshot("admin_toolshed_repo_uninstalled")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_admin_dependencies_display(self):
@@ -122,6 +126,7 @@ def test_admin_dependencies_display(self):
         admin_component.manage_dependencies.unused_paths.wait_for_visible()
         self.screenshot("admin_dependencies_unused")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_admin_jobs_display(self):
@@ -150,6 +155,7 @@ def test_admin_jobs_display(self):
         # And confirm that it has toggled back to what it was.
         assert lock_label.wait_for_text() == original_label
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_admin_server_display(self):
@@ -178,6 +184,7 @@ def test_admin_server_display(self):
         assert title_element.text == "Local Data"
         self.screenshot("admin_local_data")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_admin_user_display(self):
@@ -204,6 +211,7 @@ def test_admin_user_display(self):
         admin_component.roles_grid.wait_for_visible()
         self.screenshot("admin_roles")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_admin_data_manager(self):
diff --git a/lib/galaxy_test/selenium/test_archive_explorer.py b/lib/galaxy_test/selenium/test_archive_explorer.py
index d210053229be..24a7dfd95c78 100644
--- a/lib/galaxy_test/selenium/test_archive_explorer.py
+++ b/lib/galaxy_test/selenium/test_archive_explorer.py
@@ -2,6 +2,7 @@
 
 from galaxy.util.unittest_utils import skip_if_github_down
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesHistoryItemAssertions,
@@ -13,6 +14,7 @@
 
 
 class TestArchiveExplorer(SeleniumTestCase, UsesHistoryItemAssertions):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_import_from_local_zip(self):
         self.login()
@@ -41,6 +43,7 @@ def test_explore_from_local_upload(self):
         self.start_importing_files()
         self.expect_history_item_to_be_imported(hid=1, name="README.txt")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @skip_if_github_down
     def test_import_from_remote_zip(self):
diff --git a/lib/galaxy_test/selenium/test_change_password.py b/lib/galaxy_test/selenium/test_change_password.py
index 8ab3e9f8e311..eedd345dc726 100644
--- a/lib/galaxy_test/selenium/test_change_password.py
+++ b/lib/galaxy_test/selenium/test_change_password.py
@@ -1,10 +1,14 @@
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
 
 
 class TestChangePassword(SeleniumTestCase):
+    @selenium_only(
+        "Not yet migrated to support Playwright backend - playwright._impl._errors.Error: Page.goto: net::ERR_ABORTED at http://localhost:8081/"
+    )
     @selenium_test
     def test_change_password(self):
         self.home()
diff --git a/lib/galaxy_test/selenium/test_collection_builders.py b/lib/galaxy_test/selenium/test_collection_builders.py
index 7164d4ea9aa1..54705f98ca47 100644
--- a/lib/galaxy_test/selenium/test_collection_builders.py
+++ b/lib/galaxy_test/selenium/test_collection_builders.py
@@ -1,5 +1,6 @@
 from .framework import (
     managed_history,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -8,6 +9,7 @@
 class TestCollectionBuilders(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_list_simple_hidden(self):
@@ -19,6 +21,7 @@ def test_build_list_simple_hidden(self):
         self.collection_builder_create()
         self._wait_for_hid_visible(3)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_list_and_show_items(self):
@@ -31,6 +34,7 @@ def test_build_list_and_show_items(self):
         self.collection_builder_create()
         self._wait_for_hid_visible(3)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_paired_list_auto_matched(self):
@@ -53,6 +57,7 @@ def test_build_paired_list_auto_matched(self):
         self._wait_for_hid_visible(3)
         self._wait_for_hid_visible(4)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_paired_list_manual_matched(self):
@@ -80,6 +85,7 @@ def test_build_paired_list_manual_matched(self):
         self._wait_for_hid_visible(3)
         self._wait_for_hid_visible(4)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_paired_unpaired_list(self):
@@ -98,6 +104,7 @@ def test_build_paired_unpaired_list(self):
         self.collection_builder_create()
         self._wait_for_hid_visible(7)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_list_of_lists(self):
@@ -120,6 +127,7 @@ def test_build_list_of_lists(self):
         self.collection_builder_create()
         self._wait_for_hid_visible(9)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_paired_list_show_original(self):
@@ -147,6 +155,7 @@ def test_build_paired_list_show_original(self):
         self._wait_for_hid_visible(3)
         self._wait_for_hid_visible(4)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_build_simple_list_via_rules_hidden(self):
diff --git a/lib/galaxy_test/selenium/test_collection_edit.py b/lib/galaxy_test/selenium/test_collection_edit.py
index 95c604163f4b..4f3e8d4e589a 100644
--- a/lib/galaxy_test/selenium/test_collection_edit.py
+++ b/lib/galaxy_test/selenium/test_collection_edit.py
@@ -1,5 +1,6 @@
 from .framework import (
     managed_history,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -8,6 +9,9 @@
 class TestCollectionEdit(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only(
+        "Not yet migrated to support Playwright backend - Timeout waiting on CSS selector [.collection-edit-change-datatype-nav] to become clickable."
+    )
     @selenium_test
     @managed_history
     def test_change_dbkey_simple_list(self):
@@ -25,6 +29,9 @@ def test_change_dbkey_simple_list(self):
         self.navigate_to_database_tab()
         self.check_current_data_value(dataNew)
 
+    @selenium_only(
+        "Not yet migrated to support Playwright backend - Timeout waiting on CSS selector [.collection-edit-change-datatype-nav] to become clickable."
+    )
     @selenium_test
     @managed_history
     def test_change_datatype_simple_list(self):
@@ -46,7 +53,7 @@ def test_change_datatype_simple_list(self):
         self.history_panel_ensure_showing_item_details(1)
         item = self.history_panel_item_component(hid=1)
         item.datatype.wait_for_visible()
-        self._wait_on(lambda _: item.datatype.wait_for_text() == dataNew)
+        self._wait_on(lambda *_: item.datatype.wait_for_text() == dataNew)
 
     def _create_simple_list_collection(self, filename, ext):
         self.perform_upload(self.get_filename(filename), ext=ext)
@@ -73,13 +80,13 @@ def check_current_data_value(self, dataValue):
     def change_dbkey_value_and_click_submit(self, dataValue, dataNew):
         self._edit_attributes.data_value(data_change=dataValue).wait_for_and_click()
         self._edit_attributes.genome_select_search.wait_for_and_send_keys(dataNew)
-        self._edit_attributes.genome_select_search.wait_for_and_send_keys(self.keys.ENTER)
+        self._edit_attributes.genome_select_search.wait_for_and_send_enter()
         self._edit_attributes.save_dbkey_btn.wait_for_and_click()
 
     def change_datatype_value_and_click_submit(self, dataValue, dataNew):
         self._edit_attributes.data_value(data_change=dataValue).wait_for_and_click()
         self._edit_attributes.datatype_select_search.wait_for_and_send_keys(dataNew)
-        self._edit_attributes.datatype_select_search.wait_for_and_send_keys(self.keys.ENTER)
+        self._edit_attributes.datatype_select_search.wait_for_and_send_enter()
         self._edit_attributes.save_datatype_btn.wait_for_and_click()
 
     @property
diff --git a/lib/galaxy_test/selenium/test_custom_builds.py b/lib/galaxy_test/selenium/test_custom_builds.py
index 2e020f961d53..cd6df88cc414 100644
--- a/lib/galaxy_test/selenium/test_custom_builds.py
+++ b/lib/galaxy_test/selenium/test_custom_builds.py
@@ -1,5 +1,8 @@
+from selenium.webdriver.common.by import By
+
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SharedStateSeleniumTestCase,
 )
@@ -12,6 +15,7 @@ class TestCustomBuilds(SharedStateSeleniumTestCase):
     build_key1: str
     build_key2: str
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_build_add(self):
         self._login()
@@ -19,6 +23,7 @@ def test_build_add(self):
         self.add_custom_build(self.build_name1, self.build_key1)
         self.assert_custom_builds_in_grid([self.build_name1])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_build_delete(self):
         self._login()
@@ -51,7 +56,7 @@ def add_custom_build(self, build_name, build_key):
         len_type_select = self.wait_for_selector('select[id="type"]')
         len_type_select.click()
 
-        option = self.wait_for_sizzle_selector_clickable('option[value="text"]')
+        option = self.wait_for_selector_clickable('option[value="text"]')
         option.click()
         content_area = self.wait_for_and_click_selector('textarea[id="len-file-text-area"]')
         content_area.send_keys("content")
@@ -61,11 +66,11 @@ def add_custom_build(self, build_name, build_key):
     def delete_custom_build(self, build_name):
         delete_button = None
         grid = self.wait_for_selector("table.grid > tbody")
-        for row in grid.find_elements(self.by.TAG_NAME, "tr"):
-            td = row.find_elements(self.by.TAG_NAME, "td")
+        for row in grid.find_elements(By.TAG_NAME, "tr"):
+            td = row.find_elements(By.TAG_NAME, "td")
             name = td[0].text
             if name == build_name:
-                delete_button = td[3].find_element(self.by.CSS_SELECTOR, ".fa-trash-o")
+                delete_button = td[3].find_element(By.CSS_SELECTOR, ".fa-trash-o")
                 break
 
         if delete_button is None:
@@ -77,8 +82,8 @@ def get_custom_builds(self):
         self.sleep_for(self.wait_types.UX_RENDER)
         builds = []
         grid = self.wait_for_selector("table.grid > tbody")
-        for row in grid.find_elements(self.by.TAG_NAME, "tr"):
-            name = row.find_elements(self.by.TAG_NAME, "td")[0].text
+        for row in grid.find_elements(By.TAG_NAME, "tr"):
+            name = row.find_elements(By.TAG_NAME, "td")[0].text
             builds.append(name)
         return builds
 
diff --git a/lib/galaxy_test/selenium/test_custom_tools.py b/lib/galaxy_test/selenium/test_custom_tools.py
index 52d6e04f6986..4556587f1f43 100644
--- a/lib/galaxy_test/selenium/test_custom_tools.py
+++ b/lib/galaxy_test/selenium/test_custom_tools.py
@@ -6,6 +6,7 @@
 from selenium.webdriver.common.keys import Keys
 
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -18,6 +19,7 @@ def assert_baseline_accessibility(self):
         """Skip accessibility checks for custom tools tests due to Monaco editor issues."""
         pass
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_create_custom_tool(self):
         """Test creating a new custom tool through the UI."""
@@ -26,6 +28,7 @@ def test_create_custom_tool(self):
             assert tool_uuid, "Tool UUID should be returned after saving."
             self.components.custom_tools.tool_link(tool_uuid=tool_uuid).wait_for_clickable()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_custom_tool(self):
         test_path = self.get_filename("1.fasta")
diff --git a/lib/galaxy_test/selenium/test_data_source_tools.py b/lib/galaxy_test/selenium/test_data_source_tools.py
index c669c0b7221e..8728a7e6485b 100644
--- a/lib/galaxy_test/selenium/test_data_source_tools.py
+++ b/lib/galaxy_test/selenium/test_data_source_tools.py
@@ -1,5 +1,5 @@
 import pytest
-from selenium.webdriver.support.ui import Select
+from selenium.webdriver.common.by import By
 
 from galaxy.util.unittest_utils import skip_if_site_down
 from .framework import (
@@ -22,7 +22,7 @@ def test_ucsc_table_direct1_data_source(self):
         self.datasource_tool_open("ucsc_table_direct1")
         self.screenshot("ucsc_table_browser_first_page")
         # only 4mb instead of 10 times that for human by default
-        Select(self.wait_for_selector("#org")).select_by_value("Tree shrew")
+        self.select_by_value((By.CSS_SELECTOR, "#org"), "Tree shrew")
         checkbox = self.wait_for_selector("#checkboxGalaxy")
         assert checkbox.get_attribute("checked") == "true"
         submit_button = self.wait_for_selector("#hgta_doTopSubmit")
diff --git a/lib/galaxy_test/selenium/test_dataset_edit.py b/lib/galaxy_test/selenium/test_dataset_edit.py
index b6da177f42b4..08b226c7dbf7 100644
--- a/lib/galaxy_test/selenium/test_dataset_edit.py
+++ b/lib/galaxy_test/selenium/test_dataset_edit.py
@@ -1,6 +1,7 @@
 from galaxy.selenium.axe_results import FORMS_VIOLATIONS
 from .framework import (
     managed_history,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -66,6 +67,7 @@ def test_history_dataset_update_annotation_and_info(self):
         assert annotation_component.wait_for_value() == TEST_ANNOTATION
         assert info_component.wait_for_value() == TEST_INFO
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_history_dataset_auto_detect_datatype(self):
diff --git a/lib/galaxy_test/selenium/test_edam_tool_panel_views.py b/lib/galaxy_test/selenium/test_edam_tool_panel_views.py
index cc9619db81eb..8b04cfe0eb70 100644
--- a/lib/galaxy_test/selenium/test_edam_tool_panel_views.py
+++ b/lib/galaxy_test/selenium/test_edam_tool_panel_views.py
@@ -38,4 +38,6 @@ def _assert_displaying_edam_operations(self):
         labels = tool_panel.panel_labels.all()
         assert len(labels) > 0
         label0 = labels[0]
-        assert label0.text.strip().startswith("ANALYSIS")
+        # oh dear Selenium and Playwright are returning very different things
+        # for label.text here. ANALYSIS vs "Analysis    \n\nn Link Link"
+        assert "ANALYSIS" in label0.text.strip().upper()
diff --git a/lib/galaxy_test/selenium/test_histories_list.py b/lib/galaxy_test/selenium/test_histories_list.py
index 0d0c6e190d03..5fb0fc19ba6a 100644
--- a/lib/galaxy_test/selenium/test_histories_list.py
+++ b/lib/galaxy_test/selenium/test_histories_list.py
@@ -2,18 +2,21 @@
 
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SharedStateSeleniumTestCase,
 )
 
 
 class TestSavedHistories(SharedStateSeleniumTestCase):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_histories_list(self):
         self._login()
         self.navigate_to_histories_page()
         self.assert_histories_in_list([self.history2_name, self.history3_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_switch(self):
         self._login()
@@ -28,6 +31,7 @@ def assert_history_name_switched():
 
         assert_history_name_switched()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_view(self):
         self._login()
@@ -36,6 +40,7 @@ def test_history_view(self):
         history_name = self.wait_for_selector("[data-description='name display']")
         assert history_name.text == self.history2_name
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_publish(self):
         self._login()
@@ -52,6 +57,7 @@ def test_history_publish(self):
 
         self.assert_histories_in_list([self.history2_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rename_history(self):
         self._login()
@@ -70,6 +76,7 @@ def test_rename_history(self):
 
         self.assert_histories_in_list([self.history1_name, self.history2_name, self.history3_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_delete_and_undelete_history(self):
         self._login()
@@ -94,6 +101,7 @@ def test_delete_and_undelete_history(self):
 
         self.assert_histories_in_list([self.history2_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_permanently_delete_history(self):
         self._login()
@@ -114,6 +122,7 @@ def test_permanently_delete_history(self):
 
         self.assert_histories_in_list([self.history4_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_delete_and_undelete_multiple_histories(self):
         self._login()
@@ -142,6 +151,7 @@ def test_delete_and_undelete_multiple_histories(self):
         self.components.histories.reset_input.wait_for_and_click()
         self.assert_histories_in_list([self.history2_name, self.history3_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_sort_by_name(self):
         self._login()
@@ -164,6 +174,7 @@ def test_sort_by_name(self):
 
         assert actual_histories == expected_histories
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_standard_search(self):
         self._login()
@@ -174,6 +185,7 @@ def test_standard_search(self):
         self.components.histories.search_input.wait_for_and_send_keys(self.history4_name)
         self.assert_histories_sorted_in_list([])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_advanced_search(self):
         self._login()
@@ -214,6 +226,7 @@ def get_present_histories(self):
         self.sleep_for(self.wait_types.UX_RENDER)
         return self.components.histories.history_cards.all()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_tags(self):
         self._login()
diff --git a/lib/galaxy_test/selenium/test_histories_published.py b/lib/galaxy_test/selenium/test_histories_published.py
index c7fae0074dd6..bf4915b9342d 100644
--- a/lib/galaxy_test/selenium/test_histories_published.py
+++ b/lib/galaxy_test/selenium/test_histories_published.py
@@ -2,12 +2,14 @@
 
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SharedStateSeleniumTestCase,
 )
 
 
 class TestPublishedHistories(SharedStateSeleniumTestCase):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories(self):
         self._login()
@@ -15,6 +17,7 @@ def test_published_histories(self):
         expected_history_names = self.get_published_history_names_from_server()
         self.assert_histories_present(expected_history_names)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories_sort_by_name(self):
         self._login()
@@ -27,6 +30,7 @@ def test_published_histories_sort_by_name(self):
         sorted_histories = self.get_published_history_names_from_server(sort_by="name")
         self.assert_histories_present(sorted_histories, sort_by_matters=True)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories_sort_by_last_update(self):
         self._login()
@@ -38,6 +42,7 @@ def test_published_histories_sort_by_last_update(self):
         expected_history_names = self.get_published_history_names_from_server(sort_by="update_time")
         self.assert_histories_present(expected_history_names, sort_by_matters=True)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories_tag_click(self):
         self._login()
@@ -58,6 +63,7 @@ def test_published_histories_tag_click(self):
 
         self.assert_histories_present([self.history3_name, self.history1_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories_username_filter(self):
         self._login()
@@ -66,6 +72,7 @@ def test_published_histories_username_filter(self):
         self.components.published_histories.search_input.wait_for_and_send_keys(f"user:{username}")
         self.assert_histories_present([self.history2_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories_search_standard(self):
         self._login()
@@ -73,6 +80,7 @@ def test_published_histories_search_standard(self):
         self.components.published_histories.search_input.wait_for_and_send_keys(self.history1_name)
         self.assert_histories_present([self.history1_name])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_published_histories_search_advanced(self):
         self._login()
diff --git a/lib/galaxy_test/selenium/test_history_multi_view.py b/lib/galaxy_test/selenium/test_history_multi_view.py
index 3994b3b8913c..7b7e273ccc2d 100644
--- a/lib/galaxy_test/selenium/test_history_multi_view.py
+++ b/lib/galaxy_test/selenium/test_history_multi_view.py
@@ -2,6 +2,7 @@
 
 from .framework import (
     managed_history,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -35,6 +36,7 @@ def test_list_list_display(self):
         dataset_selector.wait_for_and_click()
         self.screenshot("multi_history_list_list")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_list_list_copy(self):
@@ -48,7 +50,7 @@ def test_list_list_copy(self):
         ac = self.action_chains()
         ac = ac.move_to_element(dataset_element).click_and_hold()
         drag_and_drop(self.driver, source=dataset_element, target=drop_target)
-        self._wait_on(lambda driver: self.current_history_id() != source_history_id)
+        self._wait_on(lambda *driver: self.current_history_id() != source_history_id)
         target_history_id = self.current_history_id()
         assert source_history_id != target_history_id
         source_contents = self.dataset_populator.get_history_contents(history_id=source_history_id)
diff --git a/lib/galaxy_test/selenium/test_history_options.py b/lib/galaxy_test/selenium/test_history_options.py
index 0eb90a8dc344..767ce54b2bfe 100644
--- a/lib/galaxy_test/selenium/test_history_options.py
+++ b/lib/galaxy_test/selenium/test_history_options.py
@@ -1,14 +1,17 @@
 from .framework import (
+    managed_history,
     selenium_test,
     SeleniumTestCase,
 )
 
 
 class TestHistoryOptions(SeleniumTestCase):
+    ensure_registered = True
+
     @selenium_test
+    @managed_history
     def test_options(self):
-        self.register()
-        self.perform_upload(self.get_filename("1.txt"))
+        self.perform_upload_of_pasted_content("text content")
         menu_selector = self.navigation.history_panel.selectors.options_menu
         self.wait_for_absent_or_hidden(menu_selector)
         self.click_history_options()
diff --git a/lib/galaxy_test/selenium/test_history_panel.py b/lib/galaxy_test/selenium/test_history_panel.py
index 2a19aad88f85..d0a93fefab00 100644
--- a/lib/galaxy_test/selenium/test_history_panel.py
+++ b/lib/galaxy_test/selenium/test_history_panel.py
@@ -1,6 +1,7 @@
 from galaxy.selenium.navigates_galaxy import edit_details
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -15,6 +16,7 @@
 class TestHistoryPanel(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_panel_landing_state(self):
         self.assert_initial_history_panel_state_correct()
@@ -25,11 +27,13 @@ def test_history_panel_landing_state(self):
         toggle = editor.toggle
         toggle.wait_for_visible()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_panel_rename(self):
         self.history_panel_rename(NEW_HISTORY_NAME)
         self.assert_name_changed()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_rename_cancel_with_escape(self):
         editable_text_input_element = self.history_panel_name_input()
@@ -48,6 +52,7 @@ def test_history_tags_and_annotations_buttons(self):
         history_editor.annotation_input.wait_for_clickable()
         history_editor.tags_input.wait_for_clickable()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_panel_annotations_change(self):
         history_panel = self.components.history_panel
@@ -86,6 +91,7 @@ def set_random_annotation(clear_text=True):
             is_equal=True,
         )
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_history_panel_tags_change(self):
         def create_tags(size):
@@ -150,6 +156,7 @@ def clear_tags(self, expected_tags_size):
             close_btn.click()
             self.sleep_for(self.wait_types.UX_RENDER)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_refresh_preserves_state(self):
         self.perform_upload(self.get_filename("1.txt"))
diff --git a/lib/galaxy_test/selenium/test_history_panel_collections.py b/lib/galaxy_test/selenium/test_history_panel_collections.py
index 1b9f82200f6f..c16e1f4827dd 100644
--- a/lib/galaxy_test/selenium/test_history_panel_collections.py
+++ b/lib/galaxy_test/selenium/test_history_panel_collections.py
@@ -1,10 +1,13 @@
 import time
 
+from selenium.webdriver.common.by import By
+
 from galaxy.selenium.navigates_galaxy import WAIT_TYPES
 from galaxy_test.base.api_asserts import assert_status_code_is
 from galaxy_test.base.populators import flakey
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -13,6 +16,7 @@
 class TestHistoryPanelCollections(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_mapping_collection_states_terminal(self):
         history_id = self.current_history_id()
@@ -68,6 +72,7 @@ def test_mapping_collection_states_running(self):
             for job in running_response.json()["jobs"]:
                 self.dataset_populator.cancel_job(job["id"])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_output_collection_states_terminal(self):
         history_id = self.current_history_id()
@@ -123,6 +128,7 @@ def test_output_collection_states_running(self):
             for job in payload["jobs"]:
                 self.dataset_populator.cancel_job(job["id"])
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_collection_job_details(self):
         ok_collection_hid, failed_collection_hid = self._generate_ok_and_failed_collections()
@@ -141,6 +147,7 @@ def test_collection_job_details(self):
         self.screenshot("history_panel_collections_job_details_failed")
         assert int(tool_exit_code_component.text) > 0
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_back_to_history_button(self):
         input_collection = self._populated_paired_and_wait_for_it()
@@ -158,6 +165,7 @@ def _back_to_history(self):
         back.wait_for_and_click()
         self.sleep_for(WAIT_TYPES.UX_RENDER)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rename_collection(self):
         input_collection = self._populated_paired_and_wait_for_it()
@@ -176,6 +184,7 @@ def assert_name_changed():
 
         assert_name_changed()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_name_tags_display(self):
         # Test setting a name tag and viewing it from the outer history panel.
@@ -193,6 +202,7 @@ def test_name_tags_display(self):
         assert nametags == ["#moo"]
         self.screenshot("history_panel_collection_with_nametag")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_paired_display(self):
         input_collection = self._populated_paired_and_wait_for_it()
@@ -203,7 +213,7 @@ def test_paired_display(self):
         assert len(dataset_elements) == 2, dataset_elements
         selector = ".title .name"
         selector = ".content-title"
-        titles = [de.find_element(self.by.CSS_SELECTOR, selector).text for de in dataset_elements]
+        titles = [de.find_element(By.CSS_SELECTOR, selector).text for de in dataset_elements]
         assert titles == ["forward", "reverse"]
         self.screenshot("history_panel_collection_view_paired")
 
@@ -224,12 +234,13 @@ def check_four_datasets_shown():
             assert len(dataset_elements) == 4, dataset_elements
             selector = ".title .name"
             selector = ".content-title"
-            title_elements = [de.find_element(self.by.CSS_SELECTOR, selector).text for de in dataset_elements]
+            title_elements = [de.find_element(By.CSS_SELECTOR, selector).text for de in dataset_elements]
             assert title_elements == ["data1", "data2", "data3", "data4"]
 
         check_four_datasets_shown()
         self.screenshot("history_panel_collection_view_list")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_list_paired_display(self):
         history_id = self.current_history_id()
@@ -240,6 +251,7 @@ def test_list_paired_display(self):
         self.history_panel_expand_collection(collection_hid)
         self.screenshot("history_panel_collection_view_list_paired")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_list_list_display(self):
         history_id = self.current_history_id()
diff --git a/lib/galaxy_test/selenium/test_history_sharing.py b/lib/galaxy_test/selenium/test_history_sharing.py
index 6035216b113a..9fd168525db1 100644
--- a/lib/galaxy_test/selenium/test_history_sharing.py
+++ b/lib/galaxy_test/selenium/test_history_sharing.py
@@ -1,4 +1,5 @@
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -134,6 +135,7 @@ def share_history_with_user(self, user_id=None, user_email=None, assert_valid=Fa
 class TestHistoryRequiresLoginSelenium(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_share_history_login_redirect(self):
         user_email = self.get_user_email()
diff --git a/lib/galaxy_test/selenium/test_history_storage.py b/lib/galaxy_test/selenium/test_history_storage.py
index cb5422944041..90e0cb090e94 100644
--- a/lib/galaxy_test/selenium/test_history_storage.py
+++ b/lib/galaxy_test/selenium/test_history_storage.py
@@ -1,5 +1,6 @@
 from .framework import (
     managed_history,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -29,6 +30,7 @@
 class TestHistoryStorage(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_history_storage_accessibility(self):
@@ -55,6 +57,7 @@ def test_history_storage_accessibility(self):
         self.screenshot("storage_dashboard_manage_explore_usage_landing")
         self.assert_baseline_accessibility()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_delete_dataset_from_storage_view(self):
diff --git a/lib/galaxy_test/selenium/test_invocation_grid.py b/lib/galaxy_test/selenium/test_invocation_grid.py
index 48c17d2e447a..0fe5bc9d1986 100644
--- a/lib/galaxy_test/selenium/test_invocation_grid.py
+++ b/lib/galaxy_test/selenium/test_invocation_grid.py
@@ -1,6 +1,7 @@
 from galaxy_test.base.workflow_fixtures import WORKFLOW_RENAME_ON_INPUT
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     TestsGalaxyPagers,
@@ -10,6 +11,7 @@
 class TestInvocationGridSelenium(SeleniumTestCase, TestsGalaxyPagers):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_grid(self):
         gx_selenium_context = self
diff --git a/lib/galaxy_test/selenium/test_library_contents.py b/lib/galaxy_test/selenium/test_library_contents.py
index 4a7789b63a0b..1e46269ab9ff 100644
--- a/lib/galaxy_test/selenium/test_library_contents.py
+++ b/lib/galaxy_test/selenium/test_library_contents.py
@@ -6,6 +6,7 @@
 )
 from .framework import (
     retry_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesLibraryAssertions,
@@ -57,6 +58,7 @@ def change_description(description):
         shrinked_description = long_description[0:40]
         assert shrinked_description == self.components.libraries.folder.description_field_shrinked.wait_for_text()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     @requires_new_library
@@ -99,6 +101,7 @@ def download_dataset_from_library(self):
         expected_filename = "selected_dataset_files.zip"
         assert expected_filename in folder_files
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     @requires_new_library
@@ -122,6 +125,7 @@ def test_delete_dataset(self):
     # Fine test locally but the upload doesn't work in Docker compose. I'd think
     # Galaxy must be running so that test-data/1.txt would work but it just doesn't
     # for some reason. https://jenkins.galaxyproject.org/job/jmchilton-selenium/79/artifact/79-test-errors/test_import_dataset_from_path2017100413221507137721/
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     @requires_new_library
diff --git a/lib/galaxy_test/selenium/test_library_landing.py b/lib/galaxy_test/selenium/test_library_landing.py
index 013f75a54557..8161cedcc95c 100644
--- a/lib/galaxy_test/selenium/test_library_landing.py
+++ b/lib/galaxy_test/selenium/test_library_landing.py
@@ -1,5 +1,8 @@
+from selenium.webdriver.common.by import By
+
 from .framework import (
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -13,6 +16,7 @@ def setup_with_driver(self):
         self.admin_login()
         self.libraries_open()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_create_new_close(self):
         num_displayed_libraries = self._num_displayed_libraries()
@@ -23,6 +27,7 @@ def test_create_new_close(self):
         self.wait_for_overlays_cleared()
         assert self._num_displayed_libraries() == num_displayed_libraries
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_create_new(self):
         name = self._get_random_name(prefix="testcreatenew")
@@ -33,6 +38,7 @@ def test_create_new(self):
 
         self._search_for_only_with_name(name)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rename(self):
         name = self._get_random_name(prefix="testprerename")
@@ -52,6 +58,7 @@ def test_rename(self):
 
         self._search_for_only_with_name(new_name)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_sorting(self):
         # Throw in another library to ensure filtering is working...
@@ -84,7 +91,7 @@ def _search_for_only_with_name(self, name):
 
     @retry_assertion_during_transitions
     def _assert_names_are(self, expected_names):
-        names = [e.find_element(self.by.CSS_SELECTOR, "td a").text for e in self.libraries_index_table_elements()]
+        names = [e.find_element(By.CSS_SELECTOR, "td a").text for e in self.libraries_index_table_elements()]
         assert names == expected_names
 
     @retry_assertion_during_transitions
diff --git a/lib/galaxy_test/selenium/test_library_to_collections.py b/lib/galaxy_test/selenium/test_library_to_collections.py
index 1bc878557f73..c06b6ea7c340 100644
--- a/lib/galaxy_test/selenium/test_library_to_collections.py
+++ b/lib/galaxy_test/selenium/test_library_to_collections.py
@@ -1,5 +1,6 @@
 from galaxy_test.base.decorators import requires_admin
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesLibraryAssertions,
@@ -19,21 +20,25 @@ def test_library_collection_export_new_history(self):
     def test_library_collection_export(self):
         self.collection_export()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_library_pair_export_new_history(self):
         self.collection_export(is_new_history=True, collection_option="paired")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_library_pair_export(self):
         self.collection_export(collection_option="paired")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_export_pairs_list_new_history(self):
         self.list_of_pairs_export(is_new_history=True)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @requires_admin
     def test_export_pairs_list(self):
diff --git a/lib/galaxy_test/selenium/test_pages_index.py b/lib/galaxy_test/selenium/test_pages_index.py
index 7e0af6db293d..3718bbae39ab 100644
--- a/lib/galaxy_test/selenium/test_pages_index.py
+++ b/lib/galaxy_test/selenium/test_pages_index.py
@@ -14,9 +14,9 @@ def test_page_deletion(self):
         page_title = page_response["title"]
         self.navigate_to_pages()
         self._assert_showing_n_pages(1)
-        self.select_grid_operation(page_title, "Delete")
-        alert = self.driver.switch_to.alert
-        alert.accept()
+        with self.accept_alert():
+            self.select_grid_operation(page_title, "Delete")
+
         self._assert_showing_n_pages(0)
 
     def new_page(self):
diff --git a/lib/galaxy_test/selenium/test_personal_information.py b/lib/galaxy_test/selenium/test_personal_information.py
index 74fdcb7e99b3..853209b1041c 100644
--- a/lib/galaxy_test/selenium/test_personal_information.py
+++ b/lib/galaxy_test/selenium/test_personal_information.py
@@ -1,10 +1,16 @@
+from selenium.webdriver.common.by import By
+
 from galaxy_test.selenium.framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
 
 
 class TestManageInformation(SeleniumTestCase):
+    @selenium_only(
+        "Not yet migrated to support Playwright backend - AttributeError: 'PlaywrightElement' object has no attribute 'get_property'"
+    )
     @selenium_test
     def test_api_key(self):
         """
@@ -135,12 +141,11 @@ def clear_input_field_and_write(self, element, new_input_text):
         element.send_keys(new_input_text)
 
     def get_address_input_field(self, address_form, input_field_label):
-        return address_form.find_element(
-            self.by.CSS_SELECTOR, f"[data-label='{input_field_label}'] > div > div > input"
-        )
+        return address_form.find_element(By.CSS_SELECTOR, f"[data-label='{input_field_label}'] > div > div > input")
 
 
 class TestDeleteCurrentAccount(SeleniumTestCase):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_delete_account(self):
         email = self._get_random_email()
diff --git a/lib/galaxy_test/selenium/test_registration.py b/lib/galaxy_test/selenium/test_registration.py
index 564e910e540d..b65cf6463503 100644
--- a/lib/galaxy_test/selenium/test_registration.py
+++ b/lib/galaxy_test/selenium/test_registration.py
@@ -9,7 +9,7 @@ class TestRegistration(SeleniumTestCase):
     def test_landing(self):
         # loading galaxy homepage
         self.home()
-        assert self.driver.title == "Galaxy", self.driver.title
+        assert self.page_title == "Galaxy", self.page_title
         self.components.masthead._.wait_for_visible()
 
     @selenium_test
diff --git a/lib/galaxy_test/selenium/test_sign_out.py b/lib/galaxy_test/selenium/test_sign_out.py
index c08ed95761d5..d9505237baed 100644
--- a/lib/galaxy_test/selenium/test_sign_out.py
+++ b/lib/galaxy_test/selenium/test_sign_out.py
@@ -1,5 +1,3 @@
-from selenium.webdriver.common.by import By
-
 from .framework import (
     selenium_test,
     SeleniumTestCase,
@@ -15,7 +13,7 @@ def test_sign_out(self):
         self.components.preferences.sign_out.wait_for_and_click()
         self.components.sign_out.cancel_button.wait_for_and_click()
         assert self.is_logged_in()
-        new_email = self.driver.find_element(By.ID, "user-preferences-current-email").text
+        new_email = self.find_element_by_id("user-preferences-current-email").text
         assert email == new_email
         self.components.preferences.sign_out.wait_for_and_click()
         self.components.sign_out.sign_out_button.wait_for_and_click()
diff --git a/lib/galaxy_test/selenium/test_sizzle_loading.py b/lib/galaxy_test/selenium/test_sizzle_loading.py
deleted file mode 100644
index 05e80c5fc93c..000000000000
--- a/lib/galaxy_test/selenium/test_sizzle_loading.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from .framework import (
-    selenium_test,
-    SeleniumTestCase,
-)
-
-
-class TestSizzleLoading(SeleniumTestCase):
-    @selenium_test
-    def test_sizzle_loads(self):
-        self.home()
-        self.wait_for_sizzle_selector_clickable("span")
diff --git a/lib/galaxy_test/selenium/test_stock_tours.py b/lib/galaxy_test/selenium/test_stock_tours.py
index 9cb47e11a177..0bbf6c63831d 100644
--- a/lib/galaxy_test/selenium/test_stock_tours.py
+++ b/lib/galaxy_test/selenium/test_stock_tours.py
@@ -2,6 +2,7 @@
 
 from galaxy.util import galaxy_root_path
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     TIMEOUT_MULTIPLIER,
@@ -11,6 +12,7 @@
 
 
 class TestStockToursTestCase(SeleniumTestCase):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_core_galaxy_ui(self):
         sleep_on_steps = {
@@ -24,6 +26,7 @@ def test_core_galaxy_ui(self):
             tour_callback=TourCallback(self),
         )
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_core_windows(self):
         self.run_tour(
@@ -31,6 +34,7 @@ def test_core_windows(self):
             tour_callback=TourCallback(self),
         )
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_core_history(self):
         self.run_tour(
@@ -38,6 +42,7 @@ def test_core_history(self):
             tour_callback=TourCallback(self),
         )
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_core_deferred(self):
         self.run_tour(
diff --git a/lib/galaxy_test/selenium/test_tool_form.py b/lib/galaxy_test/selenium/test_tool_form.py
index 93248b172067..234897d44040 100644
--- a/lib/galaxy_test/selenium/test_tool_form.py
+++ b/lib/galaxy_test/selenium/test_tool_form.py
@@ -17,6 +17,7 @@
 from .framework import (
     managed_history,
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesHistoryItemAssertions,
@@ -24,6 +25,7 @@
 
 
 class TestToolForm(SeleniumTestCase, UsesHistoryItemAssertions):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_tool_verify_contents_by_peek(self):
         self._run_environment_test_tool()
@@ -32,12 +34,14 @@ def test_run_tool_verify_contents_by_peek(self):
         self.history_panel_click_item_title(hid=1)
         self.assert_item_peek_includes(1, "42")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_tool_verify_dataset_details(self):
         self._run_environment_test_tool()
         self.history_panel_wait_for_hid_ok(1)
         self._check_dataset_details_for_inttest_value(1)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_verify_dataset_details_tables(self):
         self._run_environment_test_tool()
@@ -73,6 +77,7 @@ def test_verify_dataset_details_tables(self):
         generic_item.find_element(By.CSS_SELECTOR, "[title='Run Job Again']").click()
         self.components.tool_form.execute.wait_for_visible()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_drilldown_tool(self):
         self._open_drilldown_test_tool()
@@ -112,6 +117,7 @@ def _table_to_key_value_elements(self, table_selector):
 
         return key_value_pairs
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_repeat_reordering(self):
         self.home()
@@ -148,6 +154,7 @@ def assert_input_order(inputs: list[str]):
 
         assert details == ["texttest", "Text C", "texttest", "Text B", "texttest", "Text A"]
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rerun(self):
         self._run_environment_test_tool()
@@ -169,6 +176,7 @@ def check_recorded_val():
         self.history_panel_wait_for_hid_ok(2)
         self._check_dataset_details_for_inttest_value(2)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rerun_with_non_latest_version(self):
         version = "0.1+galaxy6"
@@ -183,6 +191,7 @@ def test_rerun_with_non_latest_version(self):
                 return
         raise Exception("Tool version does not match job version")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rerun_deleted_dataset(self):
         # upload a first dataset that should not become selected on re-run
@@ -227,6 +236,7 @@ def test_rerun_deleted_dataset(self):
         )
         assert error_col.text == "Parameter 'col': an invalid option ('3') was selected (valid options: 1)"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rerun_dataset_collection_element(self):
         # upload a first dataset that should not become selected on re-run
@@ -284,6 +294,7 @@ def test_run_data(self):
         assert latest_hda["hid"] == 3
         assert latest_hda["name"] == "Select first on dataset 1"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_bibtex_rendering(self):
         self.home()
@@ -338,6 +349,7 @@ def _run_multiple_version_test_tool(self, version):
 class TestLoggedInToolForm(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_dataset_state_filtering(self):
         # upload an ok (HID 1) and a discarded (HID 2) dataset and run a tool
@@ -365,26 +377,31 @@ def test_dataset_state_filtering(self):
         assert latest_hda["hid"] == 3
         assert latest_hda["name"] == "Select first on dataset 1"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_apply_rules_1(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_1)
         self.screenshot("tool_apply_rules_example_1_final")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_apply_rules_2(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_2)
         self.screenshot("tool_apply_rules_example_2_final")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_apply_rules_3(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_3)
         self.screenshot("tool_apply_rules_example_3_final")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_apply_rules_4(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_4)
         self.screenshot("tool_apply_rules_example_4_final")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_apply_rules_paired_unpaired_flatten(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_FLATTEN_PAIRED_OR_UNPAIRED)
@@ -396,11 +413,13 @@ def test_run_apply_rules_create_paired_or_unpaired_list(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_CREATE_PAIRED_OR_UNPAIRED_COLLECTION)
         self.screenshot("tool_apply_rules_example_flatten_paired_unpaired_final")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_apply_rules_flatten_with_indices(self):
         self._apply_rules_and_check(rules_test_data.EXAMPLE_FLATTEN_USING_INDICES)
         self.screenshot("tool_apply_rules_example_flatten_with_indices_final")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     @skip_if_github_down
diff --git a/lib/galaxy_test/selenium/test_tutorial_mode.py b/lib/galaxy_test/selenium/test_tutorial_mode.py
index 11dd08d2e4b9..6654d63b18c0 100644
--- a/lib/galaxy_test/selenium/test_tutorial_mode.py
+++ b/lib/galaxy_test/selenium/test_tutorial_mode.py
@@ -3,12 +3,14 @@
 import pytest
 
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
 
 
 class TestTutorialMode(SeleniumTestCase):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     def test_activate_tutorial_mode(self):
@@ -19,7 +21,7 @@ def test_activate_tutorial_mode(self):
         self.screenshot("tutorial_mode_0_1")
 
         # Access inside the frame
-        self.driver.switch_to.frame("gtn-embed")
+        self.switch_to_frame("gtn-embed")
         self.wait_for_selector_visible("#top-navbar")
         self.screenshot("tutorial_mode_0_2")
 
diff --git a/lib/galaxy_test/selenium/test_uploads.py b/lib/galaxy_test/selenium/test_uploads.py
index 5e14992ece14..67fb8ad84c86 100644
--- a/lib/galaxy_test/selenium/test_uploads.py
+++ b/lib/galaxy_test/selenium/test_uploads.py
@@ -1,8 +1,11 @@
 import os
 
 import pytest
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
 
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesHistoryItemAssertions,
@@ -10,6 +13,7 @@
 
 
 class TestUploads(SeleniumTestCase, UsesHistoryItemAssertions):
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_file(self):
         self.perform_upload(self.get_filename("1.sam"))
@@ -21,6 +25,7 @@ def test_upload_file(self):
         self.history_panel_click_item_title(hid=1, wait=True)
         self.assert_item_summary_includes(1, "28 lines")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_pasted_content(self):
         pasted_content = "this is pasted"
@@ -30,6 +35,7 @@ def test_upload_pasted_content(self):
         history_count = len(self.history_contents())
         assert history_count == 1, f"Incorrect number of items in history - expected 1, found {history_count}"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_pasted_url_content(self):
         pasted_content = "https://raw.githubusercontent.com/galaxyproject/galaxy/dev/LICENSE.txt"
@@ -39,6 +45,7 @@ def test_upload_pasted_url_content(self):
         history_count = len(self.history_contents())
         assert history_count == 1, f"Incorrect number of items in history - expected 1, found {history_count}"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_composite_dataset_pasted_data(self):
         paste_content = ["a", "b", "c"]
@@ -50,14 +57,13 @@ def test_upload_composite_dataset_pasted_data(self):
 
         self.history_panel_click_item_title(hid=1, wait=True)
         self.history_panel_item_view_dataset_details(1)
-        param_values = self.driver.find_element(
-            self.by.CSS_SELECTOR, "#tool-parameters td.tool-parameter-value .vjs-tree"
-        )
+        param_values = self.driver.find_element(By.CSS_SELECTOR, "#tool-parameters td.tool-parameter-value .vjs-tree")
         request_json = param_values.get_attribute("data-request-json")
         assert request_json
         for data in paste_content:
             assert f'"paste_content":"{data}"' in request_json
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_simplest(self):
         self.perform_upload(self.get_filename("1.sam"))
@@ -74,6 +80,7 @@ def test_upload_simplest(self):
         self.history_panel_click_item_title(hid=1, wait=True)
         self.assert_item_dbkey_displayed_as(1, "?")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_specify_ext(self):
         self.perform_upload(self.get_filename("1.sam"), ext="txt")
@@ -83,6 +90,7 @@ def test_upload_specify_ext(self):
         assert hda["name"] == "1.sam"
         assert hda["extension"] == "txt", hda
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_specify_genome(self):
         self.perform_upload(self.get_filename("1.sam"), genome="hg18")
@@ -91,6 +99,7 @@ def test_upload_specify_genome(self):
         self.history_panel_click_item_title(hid=1, wait=True)
         self.assert_item_dbkey_displayed_as(1, "hg18")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_specify_ext_all(self):
         self.perform_upload(self.get_filename("1.sam"), ext_all="txt")
@@ -100,6 +109,7 @@ def test_upload_specify_ext_all(self):
         assert hda["name"] == "1.sam"
         assert hda["extension"] == "txt", hda
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_specify_genome_all(self):
         self.perform_upload(self.get_filename("1.sam"), genome_all="hg18")
@@ -108,6 +118,7 @@ def test_upload_specify_genome_all(self):
         self.history_panel_click_item_title(hid=1, wait=True)
         self.assert_item_dbkey_displayed_as(1, "hg18")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_deferred(self):
         self.perform_upload_of_pasted_content(
@@ -118,6 +129,7 @@ def test_upload_deferred(self):
         self.history_panel_click_item_title(hid=hid, wait=True)
         self.screenshot("history_panel_dataset_deferred")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_list(self):
         self.upload_list([self.get_filename("1.tabular")], name="Test List")
@@ -130,6 +142,7 @@ def test_upload_list(self):
         # Make sure source item is hidden when the collection is created.
         self.history_panel_wait_for_hid_hidden(1)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_pair(self):
         self.upload_list([self.get_filename("1.tabular"), self.get_filename("2.tabular")], name="Test Pair")
@@ -145,6 +158,7 @@ def test_upload_pair(self):
         self.history_panel_wait_for_hid_hidden(3)
         self.history_panel_wait_for_hid_hidden(4)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_pair_specify_extension(self):
         self.upload_list(
@@ -161,6 +175,7 @@ def test_upload_pair_specify_extension(self):
         assert hda["name"] == "1.tabular"
         assert hda["extension"] == "txt", hda
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_paired_list(self):
         self.upload_paired_list(
@@ -177,6 +192,7 @@ def test_upload_paired_list(self):
         self.history_panel_wait_for_hid_hidden(3)
         self.history_panel_wait_for_hid_hidden(4)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_upload_modal_retains_content(self):
         self.home()
@@ -207,6 +223,7 @@ def test_upload_modal_retains_content(self):
         self.wait_for_selector_visible("#upload-row-1.upload-success")
         self.wait_for_selector_visible("#upload-row-2.upload-init")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     @pytest.mark.local
@@ -237,7 +254,7 @@ def test_rules_example_1_datasets(self):
         rule_builder.menu_item_rule_type(rule_type="add-filter-count").wait_for_and_click()
         filter_editor = rule_builder.rule_editor(rule_type="add-filter-count")
         filter_editor_element = filter_editor.wait_for_visible()
-        filter_input = filter_editor_element.find_element(self.by.CSS_SELECTOR, "input[type='number']")
+        filter_input = filter_editor_element.find_element(By.CSS_SELECTOR, "input[type='number']")
         filter_input.clear()
         filter_input.send_keys("1")
         self.screenshot("rules_example_1_4_filter_header")
@@ -251,6 +268,7 @@ def test_rules_example_1_datasets(self):
         # self.history_panel_wait_for_hid_ok(6)
         # self.screenshot("rules_example_1_6_download_complete")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     @pytest.mark.local
@@ -278,6 +296,7 @@ def test_rules_example_2_list(self):
         # self.history_panel_wait_for_hid_ok(2)
         # self.screenshot("rules_example_2_5_download_complete")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     @pytest.mark.local
@@ -316,6 +335,7 @@ def test_rules_example_3_list_pairs(self):
         self.rule_builder_set_collection_name("PRJDB3920")
         self.screenshot("rules_example_3_14_paired_identifier_set")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     @pytest.mark.local
@@ -353,6 +373,7 @@ def test_rules_example_4_accessions(self):
         rule_builder.main_button_ok.wait_for_and_click()
         rule_builder.view_source.wait_for_visible()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     @pytest.mark.local
@@ -388,6 +409,7 @@ def test_rules_example_5_matching_collections(self):
         self.rule_builder_set_mapping("collection-name", "E")
         self.screenshot("rules_example_5_9_mapping")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.gtn_screenshot
     @pytest.mark.local
@@ -424,6 +446,7 @@ def test_rules_example_6_nested_lists(self):
         self.rule_builder_set_collection_name("PRJNA355367")
         self.screenshot("rules_example_6_7_named")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.local
     def test_rules_deferred_datasets(self):
@@ -453,7 +476,7 @@ def test_rules_deferred_datasets(self):
         rule_builder.menu_item_rule_type(rule_type="add-filter-count").wait_for_and_click()
         filter_editor = rule_builder.rule_editor(rule_type="add-filter-count")
         filter_editor_element = filter_editor.wait_for_visible()
-        filter_input = filter_editor_element.find_element(self.by.CSS_SELECTOR, "input[type='number']")
+        filter_input = filter_editor_element.find_element(By.CSS_SELECTOR, "input[type='number']")
         filter_input.clear()
         filter_input.send_keys("1")
         self.screenshot("rules_deferred_datasets_4_filter_header")
@@ -467,6 +490,7 @@ def test_rules_deferred_datasets(self):
         self.history_panel_wait_for_hid_deferred(6)
         self.screenshot("rules_deferred_datasets_8_download_complete")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @pytest.mark.local
     def test_rules_deferred_list(self):
@@ -517,14 +541,14 @@ def _scroll_to_end_of_table(self):
         rule_builder = self.components.rule_builder
         table_elem = rule_builder.table.wait_for_visible()
         # handsontable
-        # first_cell = table_elem.find_elements(self.by.CSS_SELECTOR, "td")[0]
+        # first_cell = table_elem.find_elements(By.CSS_SELECTOR, "td")[0]
         # aggrid
-        first_cell = table_elem.find_elements(self.by.CSS_SELECTOR, ".ag-cell")[0]
+        first_cell = table_elem.find_elements(By.CSS_SELECTOR, ".ag-cell")[0]
         action_chains = self.action_chains()
         action_chains.move_to_element(first_cell)
         action_chains.click(first_cell)
         for _ in range(15):
-            action_chains.send_keys(self.keys.ARROW_RIGHT)
+            action_chains.send_keys(Keys.ARROW_RIGHT)
         action_chains.perform()
 
     def _setup_uniprot_example(self):
diff --git a/lib/galaxy_test/selenium/test_visualizations.py b/lib/galaxy_test/selenium/test_visualizations.py
index 325acb824b50..1d415c7e7dd9 100644
--- a/lib/galaxy_test/selenium/test_visualizations.py
+++ b/lib/galaxy_test/selenium/test_visualizations.py
@@ -4,6 +4,7 @@
 )
 from .framework import (
     managed_history,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -30,6 +31,7 @@ def test_charts_image_annotate(self):
             self.wait_for_selector("#image-annotate")
             self.screenshot("visualization_plugin_charts_image_annotate")
 
+    @selenium_only("Not yet migrated to support Playwright backend - need to implement shadow DOM absractions")
     @selenium_test
     @skip_without_visualization_plugin("tabulator")
     def test_charts_tabulator(self):
@@ -44,6 +46,7 @@ def test_charts_tabulator(self):
             self.wait_for_selector(".tabulator-table")
             self.screenshot("visualization_plugin_tabulator_landing")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @skip_without_visualization_plugin("h5web")
     def test_charts_h5web(self):
@@ -61,6 +64,7 @@ def test_charts_h5web(self):
 class TestVisualizations(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend - need to implement shadow DOM absractions")
     @selenium_test
     @managed_history
     @skip_without_visualization_plugin("igv")
diff --git a/lib/galaxy_test/selenium/test_workflow_editor.py b/lib/galaxy_test/selenium/test_workflow_editor.py
index e888918fd9bd..2bcfbe60ebb5 100644
--- a/lib/galaxy_test/selenium/test_workflow_editor.py
+++ b/lib/galaxy_test/selenium/test_workflow_editor.py
@@ -1,5 +1,8 @@
 import json
-from typing import Optional
+from typing import (
+    cast,
+    Optional,
+)
 
 import pytest
 import yaml
@@ -9,6 +12,7 @@
 from selenium.webdriver.remote.webelement import WebElement
 
 from galaxy.selenium.navigates_galaxy import ColumnDefinition
+from galaxy.selenium.web_element_protocol import WebElementProtocol
 from galaxy_test.base.workflow_fixtures import (
     WORKFLOW_NESTED_SIMPLE,
     WORKFLOW_OPTIONAL_TRUE_INPUT_COLLECTION,
@@ -24,6 +28,7 @@
 from .framework import (
     retry_assertion_during_transitions,
     RunsWorkflows,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
 )
@@ -53,6 +58,7 @@
 class TestWorkflowEditor(SeleniumTestCase, RunsWorkflows):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_basics(self):
         editor = self.components.workflow_editor
@@ -75,6 +81,7 @@ def test_basics(self):
 
         self.screenshot("workflow_editor_center_pane_maximized")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_edit_annotation(self):
         editor = self.components.workflow_editor
@@ -91,6 +98,7 @@ def test_edit_annotation(self):
         self.workflow_index_open_with_name(name)
         self.assert_wf_annotation_is(new_annotation)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_edit_name(self):
         name = self.create_and_wait_for_new_workflow_in_editor()
@@ -102,6 +110,7 @@ def test_edit_name(self):
         self.workflow_index_open_with_name(new_name)
         self.assert_wf_name_is(name)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_edit_license(self):
         editor = self.components.workflow_editor
@@ -115,6 +124,7 @@ def test_edit_license(self):
         self.workflow_index_open_with_name(name)
         assert "MIT" in self.workflow_editor_license_text()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_parameter_regex_validation(self):
         editor = self.components.workflow_editor
@@ -144,6 +154,7 @@ def test_parameter_regex_validation(self):
         element = workflow_run.run_error.wait_for_present()
         assert "input must start with moocow" in element.text
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_int_parameter_minimum_validation(self):
         editor = self.components.workflow_editor
@@ -170,6 +181,7 @@ def test_int_parameter_minimum_validation(self):
         # in parameter validators
         assert "Value ('3') must fulfill (4 <= value <= +infinity)" in element.text, element.text
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_float_parameter_maximum_validation(self):
         editor = self.components.workflow_editor
@@ -194,6 +206,7 @@ def test_float_parameter_maximum_validation(self):
         # friendly.
         assert "Value ('3.2') must fulfill (-infinity <= value <= 3.14)" in element.text, element.text
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_optional_select_data_field(self):
         editor = self.components.workflow_editor
@@ -222,6 +235,7 @@ def test_optional_select_data_field(self):
         tool_state = json.loads(workflow["steps"]["0"]["tool_state"])
         assert tool_state["select_single"] == ""
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_data_input(self):
         editor = self.components.workflow_editor
@@ -246,6 +260,7 @@ def test_data_input(self):
         data_input_node.wait_for_absent()
         self.screenshot("workflow_editor_data_input_deleted")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_collection_input(self):
         editor = self.components.workflow_editor
@@ -271,6 +286,7 @@ def test_collection_input(self):
         self.sleep_for(self.wait_types.UX_RENDER)
         self.screenshot("workflow_editor_data_collection_input_deleted")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_collection_input_sample_sheet_chipseq_example(self):
         editor = self.components.workflow_editor
@@ -310,6 +326,7 @@ def test_collection_input_sample_sheet_chipseq_example(self):
         assert control["type"] == "element_identifier"
         assert control["optional"] is True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_data_column_input_editing(self):
         self.open_in_workflow_editor(
@@ -341,6 +358,7 @@ def test_data_column_input_editing(self):
         textarea_columns = columns.wait_for_visible()
         assert textarea_columns.get_attribute("value") == "4\n5\n6\n"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_integer_input(self):
         editor = self.components.workflow_editor
@@ -366,6 +384,7 @@ def test_integer_input(self):
         self.sleep_for(self.wait_types.UX_RENDER)
         self.screenshot("workflow_editor_parameter_input_deleted")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_non_data_connections(self):
         self.open_in_workflow_editor(
@@ -421,6 +440,7 @@ def test_non_data_connections(self):
         )
         self.assert_connected("input_int#output", "tool_exec#inttest")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_non_data_map_over_carried_through(self):
         # Use auto_layout=false, which prevents placing any
@@ -450,6 +470,8 @@ def test_non_data_map_over_carried_through(self):
         self.workflow_editor_connect("text_input_step#out_file1", "collection_input#input1")
         self.assert_connected("text_input_step#out_file1", "collection_input#input1")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
+    @selenium_test
     def test_connecting_display_in_upload_false_connections(self):
         self.open_in_workflow_editor(
             """
@@ -465,6 +487,7 @@ def test_connecting_display_in_upload_false_connections(self):
         self.workflow_editor_connect("step1#qname_input_sorted_bam_output", "step2#input5")
         self.assert_connected("step1#qname_input_sorted_bam_output", "step2#input5")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_existing_connections(self):
         self.open_in_workflow_editor(WORKFLOW_SIMPLE_CAT_TWICE)
@@ -487,6 +510,7 @@ def test_existing_connections(self):
         )
         self.assert_connected("input1#output", "first_cat#input1")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_reconnecting_nodes(self):
         name = self.open_in_workflow_editor(WORKFLOW_SIMPLE_CAT_TWICE)
@@ -500,6 +524,7 @@ def test_reconnecting_nodes(self):
         self.workflow_index_open_with_name(name)
         self.assert_connected("input1#output", "first_cat#input1")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_change_stack_inserting_inputs(self):
         editor = self.components.workflow_editor
@@ -543,6 +568,7 @@ def test_editor_change_stack_inserting_inputs(self):
         editor.node.by_id(id=1).wait_for_present()
         editor.node.by_id(id=2).wait_for_present()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_change_stack_set_attributes(self):
         editor = self.components.workflow_editor
@@ -575,12 +601,14 @@ def test_editor_change_stack_set_attributes(self):
 
         self.assert_wf_annotation_is(annotation)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rendering_output_collection_connections(self):
         self.open_in_workflow_editor(WORKFLOW_WITH_OUTPUT_COLLECTION)
         self.workflow_editor_maximize_center_pane()
         self.screenshot("workflow_editor_output_collections")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_simple_mapping_connections(self):
         self.open_in_workflow_editor(WORKFLOW_SIMPLE_MAPPING)
@@ -594,12 +622,14 @@ def test_simple_mapping_connections(self):
         self.workflow_editor_connect("input1#output", "cat#input1")
         self.assert_input_mapped("cat#input1")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rendering_simple_nested_workflow(self):
         self.open_in_workflow_editor(WORKFLOW_NESTED_SIMPLE)
         self.workflow_editor_maximize_center_pane()
         self.screenshot("workflow_editor_simple_nested")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_best_practices_input_label(self):
         editor = self.components.workflow_editor
@@ -632,6 +662,7 @@ def assert_linting_input_metadata_okay():
 
         assert_linting_input_metadata_okay()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rendering_rules_workflow_1(self):
         self.open_in_workflow_editor(WORKFLOW_WITH_RULES_1)
@@ -648,6 +679,7 @@ def test_rendering_rules_workflow_1(self):
         self.assert_connected(rule_output, random_lines_input)
         self.assert_input_mapped(random_lines_input)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rendering_rules_workflow_2(self):
         self.open_in_workflow_editor(WORKFLOW_WITH_RULES_2)
@@ -696,6 +728,7 @@ def test_rendering_rules_workflow_2(self):
         # to a list:list, so there should be no mapping anymore even after connected.
         self.assert_input_not_mapped(copy_list_input)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_save_as(self):
         name = self.workflow_upload_yaml_with_random_name(WORKFLOW_SIMPLE_CAT_TWICE)
@@ -706,6 +739,7 @@ def test_save_as(self):
 
         self.components.workflow_editor.save_as_activity.wait_for_and_click()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_tool_upgrade(self):
         workflow_populator = self.workflow_populator
@@ -739,6 +773,7 @@ def test_editor_tool_upgrade(self):
         workflow = self.workflow_populator.download_workflow(workflow_id)
         assert workflow["steps"]["0"]["tool_version"] == "0.1+galaxy6"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_tool_upgrade_all_tools(self):
         editor = self.components.workflow_editor
@@ -755,6 +790,7 @@ def test_editor_tool_upgrade_all_tools(self):
         version = node.get_attribute("data-version")
         assert version == "0.2"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_tool_upgrade_message(self):
         workflow_populator = self.workflow_populator
@@ -766,6 +802,7 @@ def test_editor_tool_upgrade_message(self):
         self.components.workflow_editor.modal_button_continue.wait_for_and_click()
         self.assert_workflow_has_changes_and_save()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_subworkflow_tool_upgrade_message(self):
         workflow_populator = self.workflow_populator
@@ -803,6 +840,7 @@ def set_text_element(element, value):
         element.wait_for_and_send_keys(Keys.BACKSPACE)
         element.wait_for_and_send_keys(value)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_change_datatype(self):
         self.open_in_workflow_editor(
@@ -840,6 +878,7 @@ def test_change_datatype(self):
         # Assert connection is valid
         self.assert_connected("create_2#out_file1", "checksum#input")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_change_datatype_post_job_action_lost_regression(self):
         self.open_in_workflow_editor(
@@ -864,6 +903,7 @@ def test_change_datatype_post_job_action_lost_regression(self):
         node.wait_for_and_click()
         self.assert_connected("create_2#out_file1", "metadata_bam#input_bam")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_change_datatype_in_subworkflow(self):
         self.open_in_workflow_editor(
@@ -898,6 +938,7 @@ def test_change_datatype_in_subworkflow(self):
         self.assert_connected("nested_workflow#workflow_output", "metadata_bam#input_bam")
 
     @pytest.mark.xfail
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_edit_subworkflow(self):
         self.open_in_workflow_editor(
@@ -921,6 +962,7 @@ def test_edit_subworkflow(self):
         node = editor.node._(label="create_2")
         node.wait_for_and_click()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_duplicate_node(self):
         workflow_id = self.workflow_populator.upload_yaml_workflow(WORKFLOW_SIMPLE_CAT_TWICE)
@@ -963,6 +1005,7 @@ def test_editor_duplicate_node(self):
         assert len(source_step["post_job_actions"]) == len(cloned_step["post_job_actions"]) == 4
         assert source_step["post_job_actions"] == cloned_step["post_job_actions"]
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_embed_workflow(self):
         self.setup_subworkflow()
@@ -1005,6 +1048,7 @@ def setup_subworkflow(self):
         assert subworkflow_step["input_connections"]["input1"]["input_subworkflow_step_id"] == 0
         return child_workflow_name
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_insert_steps(self):
         steps_to_insert = self.workflow_upload_yaml_with_random_name(WORKFLOW_SIMPLE_CAT_TWICE)
@@ -1025,6 +1069,7 @@ def _download_current_workflow(self):
         workflow = self.workflow_populator.download_workflow(workflow_id)
         return workflow
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_create_conditional_step(self):
         editor = self.components.workflow_editor
@@ -1084,6 +1129,8 @@ def test_editor_create_conditional_step(self):
         # TODO: hook up best practice panel, disable save when "when" not connected
         # assert save_button.has_class("disabled")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
+    @selenium_test
     def test_conditional_subworkflow_step(self):
         child_workflow_name = self.setup_subworkflow()
         editor = self.components.workflow_editor
@@ -1108,6 +1155,7 @@ def switch_param_type(self, element, param_type):
             Keys.ENTER
         ).perform()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_invalid_tool_state(self):
         workflow_populator = self.workflow_populator
@@ -1118,6 +1166,7 @@ def test_editor_invalid_tool_state(self):
         self.assert_modal_has_text("Using default: '1'")
         self.screenshot("workflow_editor_invalid_state")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_missing_tools(self):
         workflow_populator = self.workflow_populator
@@ -1152,6 +1201,7 @@ def tab_to(self, accessible_name, direction="forward"):
         else:
             raise Exception(f"Could not tab to element containing '{accessible_name}' in aria-label")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_aria_connections_menu(self):
         self.open_in_workflow_editor(
@@ -1192,6 +1242,7 @@ def test_aria_connections_menu(self):
         output_connector.send_keys(Keys.SPACE)
         assert self.driver.switch_to.active_element.text == "No compatible input found in workflow"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_insert_input_handling(self):
         self.open_in_workflow_editor(
@@ -1212,6 +1263,7 @@ def test_insert_input_handling(self):
         node.input_terminal(name="datasets_1|input").wait_for_present()
         self.assert_workflow_has_changes_and_save()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_workflow_output_handling(self):
         self.open_in_workflow_editor(
@@ -1283,6 +1335,7 @@ def test_workflow_output_handling(self):
         # should not show error
         editor.duplicate_label_error(output="out_file1").wait_for_absent()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_map_over_output_indicator(self):
         self.open_in_workflow_editor(
@@ -1308,6 +1361,7 @@ def test_map_over_output_indicator(self):
         self.workflow_editor_destroy_connection("filter#how|filter_source")
         self.assert_node_output_is("filter#output_filtered", "list")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_place_comments(self):
         editor = self.components.workflow_editor
@@ -1331,7 +1385,7 @@ def test_editor_place_comments(self):
         self.action_chains().send_keys("Hello World").perform()
 
         # check if all options were applied
-        comment_content: WebElement = editor.comment.text_inner.wait_for_visible()
+        comment_content: WebElementProtocol = editor.comment.text_inner.wait_for_visible()
         assert comment_content.text == "Hello World"
         comment_content_class = comment_content.get_attribute("class")
         assert comment_content_class
@@ -1356,7 +1410,7 @@ def test_editor_place_comments(self):
 
         editor.tool_bar.tool(tool="pointer").wait_for_and_click()
 
-        markdown_comment_content: WebElement = editor.comment.markdown_rendered.wait_for_visible()
+        markdown_comment_content: WebElementProtocol = editor.comment.markdown_rendered.wait_for_visible()
         assert markdown_comment_content.text == "Hello World"
         assert markdown_comment_content.find_element(By.TAG_NAME, "h2") is not None
 
@@ -1375,7 +1429,7 @@ def test_editor_place_comments(self):
         self.mouse_drag(from_element=canvas, from_offset=(-200, -150), to_offset=(400, 300))
         self.action_chains().send_keys("My Frame").perform()
 
-        title: WebElement = editor.comment.frame_title.wait_for_visible()
+        title: WebElementProtocol = editor.comment.frame_title.wait_for_visible()
         assert title.text == "My Frame"
 
         width, height = self.get_element_size(editor.comment._.wait_for_visible())
@@ -1416,7 +1470,7 @@ def test_editor_place_comments(self):
 
         self.mouse_drag(from_element=canvas, from_offset=(-100, -100), to_offset=(200, 200))
 
-        freehand_comment_a: WebElement = editor.comment.freehand_comment.wait_for_visible()
+        freehand_comment_a: WebElementProtocol = editor.comment.freehand_comment.wait_for_visible()
 
         # delete by clicking
         editor.tool_bar.tool(tool="freehand_eraser").wait_for_and_click()
@@ -1430,7 +1484,7 @@ def test_editor_place_comments(self):
 
         self.mouse_drag(from_element=canvas, from_offset=(-100, -100), to_offset=(200, 200))
 
-        freehand_comment_b: WebElement = editor.comment.freehand_comment.wait_for_visible()
+        freehand_comment_b: WebElementProtocol = editor.comment.freehand_comment.wait_for_visible()
 
         editor.tool_bar.tool(tool="freehand_eraser").wait_for_and_click()
         self.mouse_drag(
@@ -1439,6 +1493,7 @@ def test_editor_place_comments(self):
 
         editor.comment.freehand_comment.wait_for_absent()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_snapping(self):
         editor = self.components.workflow_editor
@@ -1474,6 +1529,7 @@ def test_editor_snapping(self):
         assert top % 200 == 0
         assert left % 200 == 0
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_editor_selection(self):
         editor = self.components.workflow_editor
@@ -1570,7 +1626,7 @@ def get_node_position(self, label: str):
 
         return self.get_element_position(node)
 
-    def get_element_position(self, element: WebElement):
+    def get_element_position(self, element: WebElementProtocol):
         left = element.value_of_css_property("left")
         top = element.value_of_css_property("top")
 
@@ -1579,7 +1635,7 @@ def get_element_position(self, element: WebElement):
 
         return (int(left_stripped), int(top_stripped))
 
-    def get_element_size(self, element: WebElement):
+    def get_element_size(self, element: WebElementProtocol):
         width = element.value_of_css_property("width")
         height = element.value_of_css_property("height")
 
@@ -1689,6 +1745,8 @@ def assert_modal_has_text(self, expected_text):
         assert expected_text in text, f"Failed to find expected text [{expected_text}] in modal text [{text}]"
 
     def move_center_of_canvas(self, xoffset=0, yoffset=0):
-        canvas = self.find_element_by_id("canvas-container")
+        _canvas = self.find_element_by_id("canvas-container")
+        assert self.backend_type == "selenium"
+        canvas = cast(WebElement, _canvas)
         chains = ActionChains(self.driver)
         chains.click_and_hold(canvas).move_by_offset(xoffset=xoffset, yoffset=yoffset).release().perform()
diff --git a/lib/galaxy_test/selenium/test_workflow_management.py b/lib/galaxy_test/selenium/test_workflow_management.py
index fcd1ddcdacd5..91abef1fa8a7 100644
--- a/lib/galaxy_test/selenium/test_workflow_management.py
+++ b/lib/galaxy_test/selenium/test_workflow_management.py
@@ -3,6 +3,7 @@
 from .framework import (
     EXAMPLE_WORKFLOW_URL_1,
     retry_assertion_during_transitions,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     TestsGalaxyPagers,
@@ -13,6 +14,7 @@
 class TestWorkflowManagement(SeleniumTestCase, TestsGalaxyPagers, UsesWorkflowAssertions):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_import_from_url(self):
         self.workflow_index_open()
@@ -24,6 +26,7 @@ def test_import_from_url(self):
         first_workflow_card = workflow_cards[0].find_element(By.CSS_SELECTOR, '[id^="g-card-title-"] a')
         assert "TestWorkflow1 (imported from URL)" in first_workflow_card.text, first_workflow_card.text
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_import_accessibility(self):
         self.workflow_index_open()
@@ -37,6 +40,7 @@ def test_import_accessibility(self):
         # ditto - moderate violation relating to header ordering
         workflows.import_trs_id.assert_no_axe_violations_with_impact_of_at_least("serious")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_view(self):
         self.workflow_index_open()
@@ -53,6 +57,7 @@ def test_view(self):
         workflow_preview = self.components.workflows.workflow_preview_container.wait_for_visible()
         assert "TestWorkflow1" in workflow_preview.text
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_rename(self):
         self.workflow_index_open()
@@ -66,6 +71,7 @@ def check_name():
 
         check_name()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_workflow_index_accessibility(self):
         self.workflow_index_open()
@@ -74,6 +80,7 @@ def test_workflow_index_accessibility(self):
         # this test will be more rigorous but test only a specific component.
         index_table.assert_no_axe_violations_with_impact_of_at_least("critical")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_download(self):
         self.workflow_index_open()
@@ -82,6 +89,7 @@ def test_download(self):
         # going through the motions though should catch a couple potential problems.
         self.components.workflows.download_button.wait_for_and_click()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_tagging(self):
         self.workflow_index_open()
@@ -96,6 +104,7 @@ def check_tags():
         check_tags()
         self.screenshot("workflow_manage_tags")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_tag_filtering(self):
         self.workflow_index_open()
@@ -127,6 +136,7 @@ def test_tag_filtering(self):
         self._assert_showing_n_workflows(4)
         self.workflow_index_search_for("MyTaG")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_index_search(self):
         self.workflow_index_open()
@@ -144,6 +154,7 @@ def test_index_search(self):
         self.workflow_index_search_for("searchforthis")
         self._assert_showing_n_workflows(1)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_index_search_filters(self):
         self.workflow_index_open()
@@ -170,6 +181,7 @@ def test_index_search_filters(self):
         self.components.workflows.workflow_not_found_message.wait_for_visible()
         self.screenshot("workflow_manage_search_name_alias")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_index_advanced_search(self):
         self.workflow_index_open()
@@ -199,6 +211,7 @@ def test_index_advanced_search(self):
         assert curr_value == "tag:'mytag' tag:'DNEtag'", curr_value
         self.components.workflows.workflow_not_found_message.wait_for_visible()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_workflow_delete(self):
         self.workflow_index_open()
@@ -211,6 +224,7 @@ def test_workflow_delete(self):
         self.workflow_index_open()
         self.components.workflows.workflows_list_empty.wait_for_visible()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_workflow_bookmark_filtering(self):
         self.workflow_index_open()
diff --git a/lib/galaxy_test/selenium/test_workflow_rerun.py b/lib/galaxy_test/selenium/test_workflow_rerun.py
index bd6e1731271b..186f4ff5d924 100644
--- a/lib/galaxy_test/selenium/test_workflow_rerun.py
+++ b/lib/galaxy_test/selenium/test_workflow_rerun.py
@@ -3,6 +3,7 @@
     managed_history,
     retry_assertion_during_transitions,
     RunsWorkflows,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesHistoryItemAssertions,
@@ -12,6 +13,7 @@
 class TestWorkflowRun(SeleniumTestCase, UsesHistoryItemAssertions, RunsWorkflows):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_workflow_rerun(self):
diff --git a/lib/galaxy_test/selenium/test_workflow_run.py b/lib/galaxy_test/selenium/test_workflow_run.py
index d104614106c3..793c26051b64 100644
--- a/lib/galaxy_test/selenium/test_workflow_run.py
+++ b/lib/galaxy_test/selenium/test_workflow_run.py
@@ -28,6 +28,7 @@
 from .framework import (
     managed_history,
     RunsWorkflows,
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesHistoryItemAssertions,
@@ -38,6 +39,7 @@
 class TestWorkflowRun(SeleniumTestCase, UsesHistoryItemAssertions, RunsWorkflows):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_workflow_export_file_rocrate(self):
@@ -63,6 +65,7 @@ def test_workflow_export_file_rocrate(self):
         invocations.export_download_link.wait_for_present()
         self.screenshot("invocation_export_crate_download_ready")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_workflow_export_file_native(self):
@@ -88,6 +91,7 @@ def test_workflow_export_file_native(self):
         invocations.export_download_link.wait_for_present()
         self.screenshot("invocation_export_native_download_ready")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_simple_execution(self):
@@ -102,6 +106,7 @@ def test_simple_execution(self):
         self.assert_item_summary_includes(2, "2 sequences")
         self.screenshot("workflow_run_simple_complete")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_expanded_execution_of_simple_workflow(self):
@@ -241,6 +246,7 @@ def tab_if_element_identifier_mutable():
             sample_sheet.select_picker.wait_for_and_click()
             sample_sheet.select_item(item=control).wait_for_and_click()
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_collection_input_sample_sheet_chipseq_example_from_uris(self):
@@ -311,6 +317,7 @@ def _expect_chipseq_table(self, history_id: str, hid: int):
             contents == expected_contents
         ), f"Expected chipseq sample sheet table:\n{expected_contents}\nGot:\n{contents}"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_collection_input_sample_sheet_chipseq_example_from_list_pairs(self):
@@ -373,6 +380,7 @@ def test_collection_input_sample_sheet_chipseq_example_from_list_pairs(self):
         self.workflow_run_submit()
         self._expect_chipseq_table(history_id, 51)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_runtime_parameters_simple(self):
@@ -387,6 +395,7 @@ def test_runtime_parameters_simple(self):
 
         self._assert_has_3_lines_after_run(hid=2)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_runtime_parameters_simple_optional(self):
@@ -410,6 +419,7 @@ def test_runtime_parameters_simple_optional(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=1)
         assert json.loads(content) == 3
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_subworkflows_expanded(self):
@@ -422,6 +432,7 @@ def test_subworkflows_expanded(self):
         self.components.workflow_run.subworkflow_step_icon.wait_for_and_click()
         self.screenshot("workflow_run_nested_open")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_subworkflow_runtime_parameters(self):
@@ -438,6 +449,7 @@ def test_subworkflow_runtime_parameters(self):
 
         self._assert_has_3_lines_after_run(hid=2)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_replacement_parameters(self):
@@ -455,6 +467,7 @@ def test_replacement_parameters(self):
         details = self.dataset_populator.get_history_dataset_details(history_id, hid=output_hid)
         assert details["name"] == "moocow suffix", details
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_step_parameter_inputs(self):
@@ -491,6 +504,7 @@ def test_step_parameter_inputs(self):
         assert "12345" in content, content
         assert "chr6_hla_hap2" in content
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_replacement_parameters_on_subworkflows(self):
@@ -508,6 +522,7 @@ def test_replacement_parameters_on_subworkflows(self):
         details = self.dataset_populator.get_history_dataset_details(history_id, hid=output_hid)
         assert details["name"] == "moocow suffix", details
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_execution_with_tool_upgrade(self):
         name = self.workflow_upload_yaml_with_random_name(WORKFLOW_WITH_OLD_TOOL_VERSION, exact_tools=True)
@@ -517,6 +532,7 @@ def test_execution_with_tool_upgrade(self):
         self.assert_message(self.components.workflow_run.warning, contains="tools which have changed")
         self.screenshot("workflow_run_tool_upgrade")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_run_form_safe_upgrade_handling(self):
         workflow_with_rules = yaml.safe_load(WORKFLOW_WITH_RULES_1)
@@ -549,6 +565,7 @@ def test_execution_with_multiple_inputs(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=7)
         assert "10.0\n30.0\n20.0\n40.0\n" == content
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_execution_with_text_default_value_connected_to_restricted_select(self):
@@ -661,6 +678,7 @@ def test_workflow_run_tag_filter(self):
         invocation = self.workflow_populator.get_invocation(invocations[-1]["id"])
         assert invocation["inputs"]["0"]["id"] == dataset["id"]
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_workflow_run_list_paired_or_unpaired_with_paired_list(self):
@@ -682,6 +700,7 @@ def test_workflow_run_list_paired_or_unpaired_with_paired_list(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=6)
         assert content.strip() == "forward content\nreverse content"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_workflow_run_list_paired_or_unpaired_with_flat_list(self):
@@ -703,6 +722,7 @@ def test_workflow_run_list_paired_or_unpaired_with_flat_list(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=6)
         assert content.strip() == "reverse content\nforward content"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_workflow_run_list_paired_or_unpaired_with_mixed_list(self):
@@ -725,6 +745,7 @@ def test_workflow_run_list_paired_or_unpaired_with_mixed_list(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=8)
         assert content.strip() == "forward content\nreverse content\nunpaired content"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_upload_dataset_from_workflow_simple(self):
@@ -739,6 +760,7 @@ def test_upload_dataset_from_workflow_simple(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=2)
         assert content.strip() == "hello world\nhello world"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_modal_upload_updates_form(self):
@@ -771,6 +793,7 @@ def test_modal_upload_updates_form(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=6)
         assert content.strip() == "hello world"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_upload_list_from_workflow_simple(self):
@@ -785,6 +808,7 @@ def test_upload_list_from_workflow_simple(self):
         self.workflow_run_submit()
         self.history_panel_wait_for_hid_ok(6)
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_upload_list_paired_from_workflow(self):
@@ -802,6 +826,7 @@ def test_upload_list_paired_from_workflow(self):
         content = self.dataset_populator.get_history_dataset_content(history_id, hid=7)
         assert content.strip() == "hello world\nhello world"
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     @managed_history
     def test_upload_list_paired_or_unpaired_from_workflow(self):
diff --git a/lib/galaxy_test/selenium/test_workflow_sharing.py b/lib/galaxy_test/selenium/test_workflow_sharing.py
index bd93e14f004f..d7c27c8744da 100644
--- a/lib/galaxy_test/selenium/test_workflow_sharing.py
+++ b/lib/galaxy_test/selenium/test_workflow_sharing.py
@@ -1,5 +1,6 @@
 from galaxy_test.base.workflow_fixtures import WORKFLOW_SIMPLE_CAT_TWICE
 from .framework import (
+    selenium_only,
     selenium_test,
     SeleniumTestCase,
     UsesWorkflowAssertions,
@@ -9,6 +10,7 @@
 class TestWorkflowSharingRedirect(SeleniumTestCase):
     ensure_registered = True
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_share_workflow_with_login_redirect(self):
         user_email = self.get_user_email()
@@ -22,6 +24,7 @@ def test_share_workflow_with_login_redirect(self):
         self.wait_for_logged_in()
         self.wait_for_selector(".make-accessible")
 
+    @selenium_only("Not yet migrated to support Playwright backend")
     @selenium_test
     def test_export_workflow_with_login_redirect(self):
         user_email = self.get_user_email()
diff --git a/packages/README.md b/packages/README.md
new file mode 100644
index 000000000000..550d5663d4a2
--- /dev/null
+++ b/packages/README.md
@@ -0,0 +1,74 @@
+# Package-centric Galaxy
+
+You clone Galaxy as a [Monorepo](https://en.wikipedia.org/wiki/Monorepo) for
+its Python backend. This packages directory allows us to distribute smaller
+connected repositories out of individual Galaxy components. CI ensures these
+repositories have valid dependencies and such defined by running each 
+components tests in isolation.
+
+## Development
+
+Typically Galaxy developers develop against the monorepo but there are times
+when developing against a small unit of Galaxy might make sense - such as to 
+keep an AI (or human cognitive) context as small as possible.
+
+This can be done by treating Galaxy as a
+[uv workspace](https://docs.astral.sh/uv/concepts/projects/workspaces/).
+The pyproject.toml file in this directory defines a workspace for Galaxy
+and allows development and testing of individual packages with
+[uv](https://docs.astral.sh/uv/).
+
+Here is an example workflow that will run tests for a specific package
+after setting up a virtual environment for that package.
+
+    $ git clone https://github.com/galaxyproject/galaxy.git
+    $ cd galaxy/packages
+    $ cd auth
+    $ uv sync --all-extras
+    $ uv run pytest tests
+
+When switching between projects it is just important to remember
+to rerun the sync command for that project.
+
+The package ``Makefile`` has been updated to use ux also, so the above can
+be simplified to just:
+
+    $ git clone https://github.com/galaxyproject/galaxy.git
+    $ cd galaxy/packages
+    $ cd auth
+    $ make test
+
+If the environment has already been setup and you wish to just re-run
+the tests. The ``make _test`` command be used to just do the testing in
+the existing environment without messing with ``sync`` and adjusting
+dependencies.
+
+The ``Makefile`` can also be used for typechecking.
+
+    $ git clone https://github.com/galaxyproject/galaxy.git
+    $ cd galaxy/packages
+    $ cd auth
+    $ make mypy
+    $ make _mypy  # a shortcut to just run mypy on an existing updated environment
+
+This is equivalent to syncing the uv environment and then adding
+Galaxy's type checking dependencies to it.
+
+    $ uv sync --all-extras
+    $ uv pip install -r ../../lib/galaxy/dependencies/pinned-typecheck-requirements.txt
+    $ uv run mypy .
+
+The ``Makefile`` can also be used for linting.
+
+    $ git clone https://github.com/galaxyproject/galaxy.git
+    $ cd galaxy/packages
+    $ cd auth
+    $ make lint
+    $ make _lint  # a shortcut to just run ruff on an existing updated environment
+
+This is equivalent to syncing the uv environment and then adding
+Galaxy's linting dependencies to it.
+
+    $ uv sync --all-extras
+    $ uv pip install -r ../../lib/galaxy/dependencies/pinned-lint-requirements.txt
+    $ uv run ruff check .
diff --git a/packages/app/pyproject.toml b/packages/app/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/app/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/app/pyproject.toml b/packages/app/pyproject.toml
new file mode 100644
index 000000000000..655a41acfd4e
--- /dev/null
+++ b/packages/app/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-app"
diff --git a/packages/app/setup.cfg b/packages/app/setup.cfg
index c6c6ef4bfa75..a2be829a76e4 100644
--- a/packages/app/setup.cfg
+++ b/packages/app/setup.cfg
@@ -82,6 +82,15 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+
+[options.extras_require]
+test = 
+    mock-ssh-server
+    pkce
+    pykwalify
+    pytest
+    testfixtures
+
 [options.entry_points]
 console_scripts =
         galaxy-main = galaxy.main:main
diff --git a/packages/app/test-requirements.txt b/packages/app/test-requirements.txt
deleted file mode 100644
index 7075b49702b9..000000000000
--- a/packages/app/test-requirements.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-mock-ssh-server
-pkce
-pykwalify
-pytest
-testfixtures
diff --git a/packages/auth/pyproject.toml b/packages/auth/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/auth/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/auth/pyproject.toml b/packages/auth/pyproject.toml
new file mode 100644
index 000000000000..be832b355d28
--- /dev/null
+++ b/packages/auth/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-auth"
diff --git a/packages/auth/setup.cfg b/packages/auth/setup.cfg
index 1ae49de86785..5bdec8baa77f 100644
--- a/packages/auth/setup.cfg
+++ b/packages/auth/setup.cfg
@@ -37,6 +37,12 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+
+[options.extras_require]
+test = 
+    pytest
+
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/auth/test-requirements.txt b/packages/auth/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/auth/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/config/pyproject.toml b/packages/config/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/config/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/config/pyproject.toml b/packages/config/pyproject.toml
new file mode 100644
index 000000000000..f9a555410a1f
--- /dev/null
+++ b/packages/config/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-config"
diff --git a/packages/config/setup.cfg b/packages/config/setup.cfg
index fc0a745e5523..cd63fb029399 100644
--- a/packages/config/setup.cfg
+++ b/packages/config/setup.cfg
@@ -40,6 +40,11 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+    gravity>=1.1.1
+
 [options.entry_points]
 console_scripts =
         galaxy-config = galaxy.config.script:main
diff --git a/packages/config/test-requirements.txt b/packages/config/test-requirements.txt
deleted file mode 100644
index 410fb268291c..000000000000
--- a/packages/config/test-requirements.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-gravity>=1.1.1
-pytest
diff --git a/packages/data/pyproject.toml b/packages/data/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/data/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/data/pyproject.toml b/packages/data/pyproject.toml
new file mode 100644
index 000000000000..5cd2a13695d4
--- /dev/null
+++ b/packages/data/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-data"
diff --git a/packages/data/setup.cfg b/packages/data/setup.cfg
index a48429222bf1..a0d4d27acc66 100644
--- a/packages/data/setup.cfg
+++ b/packages/data/setup.cfg
@@ -67,6 +67,12 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+
+[options.extras_require]
+test = 
+    pytest
+    roc-validator
+
 [options.entry_points]
 console_scripts =
         galaxy-build-objects = galaxy.model.store.build_objects:main
diff --git a/packages/data/test-requirements.txt b/packages/data/test-requirements.txt
deleted file mode 100644
index 91b7edccee09..000000000000
--- a/packages/data/test-requirements.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-pytest
-roc-validator
diff --git a/packages/files/pyproject.toml b/packages/files/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/files/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/files/pyproject.toml b/packages/files/pyproject.toml
new file mode 100644
index 000000000000..6d5a077a0b8c
--- /dev/null
+++ b/packages/files/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-files"
diff --git a/packages/files/setup.cfg b/packages/files/setup.cfg
index 3acd66a2e5a8..6de36cf65809 100644
--- a/packages/files/setup.cfg
+++ b/packages/files/setup.cfg
@@ -39,6 +39,12 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+    fs-gcsfs
+    s3fs>=2023.1.0,<2024
+
 [options.entry_points]
 console_scripts =
         galaxy-file-sources-conf-validation = galaxy.files.validate.script:main
diff --git a/packages/files/test-requirements.txt b/packages/files/test-requirements.txt
deleted file mode 100644
index ad572b378cec..000000000000
--- a/packages/files/test-requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-pytest
-fs-gcsfs
-s3fs>=2023.1.0,<2024
diff --git a/packages/job_execution/pyproject.toml b/packages/job_execution/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/job_execution/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/job_execution/pyproject.toml b/packages/job_execution/pyproject.toml
new file mode 100644
index 000000000000..d9f64c9a39f6
--- /dev/null
+++ b/packages/job_execution/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-job-execution"
diff --git a/packages/job_execution/setup.cfg b/packages/job_execution/setup.cfg
index 230c6f28921a..573a297f61b2 100644
--- a/packages/job_execution/setup.cfg
+++ b/packages/job_execution/setup.cfg
@@ -42,6 +42,10 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.entry_points]
 console_scripts =
         galaxy-set-metadata = galaxy.metadata.set_metadata:set_metadata
diff --git a/packages/job_execution/test-requirements.txt b/packages/job_execution/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/job_execution/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/job_metrics/pyproject.toml b/packages/job_metrics/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/job_metrics/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/job_metrics/pyproject.toml b/packages/job_metrics/pyproject.toml
new file mode 100644
index 000000000000..ced51f974cd1
--- /dev/null
+++ b/packages/job_metrics/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-job-metrics"
diff --git a/packages/job_metrics/setup.cfg b/packages/job_metrics/setup.cfg
index 45572bbe8949..9e70e8ae7dd5 100644
--- a/packages/job_metrics/setup.cfg
+++ b/packages/job_metrics/setup.cfg
@@ -38,6 +38,10 @@ install_requires =
 packages = find:
 python_requires = >=3.8
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/job_metrics/test-requirements.txt b/packages/job_metrics/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/job_metrics/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/meta/pyproject.toml b/packages/meta/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/meta/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/meta/pyproject.toml b/packages/meta/pyproject.toml
new file mode 100644
index 000000000000..f01a4032007f
--- /dev/null
+++ b/packages/meta/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy"
diff --git a/packages/meta/test-requirements.txt b/packages/meta/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/meta/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/navigation/pyproject.toml b/packages/navigation/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/navigation/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/navigation/pyproject.toml b/packages/navigation/pyproject.toml
new file mode 100644
index 000000000000..9c8c800df809
--- /dev/null
+++ b/packages/navigation/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-navigation"
diff --git a/packages/navigation/setup.cfg b/packages/navigation/setup.cfg
index aa712a7a752a..2244c401feaf 100644
--- a/packages/navigation/setup.cfg
+++ b/packages/navigation/setup.cfg
@@ -29,6 +29,10 @@ name = galaxy-navigation
 url = https://github.com/galaxyproject/galaxy
 version = 25.1.dev0
 
+[options.extras_require]
+test = 
+    pytest
+
 [options]
 include_package_data = True
 install_requires =
diff --git a/packages/navigation/test-requirements.txt b/packages/navigation/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/navigation/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/objectstore/pyproject.toml b/packages/objectstore/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/objectstore/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/objectstore/pyproject.toml b/packages/objectstore/pyproject.toml
new file mode 100644
index 000000000000..48ceb3e89f58
--- /dev/null
+++ b/packages/objectstore/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-objectstore"
diff --git a/packages/objectstore/setup.cfg b/packages/objectstore/setup.cfg
index acf940f61add..cf9d9078eab1 100644
--- a/packages/objectstore/setup.cfg
+++ b/packages/objectstore/setup.cfg
@@ -39,6 +39,12 @@ install_requires =
 packages = find:
 python_requires = >=3.8
 
+[options.extras_require]
+test = 
+    pytest
+    boto3
+    azure-storage-blob
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/objectstore/test-requirements.txt b/packages/objectstore/test-requirements.txt
deleted file mode 100644
index 8077db870b39..000000000000
--- a/packages/objectstore/test-requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-pytest
-boto3
-azure-storage-blob
diff --git a/packages/package.Makefile b/packages/package.Makefile
index a49d9a16aa87..941de94c3e0f 100644
--- a/packages/package.Makefile
+++ b/packages/package.Makefile
@@ -13,6 +13,7 @@ PROJECT_NAME?=galaxy-$(shell basename $(CURDIR))
 PROJECT_NAME:=$(subst _,-,$(PROJECT_NAME))
 BRANCH?=$(shell git rev-parse --abbrev-ref HEAD)
 TEST_DIR?=tests
+DIST=dist
 TESTS?=$(SOURCE_DIR) $(TEST_DIR)
 
 .PHONY: clean-pyc clean-build docs clean
@@ -43,21 +44,51 @@ clean-tests:
 	rm -fr .tox/
 
 setup-venv:
-	if [ ! -d $(VENV) ]; then python -m venv $(VENV); exit; fi;
-	$(IN_VENV) pip install -r dev-requirements.txt
+	uv sync --all-extras
 
-test:
-	$(IN_VENV) pytest $(TESTS)
+_test: 
+	uv run pytest $(TESTS)
 
-dist: clean
-	$(IN_VENV) python -m build
-	ls -l dist
+test: setup-venv _test
+
+_dist:
+	uv build --out-dir $(DIST)
+	ls -l $(DIST)
+
+dist: setup-venv clean _dist
+
+_setup-mypy-venv: setup-venv
+	uv pip install -r ../../lib/galaxy/dependencies/pinned-typecheck-requirements.txt
+
+_mypy:
+	uv run mypy .
+
+mypy: _setup-mypy-venv _mypy
 
 _twine-exists: ; @which twine > /dev/null
 
+_setup-lint-venv: setup-venv
+	uv pip install -r ../../lib/galaxy/dependencies/pinned-lint-requirements.txt
+
+_lint:
+	uv run ruff check .
+
+lint: _setup-lint-venv _lint
+
 lint-dist: _twine-exists dist
 	$(IN_VENV) twine check dist/*
 
+# black doesn't actually work on symlinked files because they are outside
+# the current directory
+
+#_setup-format-venv: setup-venv
+#	uv pip install isort black
+#_isort:
+#	uv run isort --sp ../../.isort.cfg . 
+#_black:
+#	uv run black --config ../pyproject.toml .
+#format: _setup-format-venv _isort _black
+
 _release-test-artifacts:
 	$(IN_VENV) twine upload -r test dist/*
 	$(OPEN_RESOURCE) https://testpypi.python.org/pypi/$(PROJECT_NAME)
@@ -88,6 +119,3 @@ push-release:
 	echo "Makefile doesn't manually push release."
 
 release: release-local push-release
-
-mypy:
-	mypy .
diff --git a/packages/pyproject.toml b/packages/pyproject.toml
new file mode 100644
index 000000000000..a5957cb9f3f7
--- /dev/null
+++ b/packages/pyproject.toml
@@ -0,0 +1,68 @@
+[project]
+name = "galaxy-meta-package"
+version = "0.0.0"
+description = "Meta package stub (not a real package)"
+requires-python = ">=3.9"
+dependencies = []
+
+[tool.uv]
+package = false
+
+[tool.uv.sources]
+galaxy-auth = { workspace = true }
+galaxy-config = { workspace = true }
+galaxy-data = { workspace = true }
+galaxy-files = { workspace = true }
+galaxy-job-execution = { workspace = true }
+galaxy-job-metrics = { workspace = true }
+galaxy-navigation = { workspace = true }
+galaxy-objectstore = { workspace = true }
+galaxy-schema = { workspace = true }
+galaxy-selenium = { workspace = true }
+galaxy-test-api = { workspace = true }
+galaxy-test-base = { workspace = true }
+galaxy-test-driver = { workspace = true }
+galaxy-test-selenium = { workspace = true }
+galaxy-tool-shed = { workspace = true }
+galaxy-tool-shed-schema = { workspace = true }
+galaxy-tours = { workspace = true }
+galaxy-web-apps = { workspace = true }
+galaxy-web-client = { workspace = true }
+galaxy-web-framework = { workspace = true }
+galaxy-web-stack = { workspace = true }
+galaxy-util = { workspace = true }
+galaxy-tool-util-models = { workspace = true }
+galaxy-tool-util = { workspace = true }
+galaxy-app = { workspace = true }
+galaxy = { workspace = true }
+
+[tool.uv.workspace]
+members = [
+  "tool_util_models",
+  "util",
+  "config",
+  "files",
+  "job_metrics",
+  "navigation",
+  "objectstore",
+  "schema",
+  "tool_shed_schema",
+  "tool_util",
+  "data",
+  "selenium",
+  "tours",
+  "test_base",
+  "test_driver",
+  "test_api",
+  "test_selenium",
+  "auth",
+  "job_execution",
+  "test_api",
+  "web_framework",
+  "web_stack",
+  "app",
+  "web_apps",
+  "tool_shed",
+  "web_client",
+  "meta",
+]
diff --git a/packages/schema/pyproject.toml b/packages/schema/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/schema/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/schema/pyproject.toml b/packages/schema/pyproject.toml
new file mode 100644
index 000000000000..e5d29a25ee48
--- /dev/null
+++ b/packages/schema/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-schema"
diff --git a/packages/schema/setup.cfg b/packages/schema/setup.cfg
index 4193f83819ed..63fabd0ab9ef 100644
--- a/packages/schema/setup.cfg
+++ b/packages/schema/setup.cfg
@@ -37,6 +37,10 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/schema/test-requirements.txt b/packages/schema/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/schema/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/selenium/.claude/commands/add-browser-operation.md b/packages/selenium/.claude/commands/add-browser-operation.md
new file mode 100644
index 000000000000..1eb44d2dfa30
--- /dev/null
+++ b/packages/selenium/.claude/commands/add-browser-operation.md
@@ -0,0 +1,130 @@
+---
+description: Add a new low-level browser operation to both Selenium and Playwright implementations with tests
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+**Operation Description**: The user input describes the browser operation to add (e.g., "add method to scroll element to center of viewport" or "add method to get element's bounding box").
+
+## Implementation Steps
+
+1. **Parse the operation description** from user input:
+   - Extract the operation name (convert to snake_case method name)
+   - Identify parameters needed
+   - Determine return type
+   - Understand the browser behavior to implement
+
+2. **Add to HasDriverProtocol** (`lib/galaxy/selenium/has_driver_protocol.py`):
+   - Add abstract method with proper signature
+   - Include comprehensive docstring with:
+     * Description of what the operation does
+     * Args documentation
+     * Returns documentation
+     * Usage example if helpful
+   - Add `ContextManager` import if method returns a context manager
+
+3. **Implement in HasDriver** (`lib/galaxy/selenium/has_driver.py`):
+   - Implement using Selenium WebDriver API
+   - Use `self.driver` for page-level operations
+   - Use element methods for element-specific operations
+   - Handle any Selenium-specific quirks or edge cases
+   - Add appropriate error handling
+
+4. **Implement in HasPlaywrightDriver** (`lib/galaxy/selenium/has_playwright_driver.py`):
+   - Implement using Playwright API
+   - Use `self.page` for page-level operations
+   - For element operations, follow the wrapper pattern:
+     * Create public method accepting `WebElementProtocol`
+     * Use `self._unwrap_element()` to get `ElementHandle`
+     * Create private `_method_name()` with `ElementHandle` parameter
+   - Use `self._frame_or_page` instead of `self.page` if operation should work within frames
+   - Handle any Playwright-specific patterns
+
+5. **Update HasDriverProxy** (`lib/galaxy/selenium/has_driver_proxy.py`):
+   - Add delegation method that forwards to `self._driver_impl`
+   - Include docstring (can be brief, main docs are in protocol)
+   - Ensure type hints match the protocol
+
+6. **Add comprehensive unit tests** (`test/unit/selenium/test_has_driver.py`):
+   - Create new test class or add to existing relevant class
+   - Test the operation with `has_driver_instance` fixture (parametrized for both backends)
+   - Include tests for:
+     * Basic functionality
+     * Edge cases
+     * Error conditions if applicable
+     * Different element states if relevant
+   - Use `base_url` fixture to load test pages
+   - Assert expected behavior for both Selenium and Playwright
+
+7. **Verify implementation**:
+   - Run tests: `uv run pytest tests/seleniumtests/test_has_driver.py::<TestClass>::<test_name> -v`
+   - Run type checking: `make mypy`
+   - Ensure all 3 backend variants pass (selenium, playwright, proxy-selenium)
+
+8. **Update WebElementProtocol if needed**:
+   - If the operation is element-specific and should be callable on elements directly
+   - Add to `lib/galaxy/selenium/web_element_protocol.py`
+   - Implement in `lib/galaxy/selenium/playwright_element.py` for Playwright
+   - Selenium's WebElement will implement it natively if it's a standard method
+
+## Example Workflow
+
+For operation "get element's computed background color":
+
+1. **Protocol** (`has_driver_protocol.py`):
+```python
+@abstractmethod
+def get_element_background_color(self, element: WebElementProtocol) -> str:
+    """Get the computed background color of an element.
+
+    Args:
+        element: The element to get background color from
+
+    Returns:
+        The computed background-color CSS value (e.g., "rgb(255, 0, 0)")
+    """
+    ...
+```
+
+2. **Selenium** (`has_driver.py`):
+```python
+def get_element_background_color(self, element: WebElementProtocol) -> str:
+    return element.value_of_css_property("background-color")
+```
+
+3. **Playwright** (`has_playwright_driver.py`):
+```python
+def get_element_background_color(self, element: WebElementProtocol) -> str:
+    return element.value_of_css_property("background-color")
+```
+
+4. **Proxy** (`has_driver_proxy.py`):
+```python
+def get_element_background_color(self, element: WebElementProtocol) -> str:
+    """Get the computed background color of an element."""
+    return self._driver_impl.get_element_background_color(element)
+```
+
+5. **Tests** (`test_has_driver.py`):
+```python
+class TestCSSProperties:
+    def test_get_element_background_color(self, has_driver_instance, base_url):
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("test-div")
+        color = has_driver_instance.get_element_background_color(element)
+        assert color != ""
+        # Color format varies by browser, just check it's a valid value
+        assert isinstance(color, str)
+```
+
+## Notes
+
+- Always maintain API compatibility between Selenium and Playwright implementations
+- Use the wrapper pattern (`_unwrap_element()`) for element operations in Playwright
+- Ensure both implementations have identical behavior from the user's perspective
+- Write thorough tests that verify behavior on both backends
+- Follow existing code patterns and naming conventions
diff --git a/packages/selenium/README.rst b/packages/selenium/README.rst
index adfd385762c6..3bc9e1d9d802 100644
--- a/packages/selenium/README.rst
+++ b/packages/selenium/README.rst
@@ -3,12 +3,484 @@
    :target: https://pypi.org/project/galaxy-selenium/
 
 
+Galaxy Browser Automation Framework
+====================================
+
+.. note::
+   The package is named ``galaxy-selenium`` for historical reasons, but a more accurate name
+   would be ``galaxy-browser-automation`` since it supports both Selenium and Playwright backends.
 
 Overview
 --------
 
-The Galaxy_ selenium framework.
+This package provides a browser automation framework for Galaxy_ with:
+
+* **Multi-backend support**: Selenium and Playwright backends with a unified API
+* **Protocol-based architecture**: Clean separation between Galaxy logic and browser interaction
+* **Comprehensive testing**: Full unit test coverage for both backends
+* **CLI tooling**: Utilities for building command-line automation scripts
+* **Type safety**: Full type hints with mypy validation
 
 * Code: https://github.com/galaxyproject/galaxy
 
 .. _Galaxy: http://galaxyproject.org/
+
+
+Architecture
+------------
+
+Core Interfaces
+~~~~~~~~~~~~~~~
+
+The framework is built around two main protocol interfaces:
+
+**HasDriverProtocol** (``has_driver_protocol.py``)
+    Defines ~60+ browser automation operations including:
+
+    - Element finding (by ID, selector, XPath, etc.)
+    - Wait methods (visible, clickable, absent, etc.)
+    - Interactions (click, hover, drag-and-drop, keyboard input)
+    - Navigation (URLs, frames, alerts)
+    - JavaScript execution
+    - Accessibility testing (axe-core integration)
+
+**WebElementProtocol** (``web_element_protocol.py``)
+    Defines the common element API:
+
+    - ``text``, ``click()``, ``send_keys()``, ``clear()``
+    - ``get_attribute()``, ``is_displayed()``, ``is_enabled()``
+    - ``find_element()``, ``find_elements()``
+    - ``value_of_css_property()`` for CSS introspection
+
+
+Architecture Diagram
+~~~~~~~~~~~~~~~~~~~~
+
+::
+
+    ┌─────────────────────────────────────────────────────┐
+    │         Galaxy Application Layer                     │
+    │                                                       │
+    │  NavigatesGalaxy (navigates_galaxy.py)              │
+    │  - Galaxy-specific page objects                      │
+    │  - Workflow interactions                             │
+    │  - History management                                │
+    │  - Tool execution                                    │
+    └────────────────┬────────────────────────────────────┘
+                     │ extends
+                     ↓
+    ┌─────────────────────────────────────────────────────┐
+    │      Browser Automation Abstraction Layer           │
+    │                                                       │
+    │  HasDriverProxy (has_driver_proxy.py)               │
+    │  - Delegates to HasDriverProtocol implementation     │
+    │  - Runtime backend selection via composition         │
+    └────────────────┬────────────────────────────────────┘
+                     │ uses
+                     ↓
+    ┌──────────────────────────────────┬──────────────────┐
+    │   HasDriverProtocol              │                  │
+    │   (has_driver_protocol.py)       │                  │
+    │   - Abstract interface           │                  │
+    │   - ~60+ operations              │                  │
+    └──────────────┬───────────────────┴──────────────────┘
+                   │ implemented by
+         ┌─────────┴──────────┐
+         ↓                    ↓
+    ┌─────────────┐    ┌──────────────────┐
+    │  HasDriver  │    │ HasPlaywright    │
+    │             │    │ Driver           │
+    │ Selenium    │    │                  │
+    │ backend     │    │ Playwright       │
+    │             │    │ backend          │
+    └──────┬──────┘    └────────┬─────────┘
+           │                    │
+           ↓                    ↓
+    ┌─────────────┐    ┌──────────────────┐
+    │ WebElement  │    │ PlaywrightElement│
+    │ (Selenium)  │    │ (wrapper)        │
+    │             │    │                  │
+    │ implements  │    │ implements       │
+    │ protocol    │    │ protocol         │
+    └─────────────┘    └──────────────────┘
+           │                    │
+           └──────────┬─────────┘
+                      ↓
+           WebElementProtocol
+           (web_element_protocol.py)
+
+
+Implementations
+~~~~~~~~~~~~~~~
+
+**Selenium Backend** (``has_driver.py``)
+    - Uses Selenium WebDriver
+    - Direct WebElement support (implements protocol natively)
+    - Mature, widely-used automation framework
+    - Supports remote execution (Selenium Grid)
+
+**Playwright Backend** (``has_playwright_driver.py``)
+    - Uses Playwright sync API
+    - PlaywrightElement wrapper (adapts ElementHandle to protocol)
+    - Modern automation with auto-waiting
+    - Fast and reliable for modern web apps
+    - Local execution only (no remote support)
+
+Both implementations:
+
+- Share identical test suite (150+ parametrized tests)
+- Provide consistent API via protocols
+- Support headless and headed modes
+- Include full type hints
+
+
+Separation of Concerns
+~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+    Application Logic          │  Browser Automation
+    (Galaxy-specific)         │  (Generic, reusable)
+    ─────────────────────────────────────────────────
+    navigates_galaxy.py       │  has_driver_protocol.py
+    - Galaxy UI interactions  │  - Abstract interface
+    - Workflow automation     │  - Element finding
+    - History operations      │  - Wait strategies
+    - Tool wrappers           │  - Interactions
+                              │
+    smart_components.py       │  has_driver.py
+    - Galaxy component        │  - Selenium impl
+      wrappers                │
+    - Page object patterns    │  has_playwright_driver.py
+                              │  - Playwright impl
+                              │
+                              │  web_element_protocol.py
+                              │  - Element interface
+
+**Key Principle**: Galaxy-specific logic lives in ``navigates_galaxy.py`` and extends the
+generic browser automation protocols. This separation allows:
+
+- Testing browser automation independently
+- Reusing automation primitives across projects
+- Switching backends without changing application code
+- Clear boundaries between concerns
+
+
+Testing
+-------
+
+The framework includes comprehensive unit tests in ``test/unit/selenium/test_has_driver.py``:
+
+- **Parametrized tests**: Every test runs against Selenium, Playwright, and proxied backends
+- **150+ test cases** covering all protocol methods
+- **Test fixtures**: Reusable HTML pages served via local HTTP server
+- **Scope-optimized**: Session-scoped server, function-scoped drivers
+
+Run tests from the package directory::
+
+    # All tests
+    uv run pytest tests/seleniumtests/test_has_driver.py -v
+
+    # Specific test class
+    uv run pytest tests/seleniumtests/test_has_driver.py::TestElementFinding -v
+
+    # Type checking
+    make mypy
+
+.. warning::
+    Always run pytest from the package directory (``packages/selenium/``), not from the
+    monorepo root. Running from root can cause fixture scope issues.
+
+
+Building CLI Tools
+------------------
+
+The ``cli.py`` module provides infrastructure for building command-line automation tools.
+
+Core Components
+~~~~~~~~~~~~~~~
+
+**add_selenium_arguments(parser)**
+    Adds standard CLI arguments:
+
+    - ``--selenium-browser``: Browser choice (chrome, firefox, auto)
+    - ``--selenium-headless``: Headless mode flag
+    - ``--backend``: Backend selection (selenium, playwright)
+    - ``--galaxy_url``: Target Galaxy instance URL
+    - ``--selenium-remote``: Remote execution (Selenium only)
+
+**DriverWrapper**
+    Adapts argparse args to a NavigatesGalaxy instance:
+
+    - Handles backend selection
+    - Manages virtual display (for headless Selenium)
+    - Provides Galaxy navigation utilities
+    - Cleanup via ``finish()`` method
+
+Example: dump_tour.py
+~~~~~~~~~~~~~~~~~~~~~
+
+The ``scripts/dump_tour.py`` script demonstrates CLI tool development:
+
+.. code-block:: python
+
+    #!/usr/bin/env python
+    import argparse
+    from galaxy.selenium import cli
+
+    def main(argv=None):
+        args = _arg_parser().parse_args(argv)
+        driver_wrapper = cli.DriverWrapper(args)
+
+        # Use driver_wrapper for automation
+        callback = DumpTourCallback(driver_wrapper, args.output)
+        driver_wrapper.run_tour(args.tour, tour_callback=callback)
+
+    def _arg_parser():
+        parser = argparse.ArgumentParser(description="Walk a Galaxy tour")
+        parser.add_argument("tour", help="tour to walk")
+        parser.add_argument("-o", "--output", help="screenshot output dir")
+        parser = cli.add_selenium_arguments(parser)  # Add standard args
+        return parser
+
+    class DumpTourCallback:
+        def handle_step(self, step, step_index: int):
+            self.driver_wrapper.save_screenshot(f"{output}/{step_index}.png")
+
+Usage::
+
+    # With Selenium backend
+    python dump_tour.py my_tour.yaml --backend selenium --selenium-headless
+
+    # With Playwright backend
+    python dump_tour.py my_tour.yaml --backend playwright --galaxy_url http://localhost:8080
+
+
+Building Your Own CLI Tool
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+1. **Import the CLI utilities**::
+
+    from galaxy.selenium import cli
+
+2. **Create argument parser**::
+
+    parser = argparse.ArgumentParser(description="My automation tool")
+    parser.add_argument("--my-option", help="Custom option")
+    parser = cli.add_selenium_arguments(parser)  # Add standard args
+
+3. **Create DriverWrapper**::
+
+    args = parser.parse_args()
+    driver_wrapper = cli.DriverWrapper(args)
+
+4. **Use NavigatesGalaxy API**::
+
+    # driver_wrapper has all NavigatesGalaxy methods
+    driver_wrapper.navigate_to(url)
+    driver_wrapper.click_selector("#my-button")
+    driver_wrapper.wait_for_selector_visible(".result")
+
+5. **Clean up**::
+
+    driver_wrapper.finish()  # Quits driver and stops virtual display
+
+
+Development
+-----------
+
+Package Structure
+~~~~~~~~~~~~~~~~~
+
+::
+
+    packages/selenium/
+    ├── galaxy/selenium/          # Symlink to lib/galaxy/selenium/
+    ├── tests/seleniumtests/      # Symlink to test/unit/selenium/
+    ├── README.rst                # This file
+    └── pyproject.toml
+
+    lib/galaxy/selenium/          # Actual source code
+    ├── has_driver_protocol.py    # Protocol interface
+    ├── has_driver.py             # Selenium implementation
+    ├── has_playwright_driver.py  # Playwright implementation
+    ├── web_element_protocol.py   # Element interface
+    ├── playwright_element.py     # Element wrapper
+    ├── navigates_galaxy.py       # Galaxy-specific logic
+    ├── smart_components.py       # Component wrappers
+    ├── cli.py                    # CLI utilities
+    └── scripts/
+        └── dump_tour.py          # Example CLI tool
+
+    test/unit/selenium/           # Actual tests
+    ├── conftest.py               # Pytest fixtures
+    ├── test_has_driver.py        # Main test suite
+    └── fixtures/                 # HTML test pages
+
+
+Running Commands
+~~~~~~~~~~~~~~~~
+
+Always use ``uv run`` from the package directory::
+
+    # Run tests
+    uv run pytest tests/seleniumtests/test_has_driver.py -v
+
+    # Type checking
+    make mypy
+
+    # Linting
+    uv run ruff check .
+
+
+Adding New Low-Level Browser Operations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Low-level operations are generic browser automation primitives that work with both backends.
+
+**Manual Process:**
+
+1. **Add to protocol** (``has_driver_protocol.py``)::
+
+    @abstractmethod
+    def my_new_operation(self, param: str) -> bool:
+        """Do something useful."""
+        ...
+
+2. **Implement in Selenium** (``has_driver.py``)::
+
+    def my_new_operation(self, param: str) -> bool:
+        # Selenium implementation
+        return self.driver.do_something(param)
+
+3. **Implement in Playwright** (``has_playwright_driver.py``)::
+
+    def my_new_operation(self, param: str) -> bool:
+        # Playwright implementation
+        return self.page.do_something(param)
+
+4. **Update proxy** (``has_driver_proxy.py``)::
+
+    def my_new_operation(self, param: str) -> bool:
+        """Do something useful."""
+        return self._driver_impl.my_new_operation(param)
+
+5. **Add tests** (``test_has_driver.py``)::
+
+    def test_my_new_operation(self, has_driver_instance, base_url):
+        """Test new operation works on both backends."""
+        has_driver_instance.navigate_to(f"{base_url}/test.html")
+        result = has_driver_instance.my_new_operation("test")
+        assert result is True
+
+**Automated Process:**
+
+Use the ``/add-browser-operation`` slash command to automate these steps::
+
+    /add-browser-operation scroll element to center of viewport
+
+This command will generate all the necessary code across all files and create tests.
+
+
+Adding New Smart Component Operations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Smart component operations are higher-level conveniences that may require adding low-level
+operations first. These operations make Galaxy components more ergonomic to use in tests.
+
+**When to Add Smart Operations:**
+
+- When you find yourself repeating a pattern of low-level operations
+- When Galaxy-specific UI patterns need convenient wrappers
+- When you want to express test intent more clearly
+
+**Process:**
+
+1. **Determine if low-level support exists**:
+
+   Check if the required browser operation exists in ``HasDriverProtocol``. If not,
+   add it first using the process above (or ``/add-browser-operation``).
+
+2. **Add to SmartTarget** (``smart_components.py``):
+
+   Add a method to the ``SmartTarget`` class::
+
+    def my_smart_operation(self, **kwds):
+        """High-level operation description."""
+        # Delegate to has_driver protocol methods
+        element = self._has_driver.wait_for_visible(self._target, **kwds)
+        return self._has_driver.my_low_level_operation(element)
+
+3. **Consider return value wrapping**:
+
+   If your operation returns a Component or Target, wrap it::
+
+    def get_child_component(self, name: str):
+        """Get a child component and wrap it smartly."""
+        child = self._target.get_child(name)
+        return self._wrap(child)  # Returns SmartTarget
+
+4. **Add tests** (``test/unit/selenium/test_smart_components.py``):
+
+   Test with both backends using the ``has_driver_instance`` fixture::
+
+    def test_my_smart_operation(self, has_driver_instance, base_url):
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+
+        # Use SmartComponent wrapping
+        component = SmartComponent(MyComponent(), has_driver_instance)
+        result = component.my_target.my_smart_operation()
+
+        assert result is not None
+
+**Example: Adding a "wait_for_and_hover" operation**
+
+This demonstrates when you need to add a low-level operation first:
+
+1. **Check low-level support**: ``hover()`` already exists in ``HasDriverProtocol`` ✓
+
+2. **Add to SmartTarget**::
+
+    def wait_for_and_hover(self, **kwds):
+        """Wait for element to be visible and hover over it."""
+        element = self._has_driver.wait_for_visible(self._target, **kwds)
+        self._has_driver.hover(element)
+        return element
+
+3. **Usage in tests**::
+
+    # Before: Multiple steps
+    element = driver.wait_for_visible(component.menu)
+    driver.hover(element)
+
+    # After: One expressive call
+    component.menu.wait_for_and_hover()
+
+**Example: Adding operation requiring new low-level support**
+
+When the operation needs a new browser primitive:
+
+1. **Add low-level operation** (see "Adding New Low-Level Browser Operations"):
+
+   Add ``scroll_to_center(element)`` to protocols and implementations
+
+2. **Add smart wrapper**::
+
+    def wait_for_and_scroll_to_center(self, **kwds):
+        """Wait for element and scroll it to viewport center."""
+        element = self._has_driver.wait_for_visible(self._target, **kwds)
+        self._has_driver.scroll_to_center(element)
+        return element
+
+3. **Test both levels**:
+
+   - Test low-level in ``test_has_driver.py``
+   - Test smart wrapper in ``test_smart_components.py``
+
+
+See Also
+--------
+
+* `Selenium Documentation <https://www.selenium.dev/documentation/>`_
+* `Playwright Documentation <https://playwright.dev/python/>`_
+* `Galaxy Testing Documentation <https://docs.galaxyproject.org/en/latest/dev/writing_tests.html>`_
diff --git a/packages/selenium/pyproject.toml b/packages/selenium/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/selenium/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/selenium/pyproject.toml b/packages/selenium/pyproject.toml
new file mode 100644
index 000000000000..a3874ac40c8c
--- /dev/null
+++ b/packages/selenium/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-selenium"
diff --git a/packages/selenium/setup.cfg b/packages/selenium/setup.cfg
index 79f06f8b9596..9a75986b55cd 100644
--- a/packages/selenium/setup.cfg
+++ b/packages/selenium/setup.cfg
@@ -38,9 +38,14 @@ install_requires =
     PyYAML
     requests
     selenium!=4.11.0,!=4.11.1,!=4.11.2
+    playwright
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.entry_points]
 console_scripts =
         gx-dump-tour = galaxy.selenium.scripts.dump_tour:main
diff --git a/packages/selenium/test-requirements.txt b/packages/selenium/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/selenium/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/selenium/tests/seleniumtests b/packages/selenium/tests/seleniumtests
new file mode 120000
index 000000000000..bd38fd9464ba
--- /dev/null
+++ b/packages/selenium/tests/seleniumtests
@@ -0,0 +1 @@
+../../../test/unit/selenium
\ No newline at end of file
diff --git a/packages/sync_pyprojects.py b/packages/sync_pyprojects.py
new file mode 100644
index 000000000000..01d7bbd77ba6
--- /dev/null
+++ b/packages/sync_pyprojects.py
@@ -0,0 +1,77 @@
+import configparser
+import tomllib
+from pathlib import Path
+from string import Template
+
+PACKAGES_DIR = Path(__file__).parent
+WORKSPACE_ROOT_PYPROJECT = PACKAGES_DIR / "pyproject.toml"
+
+PYPROJECT_TOML = Template(
+    """
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "${project_name}"
+"""
+)
+
+
+def get_workspace_members(pyproject_path: Path):
+    pyproject_file = Path(pyproject_path)
+    if not pyproject_file.exists():
+        raise FileNotFoundError(f"{pyproject_path} not found.")
+
+    data = tomllib.load(pyproject_file.open("rb"))
+    try:
+        members = data["tool"]["uv"]["workspace"]["members"]
+        if not isinstance(members, list):
+            raise ValueError("Expected 'members' to be a list.")
+        return members
+    except KeyError:
+        raise KeyError("Could not find [tool.uv.workspace] members in pyproject.toml.")
+
+
+def update_project(project_directory: Path):
+    if not project_directory.exists():
+        raise Exception(f"Skipping {project_directory}, not found.")
+    setup_cfg = project_directory / "setup.cfg"
+    if not setup_cfg.exists():
+        raise Exception(f"No setup.cfg found in {project_directory}")
+
+    config = configparser.ConfigParser()
+    config.read(setup_cfg)
+    try:
+        project_name = config["metadata"]["name"]
+        print(f"Project name in {setup_cfg}: {project_name}")
+    except KeyError:
+        print(f"No [metadata] section or 'name' field in {setup_cfg}")
+    pyproject_path = project_directory / "pyproject.toml"
+    with pyproject_path.open("w") as f:
+        f.write(PYPROJECT_TOML.substitute(project_name=project_name))
+
+    if "options.extras_require" in config:
+        extra_requires = config["options.extras_require"]
+        if "test" in extra_requires:
+            print("'" + extra_requires["test"] + "'")
+
+
+def main():
+    members = get_workspace_members(WORKSPACE_ROOT_PYPROJECT)
+    for member in members:
+        update_project(PACKAGES_DIR / Path(member))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/test.sh b/packages/test.sh
index 4b886efcfe06..7d3d59163024 100755
--- a/packages/test.sh
+++ b/packages/test.sh
@@ -65,15 +65,15 @@ while read -r package_dir || [ -n "$package_dir" ]; do  # https://stackoverflow.
 
     # Install extras (if needed)
     if [ "$package_dir" = "util" ]; then
-        pip install '.[image-util,template,jstree,config-template]'
+        pip install '.[image-util,template,jstree,config-template,test]'
     elif [ "$package_dir" = "tool_util" ]; then
-        pip install '.[cwl,mulled,edam,extended-assertions]'
+        pip install '.[cwl,mulled,edam,extended-assertions,test]'
+    elif grep -q 'test =' setup.cfg 2>/dev/null; then
+        pip install '.[test]'
     else
         pip install .
     fi
 
-    pip install -r test-requirements.txt
-
     if [ $FOR_PULSAR -eq 0 ]; then
         marker_args=(-m 'not external_dependency_management')
     else
@@ -82,7 +82,9 @@ while read -r package_dir || [ -n "$package_dir" ]; do  # https://stackoverflow.
     # Ignore exit code 5 (no tests ran)
     pytest "${marker_args[@]}" . || test $? -eq 5
     if [ $FOR_PULSAR -eq 0 ]; then
-        make mypy
+        # make mypy uses uv now and so this legacy code should just run mypy
+        # directly to use the venv we have already activated
+        mypy .
     fi
     cd ..
 done < $PACKAGE_LIST_FILE
diff --git a/packages/test_api/pyproject.toml b/packages/test_api/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/test_api/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/test_api/pyproject.toml b/packages/test_api/pyproject.toml
new file mode 100644
index 000000000000..66d35fb0b9e8
--- /dev/null
+++ b/packages/test_api/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-test-api"
diff --git a/packages/test_api/setup.cfg b/packages/test_api/setup.cfg
index a197c9130eb3..d38affc4c085 100644
--- a/packages/test_api/setup.cfg
+++ b/packages/test_api/setup.cfg
@@ -43,6 +43,8 @@ python_requires = >=3.9
 [options.extras_require]
 driver =
     galaxy-test-driver
+test = 
+    pytest
 
 [options.packages.find]
 exclude =
diff --git a/packages/test_api/test-requirements.txt b/packages/test_api/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/test_api/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/test_base/pyproject.toml b/packages/test_base/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/test_base/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/test_base/pyproject.toml b/packages/test_base/pyproject.toml
new file mode 100644
index 000000000000..06ed2e36cc11
--- /dev/null
+++ b/packages/test_base/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-test-base"
diff --git a/packages/test_base/setup.cfg b/packages/test_base/setup.cfg
index d7be805a22e4..69f289b246f9 100644
--- a/packages/test_base/setup.cfg
+++ b/packages/test_base/setup.cfg
@@ -38,11 +38,17 @@ install_requires =
     cwltest>=2.5.20240906231108
     gxformat2
     pytest
+    pytest-celery
     PyYAML
     requests
+    jsonschema
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/test_base/test-requirements.txt b/packages/test_base/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/test_base/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/test_driver/pyproject.toml b/packages/test_driver/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/test_driver/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/test_driver/pyproject.toml b/packages/test_driver/pyproject.toml
new file mode 100644
index 000000000000..6ed7701405d2
--- /dev/null
+++ b/packages/test_driver/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-test-driver"
diff --git a/packages/test_driver/setup.cfg b/packages/test_driver/setup.cfg
index 56f5a6cf2d2d..b3e367584322 100644
--- a/packages/test_driver/setup.cfg
+++ b/packages/test_driver/setup.cfg
@@ -43,6 +43,10 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/test_driver/test-requirements.txt b/packages/test_driver/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/test_driver/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/test_selenium/pyproject.toml b/packages/test_selenium/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/test_selenium/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/test_selenium/pyproject.toml b/packages/test_selenium/pyproject.toml
new file mode 100644
index 000000000000..108869ee5787
--- /dev/null
+++ b/packages/test_selenium/pyproject.toml
@@ -0,0 +1,7 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+dynamic = ["version", "dependencies", "description", "readme", "requires-python", "optional-dependencies", "license", "authors"]
+name = "galaxy-test-selenium"
diff --git a/packages/test_selenium/setup.cfg b/packages/test_selenium/setup.cfg
index 627621b97d65..44b15885a356 100644
--- a/packages/test_selenium/setup.cfg
+++ b/packages/test_selenium/setup.cfg
@@ -48,6 +48,8 @@ python_requires = >=3.9
 [options.extras_require]
 driver =
     galaxy-test-driver
+test = 
+    pytest
 
 [options.packages.find]
 exclude =
diff --git a/packages/test_selenium/test-requirements.txt b/packages/test_selenium/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/test_selenium/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/tool_shed/pyproject.toml b/packages/tool_shed/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/tool_shed/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/tool_shed/pyproject.toml b/packages/tool_shed/pyproject.toml
new file mode 100644
index 000000000000..4febd0807346
--- /dev/null
+++ b/packages/tool_shed/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-tool-shed"
diff --git a/packages/tool_shed/setup.cfg b/packages/tool_shed/setup.cfg
index 04a542b5df4a..2945567a8db0 100644
--- a/packages/tool_shed/setup.cfg
+++ b/packages/tool_shed/setup.cfg
@@ -59,6 +59,10 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/tool_shed/test-requirements.txt b/packages/tool_shed/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/tool_shed/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/tool_shed_schema/pyproject.toml b/packages/tool_shed_schema/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/tool_shed_schema/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/tool_shed_schema/pyproject.toml b/packages/tool_shed_schema/pyproject.toml
new file mode 100644
index 000000000000..fb3b897e13db
--- /dev/null
+++ b/packages/tool_shed_schema/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-tool-shed-schema"
diff --git a/packages/tool_shed_schema/setup.cfg b/packages/tool_shed_schema/setup.cfg
index bd3d6a198ad0..31e5696a5675 100644
--- a/packages/tool_shed_schema/setup.cfg
+++ b/packages/tool_shed_schema/setup.cfg
@@ -39,6 +39,10 @@ install_requires =
 packages = find:
 python_requires = >=3.8
 
+[options.extras_require]
+test = 
+    pytest
+
 [options.entry_points]
 console_scripts =
 
diff --git a/packages/tool_shed_schema/test-requirements.txt b/packages/tool_shed_schema/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/tool_shed_schema/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/tool_util/pyproject.toml b/packages/tool_util/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/tool_util/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/tool_util/pyproject.toml b/packages/tool_util/pyproject.toml
new file mode 100644
index 000000000000..ea042f2194f7
--- /dev/null
+++ b/packages/tool_util/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-tool-util"
diff --git a/packages/tool_util/setup.cfg b/packages/tool_util/setup.cfg
index 9f087d25d9f0..3c55b5deaf22 100644
--- a/packages/tool_util/setup.cfg
+++ b/packages/tool_util/setup.cfg
@@ -75,7 +75,10 @@ extended-assertions =
     pysam
     pillow
     tifffile
-
+test =
+    Beaker
+    pytest
+    pytest-mock
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/tool_util/test-requirements.txt b/packages/tool_util/test-requirements.txt
deleted file mode 100644
index ebab0322ccf2..000000000000
--- a/packages/tool_util/test-requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Beaker
-pytest
-pytest-mock
diff --git a/packages/tool_util_models/pyproject.toml b/packages/tool_util_models/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/tool_util_models/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/tool_util_models/pyproject.toml b/packages/tool_util_models/pyproject.toml
new file mode 100644
index 000000000000..8a7e114f1acd
--- /dev/null
+++ b/packages/tool_util_models/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-tool-util-models"
diff --git a/packages/tool_util_models/setup.cfg b/packages/tool_util_models/setup.cfg
index 21a77302c7d2..00d0c4b0ca3b 100644
--- a/packages/tool_util_models/setup.cfg
+++ b/packages/tool_util_models/setup.cfg
@@ -38,6 +38,10 @@ install_requires =
 packages = find:
 python_requires = >=3.8
 
+[options.extras_require]
+test =
+    pytest
+
 [options.entry_points]
 console_scripts =
 
diff --git a/packages/tool_util_models/test-requirements.txt b/packages/tool_util_models/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/tool_util_models/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/tours/pyproject.toml b/packages/tours/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/tours/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/tours/pyproject.toml b/packages/tours/pyproject.toml
new file mode 100644
index 000000000000..236a6f25812e
--- /dev/null
+++ b/packages/tours/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-tours"
diff --git a/packages/tours/test-requirements.txt b/packages/tours/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/tours/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/util/pyproject.toml b/packages/util/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/util/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/util/pyproject.toml b/packages/util/pyproject.toml
new file mode 100644
index 000000000000..36fc814ad6c0
--- /dev/null
+++ b/packages/util/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-util"
diff --git a/packages/util/setup.cfg b/packages/util/setup.cfg
index 3b3fac72e921..0c1c79c19167 100644
--- a/packages/util/setup.cfg
+++ b/packages/util/setup.cfg
@@ -59,6 +59,11 @@ template =
 config-template =
     Jinja2
     pydantic
+test = 
+    pytest
+    pytest-httpserver
+    responses
+    Werkzeug
 
 [options.packages.find]
 exclude =
diff --git a/packages/util/test-requirements.txt b/packages/util/test-requirements.txt
deleted file mode 100644
index 2b7d321b4f1a..000000000000
--- a/packages/util/test-requirements.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-pytest
-pytest-httpserver
-responses
-Werkzeug
diff --git a/packages/web_apps/pyproject.toml b/packages/web_apps/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/web_apps/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/web_apps/pyproject.toml b/packages/web_apps/pyproject.toml
new file mode 100644
index 000000000000..46d9d6aec59d
--- /dev/null
+++ b/packages/web_apps/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-web-apps"
diff --git a/packages/web_apps/setup.cfg b/packages/web_apps/setup.cfg
index 58aa19e8cbb5..29d0a800e3e0 100644
--- a/packages/web_apps/setup.cfg
+++ b/packages/web_apps/setup.cfg
@@ -68,6 +68,12 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test = 
+    httpx
+    pytest
+    pytest-asyncio
+
 [options.entry_points]
 console_scripts =
         galaxy-web = galaxy.webapps.galaxy.script:main
diff --git a/packages/web_apps/test-requirements.txt b/packages/web_apps/test-requirements.txt
deleted file mode 100644
index 4d0c5d6c9943..000000000000
--- a/packages/web_apps/test-requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-httpx
-pytest
-pytest-asyncio
diff --git a/packages/web_client/pyproject.toml b/packages/web_client/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/web_client/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/web_client/pyproject.toml b/packages/web_client/pyproject.toml
new file mode 100644
index 000000000000..de50be4f9ac6
--- /dev/null
+++ b/packages/web_client/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-web-client"
diff --git a/packages/web_client/test-requirements.txt b/packages/web_client/test-requirements.txt
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/packages/web_framework/pyproject.toml b/packages/web_framework/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/web_framework/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/web_framework/pyproject.toml b/packages/web_framework/pyproject.toml
new file mode 100644
index 000000000000..41f0ef267f99
--- /dev/null
+++ b/packages/web_framework/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-web-framework"
diff --git a/packages/web_framework/setup.cfg b/packages/web_framework/setup.cfg
index a7d25a5602af..9fd1622b68ae 100644
--- a/packages/web_framework/setup.cfg
+++ b/packages/web_framework/setup.cfg
@@ -46,6 +46,10 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test =
+    pytest
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/web_framework/test-requirements.txt b/packages/web_framework/test-requirements.txt
deleted file mode 100644
index e079f8a6038d..000000000000
--- a/packages/web_framework/test-requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/packages/web_stack/pyproject.toml b/packages/web_stack/pyproject.toml
deleted file mode 120000
index 01a3b08b8872..000000000000
--- a/packages/web_stack/pyproject.toml
+++ /dev/null
@@ -1 +0,0 @@
-../package-pyproject.toml
\ No newline at end of file
diff --git a/packages/web_stack/pyproject.toml b/packages/web_stack/pyproject.toml
new file mode 100644
index 000000000000..391fce957686
--- /dev/null
+++ b/packages/web_stack/pyproject.toml
@@ -0,0 +1,17 @@
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools"]
+
+[project]
+dynamic = [
+    "authors",
+    "dependencies",
+    "description",
+    "license",
+    "optional-dependencies",
+    "readme",
+    "requires-python",
+    "version"
+]
+name = "galaxy-web-stack"
diff --git a/packages/web_stack/setup.cfg b/packages/web_stack/setup.cfg
index 8acaeced7ec4..319b914ce9c7 100644
--- a/packages/web_stack/setup.cfg
+++ b/packages/web_stack/setup.cfg
@@ -38,6 +38,11 @@ install_requires =
 packages = find:
 python_requires = >=3.9
 
+[options.extras_require]
+test =
+    pytest
+    gunicorn
+
 [options.packages.find]
 exclude =
     tests*
diff --git a/packages/web_stack/test-requirements.txt b/packages/web_stack/test-requirements.txt
deleted file mode 100644
index 527b6063f0fa..000000000000
--- a/packages/web_stack/test-requirements.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-gunicorn
-pytest
diff --git a/run_tests.sh b/run_tests.sh
index ea6c3f864b43..6bc7443be364 100755
--- a/run_tests.sh
+++ b/run_tests.sh
@@ -21,6 +21,8 @@ cat <<EOF
 '${0##*/} -unit (test_selector)'    for running unit tests on specified test path (using pytest selector syntax)
 '${0##*/} -selenium'                for running all selenium web tests (in lib/galaxy_test/selenium)
 '${0##*/} -selenium (test_selector)' for running specified selenium web tests (using pytest selector syntax)
+'${0##*/} -playwright'                 for running all end2end web tests (in lib/galaxy_test/selenium) using Playwright
+'${0##*/} -playwright (test_selector)' for running specified end2end web tests (using pytest selector syntax) using Playwright
 
 This wrapper script largely serves as a point documentation and convenience for
 running Galaxy's Python tests. All Python tests shipped with Galaxy can be run with
@@ -77,13 +79,38 @@ Run all selenium tests (Under Linux using Docker):
 Run a specific selenium test (under Linux or Mac OS X after installing geckodriver or chromedriver):
     ./run_tests.sh -selenium lib/galaxy_test/selenium/test_registration.py::TestRegistration::test_reregister_username_fails
 
-Run a selenium test against a running server while watching client (fastest iterating on client tests):
-    ./run.sh & # run Galaxy on 8080
-    make client-watch & # watch for client changes
-    export GALAXY_TEST_EXTERNAL=http://localhost:8080/  # Target tests at server.
+Run an end-to-end test using Selenium against a running server while watching client (fastest iterating on client tests):
+    GALAXY_SKIP_CLIENT_BUILD=1 GALAXY_RUN_WITH_TEST_TOOLS=1 ./run.sh & # run Galaxy on 8080 with test tools and skip client build
+    make client-dev-server & # watch for client changes and serve on 8081
+    export GALAXY_TEST_EXTERNAL=http://localhost:8081/  # Target tests at server.
     . .venv/bin/activate # source the virtualenv so can skip run_tests.sh.
     pytest lib/galaxy_test/selenium/test_workflow_editor.py::TestWorkflowEditor::test_data_input
 
+Some tests create new users but most tests can just use a single user - you can adjust
+these end-to-end tests to use a specific user by copying and updating the sample config:
+
+
+    cp lib/galaxy_test/selenium/jupyter/galaxy_selenium_context.yml.sample ./galaxy_selenium_context.yml
+    vi galaxy_selenium_context.yml  # edit user and password, target galaxy server, etc..
+
+If you've setup this config file, the file can be used with any end-to-end/selenium/playwright test by
+setting GALAXY_TEST_END_TO_END_CONFIG when calling pytest or run_test.sh. So for example
+the last line in that previous example run could become:
+
+    GALAXY_TEST_END_TO_END_CONFIG=./galaxy_selenium_context.yml pytest lib/galaxy_test/selenium/test_workflow_editor.py::TestWorkflowEditor::test_data_input
+
+Run an end-to-end test using Playwright against a running server while watching client (fastest iterating on client tests):
+    GALAXY_SKIP_CLIENT_BUILD=1 GALAXY_RUN_WITH_TEST_TOOLS=1 ./run.sh & # run Galaxy on 8080 with test tools and skip client build
+    make client-dev-server & # watch for client changes and serve on 8081
+    export GALAXY_TEST_EXTERNAL=http://localhost:8081/  # Target tests at server.
+    . .venv/bin/activate # source the virtualenv so can skip run_tests.sh.
+    GALAXY_TEST_DRIVER_BACKEND=playwright pytest lib/galaxy_test/selenium/test_workflow_editor.py::TestWorkflowEditor::test_data_input
+
+Playwright will probably require a browser installation:
+
+    . .venv/bin/activate
+    playwright install --with-deps
+
 To run the tool tests for a specific framework test tool
 listed in test/functional/tools/sample_tool_conf.xml.
 
@@ -370,6 +397,20 @@ do
               shift 1
           fi
           ;;
+      -playwright|--playwright)
+          GALAXY_TEST_TOOL_CONF="lib/galaxy/config/sample/tool_conf.xml.sample,test/functional/tools/sample_tool_conf.xml"
+          GALAXY_TEST_DRIVER_BACKEND="playwright"
+          export GALAXY_TEST_DRIVER_BACKEND
+          report_file="./run_playwright_tests.html"
+          skip_client_build=""
+          if [ $# -gt 1 ]; then
+              selenium_script=$2
+              shift 2
+          else
+              selenium_script="./lib/galaxy_test/selenium"
+              shift 1
+          fi
+          ;;
       -t|-toolshed|--toolshed)
           report_file="run_toolshed_tests.html"
           if [ $# -gt 1 ]; then
diff --git a/test/integration_selenium/test_allowlist_sanitization.py b/test/integration_selenium/test_allowlist_sanitization.py
index 109862158cb0..d1e8f064ba4e 100644
--- a/test/integration_selenium/test_allowlist_sanitization.py
+++ b/test/integration_selenium/test_allowlist_sanitization.py
@@ -24,18 +24,19 @@ def run_html_output(self):
     def test_html_output_sanitized(self):
         self.login()
         hda_id = self.run_html_output()
-        self.get(f"datasets/{hda_id}/preview")
+        self.navigate_to(self.build_url(f"datasets/{hda_id}/preview"))
         self.wait_for_selector_visible("[data-description='sanitization warning']")
         self.assert_selector_absent("[data-description='allowlist link']")
         self.screenshot("sanitization warning")
         assert self.switch_to_frame()
         self.assert_selector_absent("[data-description='hello-world']")
+        self.switch_to_default_content()
 
     @selenium_test
     def test_html_output_sanitized_admin(self):
         self.admin_login()
         hda_id = self.run_html_output()
-        self.get(f"datasets/{hda_id}/preview")
+        self.navigate_to(self.build_url(f"datasets/{hda_id}/preview"))
         self.wait_for_selector_visible("[data-description='sanitization warning']")
         self.wait_for_selector_visible("[data-description='allowlist link']")
         self.screenshot("sanitization warning admin")
@@ -48,5 +49,6 @@ def test_html_output_sanitized_admin(self):
             self.assert_selector_absent("[data-description='allowlist link']")
             assert self.switch_to_frame()
             self.wait_for_selector("[data-description='hello-world']")
+            self.switch_to_default_content()
         finally:
             self._delete("/api/sanitize_allow?tool_id=html_output", admin=True)
diff --git a/test/unit/selenium/__init__.py b/test/unit/selenium/__init__.py
new file mode 100644
index 000000000000..4e571446fc19
--- /dev/null
+++ b/test/unit/selenium/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for galaxy.selenium package."""
diff --git a/test/unit/selenium/conftest.py b/test/unit/selenium/conftest.py
new file mode 100644
index 000000000000..f92684e3655f
--- /dev/null
+++ b/test/unit/selenium/conftest.py
@@ -0,0 +1,107 @@
+"""Pytest configuration and fixtures for selenium unit tests."""
+
+import pytest
+from playwright.sync_api import sync_playwright
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+
+from galaxy.selenium.availability import (
+    PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE,
+    SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE,
+)
+from galaxy.selenium.has_playwright_driver import PlaywrightResources
+from .test_server import TestHTTPServer
+from .util import (
+    check_playwright_cached,
+    check_selenium_cached,
+)
+
+
+@pytest.fixture(scope="session")
+def test_server():
+    """
+    Create and start a test HTTP server for the entire test session.
+
+    Yields:
+        TestHTTPServer: Running HTTP server instance
+    """
+    server = TestHTTPServer(port=0)  # Use random available port
+    server.start()
+    yield server
+    server.stop()
+
+
+@pytest.fixture(scope="function")
+def chrome_options():
+    """
+    Create Chrome options for headless testing.
+
+    Returns:
+        ChromeOptions: Configured Chrome options
+    """
+    options = ChromeOptions()
+    options.add_argument("--headless=new")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--window-size=1920,1080")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-popup-blocking")
+    return options
+
+
+@pytest.fixture(scope="function")
+def driver(chrome_options):
+    """
+    Create a WebDriver instance for each test.
+
+    Args:
+        chrome_options: Chrome options fixture
+
+    Yields:
+        WebDriver: Chrome WebDriver instance
+    """
+    if not check_selenium_cached():
+        pytest.skip(SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE)
+
+    _driver = webdriver.Chrome(options=chrome_options)
+    _driver.implicitly_wait(0)  # Disable implicit waits, use explicit waits in tests
+    yield _driver
+    _driver.quit()
+
+
+@pytest.fixture(scope="session")
+def base_url(test_server):
+    """
+    Get the base URL for the test server.
+
+    Args:
+        test_server: Test HTTP server fixture
+
+    Returns:
+        str: Base URL of the test server
+    """
+    return test_server.get_url()
+
+
+@pytest.fixture(scope="function")
+def playwright_resources():
+    """
+    Create Playwright resources (playwright, browser, page) for each test.
+
+    Yields:
+        PlaywrightResources: NamedTuple containing playwright, browser, and page instances
+    """
+    if not check_playwright_cached():
+        pytest.skip(PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE)
+
+    playwright = sync_playwright().start()
+    browser = playwright.chromium.launch(headless=True)
+    page = browser.new_page()
+
+    yield PlaywrightResources(playwright=playwright, browser=browser, page=page)
+
+    # Cleanup in reverse order
+    page.close()
+    browser.close()
+    playwright.stop()
diff --git a/test/unit/selenium/fixtures/__init__.py b/test/unit/selenium/fixtures/__init__.py
new file mode 100644
index 000000000000..3f00a5df2e58
--- /dev/null
+++ b/test/unit/selenium/fixtures/__init__.py
@@ -0,0 +1 @@
+"""HTML fixtures for selenium unit tests."""
diff --git a/test/unit/selenium/fixtures/accessibility.html b/test/unit/selenium/fixtures/accessibility.html
new file mode 100644
index 000000000000..d9e2d89462c9
--- /dev/null
+++ b/test/unit/selenium/fixtures/accessibility.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Accessibility Test Page</title>
+</head>
+<body>
+    <h1>Accessibility Test Page</h1>
+
+    <!-- Section with good accessibility -->
+    <section id="good-section" aria-label="Accessible form">
+        <h2>Accessible Form</h2>
+        <form>
+            <label for="good-input">Name:</label>
+            <input type="text" id="good-input" name="name" aria-required="true" />
+
+            <label for="good-email">Email:</label>
+            <input type="email" id="good-email" name="email" />
+
+            <button type="submit" aria-label="Submit form">Submit</button>
+        </form>
+
+        <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='100' height='100'%3E%3Crect width='100' height='100' fill='blue'/%3E%3C/svg%3E" alt="Blue square" />
+    </section>
+
+    <!-- Section with accessibility violations -->
+    <section id="bad-section" aria-label="Section with violations">
+        <h2>Form with Violations</h2>
+
+        <!-- Missing label for input -->
+        <input type="text" id="no-label-input" name="nolabel" />
+
+        <!-- Image without alt text -->
+        <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='100' height='100'%3E%3Crect width='100' height='100' fill='red'/%3E%3C/svg%3E" />
+
+        <!-- Button without accessible name -->
+        <button type="button"></button>
+
+        <!-- Low contrast text (white on white) -->
+        <div style="background-color: white; color: white;">Invisible text</div>
+    </section>
+
+    <!-- Section for testing context parameter -->
+    <section id="context-section" aria-label="Context test section">
+        <h2>Context Test Section</h2>
+        <label for="context-input">Context Input:</label>
+        <input type="text" id="context-input" name="context" />
+
+        <!-- This has a violation -->
+        <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='50' height='50'%3E%3Ccircle cx='25' cy='25' r='20' fill='green'/%3E%3C/svg%3E" />
+    </section>
+</body>
+</html>
diff --git a/test/unit/selenium/fixtures/basic.html b/test/unit/selenium/fixtures/basic.html
new file mode 100644
index 000000000000..dc1faa23bdc3
--- /dev/null
+++ b/test/unit/selenium/fixtures/basic.html
@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Basic Test Page</title>
+    <style>
+        .hidden {
+            display: none;
+        }
+        .visible {
+            display: block;
+        }
+        .delayed-visible {
+            display: none;
+        }
+        #disabled-button {
+            pointer-events: none;
+            opacity: 0.5;
+        }
+        #hover-target {
+            width: 200px;
+            height: 100px;
+            background-color: blue;
+            transition: background-color 0.1s;
+        }
+        #hover-target:hover {
+            background-color: red;
+        }
+        #hover-indicator {
+            display: none;
+        }
+        #hover-target:hover + #hover-indicator {
+            display: block;
+        }
+    </style>
+</head>
+<body>
+    <h1 id="header">Test Page</h1>
+
+    <!-- Elements for testing finding methods -->
+    <div id="test-div" class="test-class">Test Div</div>
+    <p class="test-paragraph">Test Paragraph</p>
+    <span data-testid="test-span">Test Span</span>
+
+    <!-- Link for testing -->
+    <a href="#" id="test-link">Test Link</a>
+
+    <!-- Elements for visibility testing -->
+    <div id="visible-element" class="visible">I am visible</div>
+    <div id="hidden-element" class="hidden">I am hidden</div>
+    <div id="delayed-element" class="delayed-visible">I will become visible</div>
+    <div id="enter-element" class="hidden">I clicked enter.</div>
+
+    <!-- Form elements -->
+    <form id="test-form" action="/submit" method="post">
+        <label for="username">Username:</label>
+        <input type="text" id="username" name="username" onkeydown="if(event.key === 'Enter'){ document.getElementById('enter-element').classList.remove('hidden'); }" />
+
+        <label for="password">Password:</label>
+        <input type="password" id="password" name="password" />
+
+        <label for="email">Email:</label>
+        <input type="email" name="email" id="email" />
+
+        <label for="fruit-select">Favorite Fruit:</label>
+        <select id="fruit-select" name="fruit">
+            <option value="">--Choose a fruit--</option>
+            <option value="apple">Apple</option>
+            <option value="banana">Banana</option>
+            <option value="cherry">Cherry</option>
+            <option value="durian">Durian</option>
+        </select>
+
+        <button type="button" id="clickable-button">Click Me</button>
+        <button type="button" id="disabled-button" disabled>Disabled Button</button>
+        <input type="submit" value="Submit" />
+    </form>
+
+    <!-- Elements for xpath testing -->
+    <div class="xpath-container">
+        <ul>
+            <li class="item">Item 1</li>
+            <li class="item">Item 2</li>
+            <li class="item">Item 3</li>
+        </ul>
+    </div>
+
+    <!-- Alert button -->
+    <button id="alert-button" onclick="alert('Test Alert')">Show Alert</button>
+
+    <!-- Hover testing elements -->
+    <div id="hover-target">Hover over me</div>
+    <div id="hover-indicator">Hover detected!</div>
+
+    <!-- Frame for iframe testing -->
+    <iframe name="frame" id="test-frame" src="frame.html" style="width: 300px; height: 200px;"></iframe>
+
+    <script>
+        // Make element visible after delay
+        setTimeout(() => {
+            document.getElementById('delayed-element').classList.remove('delayed-visible');
+            document.getElementById('delayed-element').classList.add('visible');
+        }, 1000);
+
+        // Button click handler
+        document.getElementById('clickable-button').addEventListener('click', function() {
+            this.textContent = 'Clicked!';
+            this.classList.add('was-clicked');
+        });
+
+        // Form submission handler
+        document.getElementById('test-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+            const result = document.createElement('div');
+            result.id = 'form-result';
+            result.textContent = 'Form submitted!';
+            document.body.appendChild(result);
+        });
+    </script>
+</body>
+</html>
diff --git a/test/unit/selenium/fixtures/frame.html b/test/unit/selenium/fixtures/frame.html
new file mode 100644
index 000000000000..59fdf65dca53
--- /dev/null
+++ b/test/unit/selenium/fixtures/frame.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Frame Content</title>
+</head>
+<body>
+    <h2 id="frame-header">Inside Frame</h2>
+    <p id="frame-content">This is content inside the frame.</p>
+</body>
+</html>
diff --git a/test/unit/selenium/fixtures/smart_components.html b/test/unit/selenium/fixtures/smart_components.html
new file mode 100644
index 000000000000..b78c282f3906
--- /dev/null
+++ b/test/unit/selenium/fixtures/smart_components.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Smart Components Test Page</title>
+    <style>
+        .hidden {
+            display: none;
+        }
+        .visible {
+            display: block;
+        }
+    </style>
+</head>
+<body>
+    <h1>Smart Components Test Page</h1>
+
+    <!-- Button for click testing -->
+    <button type="button" id="test-button">Click Me</button>
+    <div id="result"></div>
+
+    <!-- Input field for text input testing -->
+    <input type="text" id="test-input" placeholder="Enter text" />
+    <input type="text" id="disabled-input" disabled placeholder="Disabled" />
+
+    <!-- Multiple items for testing all() -->
+    <div class="items-container">
+        <div class="item">Item 1</div>
+        <div class="item">Item 2</div>
+        <div class="item">Item 3</div>
+    </div>
+
+    <!-- Hidden element -->
+    <div id="hidden-element" class="hidden">Hidden content</div>
+
+    <!-- Data attributes -->
+    <div id="data-element" data-test="example-value" data-other="other-value"></div>
+
+    <!-- Class testing -->
+    <div id="class-element" class="active enabled"></div>
+
+    <!-- Select element -->
+    <select id="test-select">
+        <option value="1">Option 1</option>
+        <option value="2">Option 2</option>
+        <option value="3">Option 3</option>
+    </select>
+
+    <!-- Accessible form for axe testing -->
+    <form id="accessible-form">
+        <label for="form-input">Name:</label>
+        <input type="text" id="form-input" name="name" />
+
+        <label for="form-email">Email:</label>
+        <input type="email" id="form-email" name="email" />
+
+        <button type="submit">Submit</button>
+    </form>
+
+    <script>
+        // Button click handler
+        let clickCount = 0;
+        document.getElementById('test-button').addEventListener('click', function() {
+            clickCount++;
+            if (clickCount === 1) {
+                document.getElementById('result').textContent = 'Button clicked!';
+            }
+        });
+
+        // Button double-click handler
+        document.getElementById('test-button').addEventListener('dblclick', function() {
+            document.getElementById('result').textContent = 'Button double-clicked!';
+        });
+
+        // Form submission handler
+        document.getElementById('accessible-form').addEventListener('submit', function(e) {
+            e.preventDefault();
+        });
+    </script>
+</body>
+</html>
diff --git a/test/unit/selenium/test_driver_factory.py b/test/unit/selenium/test_driver_factory.py
new file mode 100644
index 000000000000..eba6e6b51768
--- /dev/null
+++ b/test/unit/selenium/test_driver_factory.py
@@ -0,0 +1,222 @@
+"""Unit tests for driver_factory.py - ConfiguredDriver with both Selenium and Playwright backends."""
+
+from typing import get_args
+
+import pytest
+
+from galaxy.selenium.driver_factory import (
+    ConfiguredDriver,
+    get_playwright_browser_type,
+    PLAYWRIGHT_REMOTE_UNSUPPORTED_MESSAGE,
+    PlaywrightBrowserName,
+)
+from galaxy.selenium.has_driver_protocol import fixed_timeout_handler
+from .util import (
+    skip_unless_playwright_browser_cached,
+    skip_unless_selenium_browser_cached,
+)
+
+# Get the valid Playwright browser names from the Literal type
+VALID_PLAYWRIGHT_BROWSERS = get_args(PlaywrightBrowserName)
+
+
+def configured_driver(**kwds) -> ConfiguredDriver:
+    """Return a basic ConfiguredDriver for testing."""
+    return ConfiguredDriver(fixed_timeout_handler(5.0), **kwds)
+
+
+class TestGetPlaywrightBrowserType:
+    """Test browser name mapping for Playwright."""
+
+    def test_auto_maps_to_chromium(self):
+        result = get_playwright_browser_type("auto")
+        assert result == "chromium"
+        assert result in VALID_PLAYWRIGHT_BROWSERS
+
+    def test_chrome_maps_to_chromium(self):
+        result = get_playwright_browser_type("CHROME")
+        assert result == "chromium"
+        assert result in VALID_PLAYWRIGHT_BROWSERS
+
+    def test_firefox_maps_to_firefox(self):
+        result = get_playwright_browser_type("FIREFOX")
+        assert result == "firefox"
+        assert result in VALID_PLAYWRIGHT_BROWSERS
+
+    def test_edge_raises_not_implemented(self):
+        """EDGE should raise NotImplementedError with helpful message."""
+        with pytest.raises(NotImplementedError) as exc_info:
+            get_playwright_browser_type("EDGE")
+        error_msg = str(exc_info.value)
+        assert "does not have a direct Playwright mapping" in error_msg
+        assert "use 'CHROME' or 'auto' instead" in error_msg
+
+    def test_safari_raises_not_implemented(self):
+        """SAFARI should raise NotImplementedError with helpful message."""
+        with pytest.raises(NotImplementedError) as exc_info:
+            get_playwright_browser_type("SAFARI")
+        error_msg = str(exc_info.value)
+        assert "does not have a direct Playwright mapping" in error_msg
+        assert "webkit" in error_msg.lower()
+        assert "Selenium backend" in error_msg
+
+    def test_unknown_browser_raises_not_implemented(self):
+        """Unknown browser types should raise NotImplementedError."""
+        with pytest.raises(NotImplementedError) as exc_info:
+            get_playwright_browser_type("OPERA")
+        error_msg = str(exc_info.value)
+        assert "not supported with Playwright backend" in error_msg
+        assert "CHROME, FIREFOX, auto" in error_msg
+
+    def test_return_type_is_valid_playwright_browser(self):
+        """All successful return values should be valid PlaywrightBrowserName literals."""
+        test_browsers = ["auto", "CHROME", "FIREFOX"]
+        for browser in test_browsers:
+            result = get_playwright_browser_type(browser)
+            assert result in VALID_PLAYWRIGHT_BROWSERS, f"Browser '{browser}' mapped to invalid type '{result}'"
+
+
+@skip_unless_selenium_browser_cached()
+class TestConfiguredDriverSelenium:
+    """Test ConfiguredDriver with Selenium backend."""
+
+    def test_default_backend_is_selenium(self):
+        """Default backend_type should be 'selenium' for backward compatibility."""
+        driver = configured_driver(headless=True)
+        try:
+            assert driver.backend_type == "selenium"
+            assert driver.driver_impl.backend_type == "selenium"
+        finally:
+            driver.quit()
+
+    def test_explicit_selenium_backend(self):
+        """Explicitly requesting selenium backend should work."""
+        driver = configured_driver(backend_type="selenium", headless=True)
+        try:
+            assert driver.backend_type == "selenium"
+            assert driver.driver_impl.backend_type == "selenium"
+        finally:
+            driver.quit()
+
+    def test_driver_impl_has_protocol_methods(self):
+        """Driver impl should implement HasDriverProtocol methods."""
+        driver = configured_driver(headless=True)
+        try:
+            assert hasattr(driver.driver_impl, "navigate_to")
+            assert hasattr(driver.driver_impl, "find_element_by_id")
+            assert hasattr(driver.driver_impl, "wait_for_selector")
+            assert hasattr(driver.driver_impl, "click_xpath")
+        finally:
+            driver.quit()
+
+    # Make a test like this work based on checking for geckodriver or chromedriver in PATH.
+    # def test_serialization_preserves_backend(self):
+    #     """Serialization should preserve backend_type."""
+    #     driver = configured_driver(backend_type="selenium", headless=True, browser="FIREFOX")
+    #     try:
+    #         config = driver.to_dict()
+    #         assert config["backend_type"] == "selenium"
+    #         assert config["browser"] == "FIREFOX"
+    #         assert config["headless"] is True
+    #     finally:
+    #         driver.quit()
+
+    def test_deserialization_restores_backend(self):
+        """Deserialization should restore correct backend."""
+        config = {
+            "browser": "CHROME",
+            "remote": False,
+            "remote_host": "127.0.0.1",
+            "remote_port": "4444",
+            "headless": True,
+            "backend_type": "selenium",
+        }
+        driver = ConfiguredDriver.from_dict(fixed_timeout_handler(5.0), config)
+        try:
+            assert driver.backend_type == "selenium"
+        finally:
+            driver.quit()
+
+
+class TestConfiguredDriverPlaywright:
+    """Test ConfiguredDriver with Playwright backend."""
+
+    @skip_unless_playwright_browser_cached()
+    def test_playwright_backend_creation(self):
+        """Should be able to create Playwright backend."""
+        driver = configured_driver(backend_type="playwright", headless=True)
+        try:
+            assert driver.backend_type == "playwright"
+            assert driver.driver_impl.backend_type == "playwright"
+        finally:
+            driver.quit()
+
+    @skip_unless_playwright_browser_cached()
+    def test_playwright_firefox_browser(self):
+        """Should support Firefox browser with Playwright."""
+        driver = configured_driver(backend_type="playwright", browser="FIREFOX", headless=True)
+        try:
+            assert driver.backend_type == "playwright"
+            assert driver.config["browser"] == "FIREFOX"
+        finally:
+            driver.quit()
+
+    @skip_unless_playwright_browser_cached()
+    def test_playwright_driver_impl_has_protocol_methods(self):
+        """Playwright driver impl should implement HasDriverProtocol methods."""
+        driver = configured_driver(backend_type="playwright", headless=True)
+        try:
+            assert hasattr(driver.driver_impl, "navigate_to")
+            assert hasattr(driver.driver_impl, "find_element_by_id")
+            assert hasattr(driver.driver_impl, "wait_for_selector")
+            assert hasattr(driver.driver_impl, "click_xpath")
+        finally:
+            driver.quit()
+
+    @skip_unless_playwright_browser_cached()
+    def test_playwright_serialization(self):
+        """Playwright config should serialize correctly."""
+        driver = configured_driver(backend_type="playwright", headless=True, browser="FIREFOX")
+        try:
+            config = driver.to_dict()
+            assert config["backend_type"] == "playwright"
+            assert config["browser"] == "FIREFOX"
+        finally:
+            driver.quit()
+
+    def test_playwright_remote_raises_exception(self):
+        """Playwright should raise exception when remote=True.
+
+        Note: This test doesn't require a browser to be installed since it only
+        tests validation logic - the exception is raised before any browser is launched.
+        """
+        with pytest.raises(Exception) as exc_info:
+            configured_driver(backend_type="playwright", remote=True)
+        assert PLAYWRIGHT_REMOTE_UNSUPPORTED_MESSAGE in str(exc_info.value)
+
+    @skip_unless_playwright_browser_cached()
+    def test_playwright_has_page_attribute(self):
+        """Playwright driver impl should have page attribute."""
+        driver = configured_driver(backend_type="playwright", headless=True)
+        try:
+            assert hasattr(driver.driver_impl, "page")
+        finally:
+            driver.quit()
+
+
+class TestConfiguredDriverValidation:
+    """Test ConfiguredDriver validation and error handling."""
+
+    def test_invalid_backend_type_raises_error(self):
+        """Invalid backend_type should raise ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            configured_driver(backend_type="invalid")
+        assert "Invalid backend_type" in str(exc_info.value)
+
+    def test_playwright_remote_validation(self):
+        """Playwright + remote should fail with clear message."""
+        with pytest.raises(Exception) as exc_info:
+            configured_driver(backend_type="playwright", remote=True, headless=True)
+        error_msg = str(exc_info.value)
+        assert "does not support remote" in error_msg
+        assert "Selenium Grid" in error_msg
diff --git a/test/unit/selenium/test_has_driver.py b/test/unit/selenium/test_has_driver.py
new file mode 100644
index 000000000000..f157797bc38f
--- /dev/null
+++ b/test/unit/selenium/test_has_driver.py
@@ -0,0 +1,1246 @@
+"""Unit tests for galaxy.selenium.has_driver module."""
+
+from typing import cast
+
+import pytest
+from selenium.common.exceptions import (
+    NoSuchElementException,
+    TimeoutException as SeleniumTimeoutException,
+)
+from selenium.webdriver.common.by import By
+from selenium.webdriver.remote.webdriver import WebDriver
+
+from galaxy.navigation.components import Target
+from galaxy.selenium.availability import (
+    PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE,
+    SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE,
+)
+from galaxy.selenium.has_driver import (
+    exception_indicates_click_intercepted,
+    exception_indicates_not_clickable,
+    exception_indicates_stale_element,
+    HasDriver,
+)
+from galaxy.selenium.has_driver_protocol import (
+    fixed_timeout_handler,
+    HasDriverProtocol,
+    TimeoutCallback,
+)
+from galaxy.selenium.has_driver_proxy import HasDriverProxyImpl
+from galaxy.selenium.has_playwright_driver import (
+    HasPlaywrightDriver,
+    PlaywrightResources,
+    PlaywrightTimeoutException,
+)
+from .util import (
+    check_playwright_cached,
+    check_selenium_cached,
+)
+
+
+class SimpleTarget(Target):
+    """Simple concrete implementation of Target for testing."""
+
+    def __init__(self, element_locator: tuple, description: str):
+        """
+        Initialize target with locator and description.
+
+        Args:
+            element_locator: Tuple of (By, locator_string) for Selenium
+            description: Human-readable description
+        """
+        self._element_locator = element_locator
+        self._description = description
+
+    @property
+    def description(self) -> str:
+        """Return description."""
+        return self._description
+
+    @property
+    def element_locator(self):
+        """Return Selenium locator tuple."""
+        return self._element_locator
+
+    @property
+    def component_locator(self):
+        """Return component locator (not used in these tests)."""
+        raise NotImplementedError("component_locator not needed for these tests")
+
+
+class TestHasDriverImpl(HasDriver):
+    """
+    Concrete implementation of HasDriver for testing.
+
+    HasDriver is an abstract mixin that requires a driver and timeout implementation.
+    """
+
+    def __init__(self, driver: WebDriver, default_timeout: float = 10.0):
+        """
+        Initialize test implementation.
+
+        Args:
+            driver: Selenium WebDriver instance
+            default_timeout: Default timeout for waits
+        """
+        self.driver = driver
+        self.default_timeout = default_timeout
+
+    @property
+    def timeout_handler(self) -> TimeoutCallback:
+        """Return timeout value."""
+        return fixed_timeout_handler(self.default_timeout)
+
+
+class TestHasPlaywrightDriverImpl(HasPlaywrightDriver):
+    """
+    Concrete implementation of HasPlaywrightDriver for testing.
+
+    HasPlaywrightDriver is an abstract mixin that requires PlaywrightResources and timeout implementation.
+    """
+
+    def __init__(self, playwright_resources: PlaywrightResources, default_timeout: float = 10.0):
+        """
+        Initialize test implementation.
+
+        Args:
+            playwright_resources: PlaywrightResources containing playwright, browser, and page
+            default_timeout: Default timeout for waits
+        """
+        self._playwright_resources = playwright_resources
+        self.default_timeout = default_timeout
+        self._current_frame = None
+
+    @property
+    def timeout_handler(self) -> TimeoutCallback:
+        """Return timeout value."""
+        return fixed_timeout_handler(self.default_timeout)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(
+            "selenium",
+            marks=pytest.mark.skipif(
+                not check_selenium_cached(),
+                reason=SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE,
+            ),
+        ),
+        pytest.param(
+            "playwright",
+            marks=pytest.mark.skipif(
+                not check_playwright_cached(),
+                reason=PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE,
+            ),
+        ),
+        pytest.param(
+            "proxy-selenium",
+            marks=pytest.mark.skipif(
+                not check_selenium_cached(),
+                reason=SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE,
+            ),
+        ),
+    ]
+)
+def has_driver_instance(request, driver, playwright_resources) -> HasDriverProtocol:
+    """
+    Create a HasDriver, HasPlaywrightDriver, or proxied instance for testing.
+
+    This fixture is parametrized to test all three approaches:
+    - Direct Selenium (HasDriver) - skipped if Chrome not available
+    - Direct Playwright (HasPlaywrightDriver) - skipped if Chromium not available
+    - Proxied Selenium (HasDriverProxy wrapping HasDriver) - skipped if Chrome not available
+
+    Args:
+        request: Pytest request object
+        driver: Selenium WebDriver fixture
+        playwright_resources: PlaywrightResources fixture
+    """
+    if request.param == "selenium":
+        return cast(HasDriverProtocol, TestHasDriverImpl(driver))
+    elif request.param == "playwright":
+        return cast(HasDriverProtocol, TestHasPlaywrightDriverImpl(playwright_resources))
+    else:  # proxy-selenium
+        selenium_impl = cast(HasDriverProtocol, TestHasDriverImpl(driver))
+        return HasDriverProxyImpl(selenium_impl)
+
+
+class TestElementFinding:
+    """Tests for element finding methods."""
+
+    def test_assert_xpath(self, has_driver_instance, base_url: str) -> None:
+        """Test finding element by XPath assertion."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.assert_xpath("//h1[@id='header']")
+
+    def test_assert_xpath_fails_when_not_found(self, has_driver_instance, base_url: str) -> None:
+        """Test assert_xpath raises when element not found."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        with pytest.raises((NoSuchElementException, AssertionError)):
+            has_driver_instance.assert_xpath("//div[@id='nonexistent']")
+
+    def test_assert_selector(self, has_driver_instance, base_url: str) -> None:
+        """Test finding element by CSS selector assertion."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.assert_selector("#test-div")
+
+    def test_assert_selector_fails_when_not_found(self, has_driver_instance, base_url: str) -> None:
+        """Test assert_selector raises when element not found."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        with pytest.raises((NoSuchElementException, AssertionError)):
+            has_driver_instance.assert_selector("#nonexistent")
+
+    def test_find_element_by_id(self, has_driver_instance, base_url: str) -> None:
+        """Test finding element by ID."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("test-div")
+        assert element.text == "Test Div"
+
+    def test_find_element_by_xpath(self, has_driver_instance, base_url: str) -> None:
+        """Test finding element by XPath."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_xpath("//p[@class='test-paragraph']")
+        assert element.text == "Test Paragraph"
+
+    def test_find_element_by_selector(self, has_driver_instance, base_url: str) -> None:
+        """Test finding element by CSS selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_selector("[data-testid='test-span']")
+        assert element.text == "Test Span"
+
+    def test_find_element_by_link_text(self, has_driver_instance, base_url: str) -> None:
+        """Test finding element by link text."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_link_text("Test Link")
+        assert element.get_attribute("id") == "test-link"
+
+    def test_find_elements_with_target(self, has_driver_instance, base_url: str) -> None:
+        """Test finding multiple elements using Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.CLASS_NAME, "item"), description="list items")
+        elements = has_driver_instance.find_elements(target)
+        assert len(elements) == 3
+
+    def test_find_elements_by_selector(self, has_driver_instance, base_url: str) -> None:
+        """Test finding multiple elements by CSS selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        elements = has_driver_instance.find_elements_by_selector(".item")
+        assert len(elements) == 3
+        # Verify we got actual elements
+        assert all(hasattr(el, "text") for el in elements)
+
+    def test_find_elements_by_selector_no_matches(self, has_driver_instance, base_url: str) -> None:
+        """Test finding elements when selector matches nothing."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        elements = has_driver_instance.find_elements_by_selector(".nonexistent-class")
+        assert len(elements) == 0
+        assert elements == []
+
+    def test_find_elements_by_selector_single_match(self, has_driver_instance, base_url: str) -> None:
+        """Test finding elements when selector matches single element."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        elements = has_driver_instance.find_elements_by_selector("#test-div")
+        assert len(elements) == 1
+        assert elements[0].text == "Test Div"
+
+    def test_find_element_with_target(self, has_driver_instance, base_url: str) -> None:
+        """Test finding single element using Target (no waiting)."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "test-div"), description="test div")
+        element = has_driver_instance.find_element(target)
+        assert element.text == "Test Div"
+
+    def test_find_element_with_target_by_class(self, has_driver_instance, base_url: str) -> None:
+        """Test find_element returns first element when multiple matches exist."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.CLASS_NAME, "item"), description="first item")
+        element = has_driver_instance.find_element(target)
+        # Should get the first item
+        assert element.text in ["Item 1", "Item 2", "Item 3"]
+
+    def test_find_element_with_target_fails_when_not_found(self, has_driver_instance, base_url: str) -> None:
+        """Test find_element raises exception when element not found."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "nonexistent"), description="nonexistent element")
+        with pytest.raises((NoSuchElementException, Exception)):
+            has_driver_instance.find_element(target)
+
+
+class TestVisibilityAndPresence:
+    """Tests for visibility and presence checking methods."""
+
+    def test_selector_is_displayed_visible_element(self, has_driver_instance, base_url):
+        """Test checking if visible element is displayed."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        assert has_driver_instance.selector_is_displayed("#visible-element")
+
+    def test_selector_is_displayed_hidden_element(self, has_driver_instance, base_url):
+        """Test checking if hidden element is not displayed."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        assert not has_driver_instance.selector_is_displayed("#hidden-element")
+
+    def test_is_displayed_with_target(self, has_driver_instance, base_url):
+        """Test is_displayed with Target selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "visible-element"), description="visible element")
+        assert has_driver_instance.is_displayed(target)
+
+    def test_assert_selector_absent_or_hidden(self, has_driver_instance, base_url):
+        """Test asserting element is absent or hidden."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.assert_selector_absent_or_hidden("#hidden-element")
+
+    def test_assert_absent_or_hidden_with_target(self, has_driver_instance, base_url):
+        """Test assert_absent_or_hidden with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "hidden-element"), description="hidden element")
+        has_driver_instance.assert_absent_or_hidden(target)
+
+    def test_assert_selector_absent(self, has_driver_instance, base_url):
+        """Test asserting element is completely absent from DOM."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.assert_selector_absent("#nonexistent-element")
+
+    def test_assert_absent_with_target(self, has_driver_instance, base_url):
+        """Test assert_absent with Target when element doesn't exist."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "nonexistent"), description="nonexistent element")
+        has_driver_instance.assert_absent(target)
+
+    def test_element_absent_returns_true(self, has_driver_instance, base_url):
+        """Test element_absent returns True when element not in DOM."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "nonexistent"), description="nonexistent element")
+        assert has_driver_instance.element_absent(target)
+
+    def test_element_absent_returns_false(self, has_driver_instance, base_url):
+        """Test element_absent returns False when element exists."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "test-div"), description="test div")
+        assert not has_driver_instance.element_absent(target)
+
+    def test_assert_disabled(self, has_driver_instance, base_url):
+        """Test asserting element is disabled."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "disabled-button"), description="disabled button")
+        has_driver_instance.assert_disabled(target)
+
+
+class TestWaitMethods:
+    """Tests for wait methods."""
+
+    def test_wait_for_xpath(self, has_driver_instance, base_url):
+        """Test waiting for element by XPath."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.wait_for_xpath("//h1[@id='header']")
+        assert element.text == "Test Page"
+
+    def test_wait_for_xpath_visible(self, has_driver_instance, base_url):
+        """Test waiting for visible element by XPath."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.wait_for_xpath_visible("//div[@id='visible-element']")
+        assert element.is_displayed()
+
+    def test_wait_for_selector(self, has_driver_instance, base_url):
+        """Test waiting for element by CSS selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.wait_for_selector("#test-div")
+        assert element.text == "Test Div"
+
+    def test_wait_for_present_with_target(self, has_driver_instance, base_url):
+        """Test wait_for_present with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "test-div"), description="test div")
+        element = has_driver_instance.wait_for_present(target)
+        assert element is not None
+
+    def test_wait_for_visible_with_target(self, has_driver_instance, base_url):
+        """Test wait_for_visible with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "visible-element"), description="visible element")
+        element = has_driver_instance.wait_for_visible(target)
+        assert element.is_displayed()
+
+    def test_wait_for_selector_visible(self, has_driver_instance, base_url):
+        """Test waiting for visible element by CSS selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.wait_for_selector_visible("#visible-element")
+        assert element.is_displayed()
+
+    def test_wait_for_selector_clickable(self, has_driver_instance, base_url):
+        """Test waiting for clickable element by CSS selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.wait_for_selector_clickable("#clickable-button")
+        assert element.is_enabled()
+
+    def test_wait_for_clickable_with_target(self, has_driver_instance, base_url):
+        """Test wait_for_clickable with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "clickable-button"), description="clickable button")
+        element = has_driver_instance.wait_for_clickable(target)
+        assert element.is_enabled()
+
+    def test_wait_for_selector_absent(self, has_driver_instance, base_url):
+        """Test waiting for element to be absent."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        # Element doesn't exist, so wait should succeed immediately
+        has_driver_instance.wait_for_selector_absent("#nonexistent-element")
+
+    def test_wait_for_absent_with_target(self, has_driver_instance, base_url):
+        """Test wait_for_absent with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "nonexistent"), description="nonexistent element")
+        has_driver_instance.wait_for_absent(target)
+
+    def test_wait_for_selector_absent_or_hidden(self, has_driver_instance, base_url):
+        """Test waiting for element to be absent or hidden."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.wait_for_selector_absent_or_hidden("#hidden-element")
+
+    def test_wait_for_absent_or_hidden_with_target(self, has_driver_instance, base_url):
+        """Test wait_for_absent_or_hidden with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "hidden-element"), description="hidden element")
+        has_driver_instance.wait_for_absent_or_hidden(target)
+
+    def test_wait_for_id(self, has_driver_instance, base_url):
+        """Test waiting for element by ID."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.wait_for_id("test-div")
+        assert element.get_attribute("id") == "test-div"
+
+    def test_wait_for_element_count_of_at_least(self, has_driver_instance, base_url):
+        """Test waiting for at least N elements."""
+        # Skip for Playwright since _wait_on_condition_count is not implemented
+        if hasattr(has_driver_instance, "page"):
+            pytest.skip("wait_for_element_count_of_at_least not implemented for Playwright")
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.CLASS_NAME, "item"), description="list items")
+        has_driver_instance.wait_for_element_count_of_at_least(target, 3)
+        elements = has_driver_instance.find_elements(target)
+        assert len(elements) >= 3
+
+    def test_wait_timeout_with_custom_timeout(self, has_driver_instance, base_url):
+        """Test that custom timeout is used."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        # Expect either SeleniumTimeoutException or PlaywrightTimeoutException
+        with pytest.raises((SeleniumTimeoutException, PlaywrightTimeoutException)):
+            has_driver_instance.wait_for_selector("#nonexistent", timeout=1)
+
+    def test_wait_for_delayed_element_becomes_visible(self, has_driver_instance, base_url):
+        """Test waiting for element that becomes visible after delay."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        # Element becomes visible after 1 second
+        element = has_driver_instance.wait_for_selector_visible("#delayed-element", timeout=3)
+        assert element.is_displayed()
+
+
+class TestClickAndInteraction:
+    """Tests for click and interaction methods."""
+
+    def test_click_xpath(self, has_driver_instance, base_url):
+        """Test clicking element by XPath."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.click_xpath("//button[@id='clickable-button']")
+        button = has_driver_instance.find_element_by_id("clickable-button")
+        assert button.text == "Clicked!"
+
+    def test_click_selector(self, has_driver_instance, base_url):
+        """Test clicking element by CSS selector."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.click_selector("#clickable-button")
+        button = has_driver_instance.find_element_by_id("clickable-button")
+        assert button.text == "Clicked!"
+
+    def test_click_label(self, has_driver_instance, base_url):
+        """Test clicking link by text."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.click_label("Test Link")
+        # Link was clicked (href="#" so stays on same page)
+
+    def test_click_with_target(self, has_driver_instance, base_url):
+        """Test click method with Target."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        target = SimpleTarget(element_locator=(By.ID, "clickable-button"), description="clickable button")
+        has_driver_instance.click(target)
+        button = has_driver_instance.find_element_by_id("clickable-button")
+        assert button.text == "Clicked!"
+
+
+class TestFormInteraction:
+    """Tests for form interaction methods."""
+
+    def test_fill_form(self, has_driver_instance, base_url):
+        """Test filling form fields."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        form = has_driver_instance.find_element_by_id("test-form")
+
+        form_data = {"username": "testuser", "password": "testpass", "email": "test@example.com"}
+        has_driver_instance.fill(form, form_data)
+
+        # Verify fields were filled
+        username = has_driver_instance.find_element_by_id("username")
+        assert username.get_attribute("value") == "testuser"
+
+        password = has_driver_instance.find_element_by_id("password")
+        assert password.get_attribute("value") == "testpass"
+
+        email = has_driver_instance.find_element_by_id("email")
+        assert email.get_attribute("value") == "test@example.com"
+
+    def test_click_submit(self, has_driver_instance, base_url):
+        """Test clicking submit button on form."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        form = has_driver_instance.find_element_by_id("test-form")
+        has_driver_instance.click_submit(form)
+
+        # Verify form was submitted (result div appears)
+        result = has_driver_instance.wait_for_id("form-result", timeout=2)
+        assert result.text == "Form submitted!"
+
+
+class TestInputValueAbstraction:
+    """Tests for get_input_value abstraction."""
+
+    def test_get_input_value_basic(self, has_driver_instance, base_url):
+        """Test getting input value from a text input."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        username_input = has_driver_instance.find_element_by_id("username")
+
+        # Set a value
+        username_input.send_keys("testuser")
+
+        # Get the value using the abstraction
+        value = has_driver_instance.get_input_value(username_input)
+        assert value == "testuser"
+
+    def test_get_input_value_empty(self, has_driver_instance, base_url):
+        """Test getting input value from an empty input."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        username_input = has_driver_instance.find_element_by_id("username")
+
+        # Get value from empty input
+        value = has_driver_instance.get_input_value(username_input)
+        assert value == ""
+
+    def test_get_input_value_after_js_modification(self, has_driver_instance, base_url):
+        """Test getting input value after JavaScript modification."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        username_input = has_driver_instance.find_element_by_id("username")
+
+        # Set value using JavaScript
+        has_driver_instance.set_element_value(username_input, "jsvalue")
+
+        # Get the value - this is the problematic case for Playwright
+        value = has_driver_instance.get_input_value(username_input)
+        assert value == "jsvalue"
+
+    def test_get_input_value_password_field(self, has_driver_instance, base_url):
+        """Test getting value from password input."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        password_input = has_driver_instance.find_element_by_id("password")
+
+        # Set a value
+        password_input.send_keys("secret123")
+
+        # Get the value
+        value = has_driver_instance.get_input_value(password_input)
+        assert value == "secret123"
+
+    def test_get_input_value_email_field(self, has_driver_instance, base_url):
+        """Test getting value from email input."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        email_input = has_driver_instance.find_element_by_id("email")
+
+        # Set a value
+        email_input.send_keys("test@example.com")
+
+        # Get the value
+        value = has_driver_instance.get_input_value(email_input)
+        assert value == "test@example.com"
+
+
+class TestSelectByValue:
+    """Tests for select_by_value method."""
+
+    def test_select_by_value_basic(self, has_driver_instance, base_url):
+        """Test basic select by value functionality."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Select an option by value using Target
+        fruit_select = SimpleTarget(element_locator=(By.CSS_SELECTOR, "#fruit-select"), description="fruit select")
+        has_driver_instance.select_by_value(fruit_select, "banana")
+
+        # Verify the selection
+        select_element = has_driver_instance.find_element_by_id("fruit-select")
+        selected_value = select_element.get_attribute("value")
+        assert selected_value == "banana"
+
+    def test_select_by_value_multiple_options(self, has_driver_instance, base_url):
+        """Test selecting different options sequentially."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        select_element = has_driver_instance.find_element_by_id("fruit-select")
+        fruit_select = SimpleTarget(element_locator=(By.CSS_SELECTOR, "#fruit-select"), description="fruit select")
+
+        # Select first option
+        has_driver_instance.select_by_value(fruit_select, "apple")
+        assert select_element.get_attribute("value") == "apple"
+
+        # Select a different option
+        has_driver_instance.select_by_value(fruit_select, "cherry")
+        assert select_element.get_attribute("value") == "cherry"
+
+        # Select another option
+        has_driver_instance.select_by_value(fruit_select, "durian")
+        assert select_element.get_attribute("value") == "durian"
+
+    def test_select_by_value_with_tuple(self, has_driver_instance, base_url):
+        """Test select by value using a (locator_type, value) tuple."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Select using tuple (By.CSS_SELECTOR, selector)
+        has_driver_instance.select_by_value((By.CSS_SELECTOR, "#fruit-select"), "cherry")
+
+        # Verify the selection
+        select_element = has_driver_instance.find_element_by_id("fruit-select")
+        assert select_element.get_attribute("value") == "cherry"
+
+    def test_select_by_value_with_id_tuple(self, has_driver_instance, base_url):
+        """Test select by value using a (By.ID, value) tuple."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Select using tuple (By.ID, id)
+        has_driver_instance.select_by_value((By.ID, "fruit-select"), "durian")
+
+        # Verify the selection
+        select_element = has_driver_instance.find_element_by_id("fruit-select")
+        assert select_element.get_attribute("value") == "durian"
+
+
+class TestFindElementWithTuple:
+    """Tests for find_element with tuple-based locators."""
+
+    def test_find_element_with_css_selector_tuple(self, has_driver_instance, base_url):
+        """Test finding element with (By.CSS_SELECTOR, selector) tuple."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Find element using tuple
+        element = has_driver_instance.find_element((By.CSS_SELECTOR, "#test-div"))
+        assert element.text == "Test Div"
+
+    def test_find_element_with_id_tuple(self, has_driver_instance, base_url):
+        """Test finding element with (By.ID, id) tuple."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Find element using tuple
+        element = has_driver_instance.find_element((By.ID, "test-div"))
+        assert element.text == "Test Div"
+
+    def test_find_element_with_xpath_tuple(self, has_driver_instance, base_url):
+        """Test finding element with (By.XPATH, xpath) tuple."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Find element using tuple
+        element = has_driver_instance.find_element((By.XPATH, "//div[@id='test-div']"))
+        assert element.text == "Test Div"
+
+
+class TestActionChainsAndKeys:
+    """Tests for action chains and key sending methods."""
+
+    def test_action_chains(self, has_driver_instance, base_url):
+        """Test creating action chains."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        chains = has_driver_instance.action_chains()
+        assert chains is not None
+
+    def test_drag_and_drop(self, has_driver_instance, base_url):
+        """Test drag and drop functionality."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # TODO: Add actual draggable elements to basic.html for proper testing
+        # For example, add:
+        #   <div id="draggable" draggable="true" style="width:100px;height:100px;background:blue;">Drag me</div>
+        #   <div id="droptarget" style="width:200px;height:200px;background:gray;">Drop here</div>
+        # Then verify with JavaScript that droptarget contains draggable after drag_and_drop
+        # e.g., assert has_driver_instance.execute_script("return document.getElementById('droptarget').contains(document.getElementById('draggable'))")
+
+        # For now, just verify the method can be called without error
+        source = has_driver_instance.find_element_by_id("test-div")
+        target = has_driver_instance.find_element_by_id("visible-element")
+
+        # Call drag_and_drop - it should not raise an exception
+        # (even though these aren't actually draggable elements, the JS will execute)
+        has_driver_instance.drag_and_drop(source, target)
+
+    def test_move_to_and_click(self, has_driver_instance, base_url):
+        """Test moving to element and clicking via ActionChains."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        button = has_driver_instance.find_element_by_id("clickable-button")
+
+        # Use move_to_and_click
+        has_driver_instance.move_to_and_click(button)
+
+        # Verify button was clicked
+        assert button.text == "Clicked!"
+
+    def test_hover(self, has_driver_instance, base_url):
+        """Test hovering over an element."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        hover_target = has_driver_instance.find_element_by_id("hover-target")
+        hover_indicator = has_driver_instance.find_element_by_id("hover-indicator")
+
+        # Verify indicator is initially hidden
+        assert not hover_indicator.is_displayed()
+
+        # Hover over the target element
+        has_driver_instance.hover(hover_target)
+
+        # Verify the hover made the indicator visible (using CSS :hover + sibling selector)
+        assert hover_indicator.is_displayed()
+
+    def test_send_enter(self, has_driver_instance, base_url):
+        """Test sending ENTER key."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("enter-element")
+        assert not element.is_displayed()
+        element = has_driver_instance.find_element_by_id("username")
+        element.click()
+        has_driver_instance.send_enter(element)
+        element = has_driver_instance.find_element_by_id("enter-element")
+        assert element.is_displayed()
+
+    def test_send_escape(self, has_driver_instance, base_url):
+        """Test sending ESCAPE key."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("username")
+        element.click()
+        has_driver_instance.send_escape(element)
+        # Key was sent (no exception)
+
+    def test_send_backspace(self, has_driver_instance, base_url):
+        """Test sending BACKSPACE key."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("username")
+        element.send_keys("test")
+        has_driver_instance.send_backspace(element)
+        # Verify one character was deleted
+        value = has_driver_instance.get_input_value(element)
+        assert value == "tes"
+
+    def test_aggressive_clear(self, has_driver_instance, base_url):
+        """Test aggressive_clear() method for clearing input fields."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("username")
+
+        # Type some text
+        element.send_keys("test value that needs clearing")
+
+        # Use aggressive_clear
+        has_driver_instance.aggressive_clear(element)
+
+        # Verify the field is cleared
+        assert element.get_attribute("value") == ""
+
+
+class TestFrameSwitching:
+    """Tests for frame switching functionality."""
+
+    def test_switch_to_frame_by_name(self, has_driver_instance, base_url):
+        """Test switching to iframe by name."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.switch_to_frame("frame")
+
+        # Verify we're in the frame by finding frame-specific element
+        frame_header = has_driver_instance.find_element_by_id("frame-header")
+        assert frame_header.text == "Inside Frame"
+
+        # Switch back using new method
+        has_driver_instance.switch_to_default_content()
+
+    def test_switch_to_frame_by_id(self, has_driver_instance, base_url):
+        """Test switching to iframe by id (frame has name='frame' and id could be different)."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        # The frame has name="frame" - the method should work for both name and id
+        has_driver_instance.switch_to_frame("frame")
+
+        # Verify we're in the frame
+        frame_header = has_driver_instance.find_element_by_id("frame-header")
+        assert frame_header.text == "Inside Frame"
+
+        # Switch back
+        has_driver_instance.switch_to_default_content()
+
+    def test_switch_to_frame_by_element(self, has_driver_instance, base_url):
+        """Test switching to iframe by element reference."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Find the frame element first
+        frame_element = has_driver_instance.find_element_by_selector("[name='frame']")
+
+        # Switch to it by element
+        has_driver_instance.switch_to_frame(frame_element)
+
+        # Verify we're in the frame
+        frame_header = has_driver_instance.find_element_by_id("frame-header")
+        assert frame_header.text == "Inside Frame"
+
+        # Switch back
+        has_driver_instance.switch_to_default_content()
+
+    def test_switch_to_default_content(self, has_driver_instance, base_url):
+        """Test switching back to default content."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Switch to frame
+        has_driver_instance.switch_to_frame("frame")
+
+        # Verify we're in the frame
+        frame_header = has_driver_instance.find_element_by_id("frame-header")
+        assert frame_header.text == "Inside Frame"
+
+        # Switch back to default content
+        has_driver_instance.switch_to_default_content()
+
+        # Verify we're back in main content (frame-header shouldn't be accessible now)
+        header = has_driver_instance.find_element_by_id("header")
+        assert header.text == "Test Page"
+
+
+class TestAlertHandling:
+    """Tests for alert handling."""
+
+    def test_accept_alert(self, has_driver_instance, base_url):
+        """Test accepting browser alert using context manager."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Use context manager to handle alert
+        with has_driver_instance.accept_alert():
+            has_driver_instance.click_selector("#alert-button")
+        # Alert is automatically accepted here
+
+        # Verify we're back on the main page and can interact with it
+        header = has_driver_instance.find_element_by_id("header")
+        assert header.text == "Test Page"
+
+
+class TestCookieManagement:
+    """Tests for cookie management."""
+
+    def test_get_cookies(self, has_driver_instance, base_url):
+        """Test getting all cookies."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Get all cookies (test server sets test_cookie automatically)
+        cookies = has_driver_instance.get_cookies()
+
+        # Verify cookies is a list
+        assert isinstance(cookies, list)
+        assert len(cookies) > 0
+
+        # Verify our test cookie is in the list
+        cookie_names = [cookie["name"] for cookie in cookies]
+        assert "test_cookie" in cookie_names
+
+        # Find and verify the test cookie value
+        test_cookie = next(cookie for cookie in cookies if cookie["name"] == "test_cookie")
+        assert test_cookie["value"] == "test_value"
+
+
+class TestUtilityMethods:
+    """Tests for utility methods."""
+
+    def test_navigate_to(self, has_driver_instance: HasDriverProtocol, base_url: str, request) -> None:
+        """Test navigating to a URL and changing pages."""
+        # Navigate to first page
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        assert "basic.html" in has_driver_instance.current_url
+        # Verify first page loaded by checking for expected element
+        header = has_driver_instance.find_element_by_id("header")
+        assert header.text == "Test Page"
+
+        # Navigate to second page
+        has_driver_instance.navigate_to(f"{base_url}/frame.html")
+        assert "frame.html" in has_driver_instance.current_url
+        # Verify we actually navigated to a different page
+        frame_header = has_driver_instance.find_element_by_id("frame-header")
+        assert frame_header.text == "Inside Frame"
+
+        # Verify the original element is no longer present
+        target = SimpleTarget((By.ID, "header"), "header element")
+        elements = has_driver_instance.find_elements(target)
+        assert len(elements) == 0
+
+    def test_re_get_with_query_params_adds_question_mark(self, has_driver_instance, base_url):
+        """Test adding query params to URL without existing params."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.re_get_with_query_params("foo=bar")
+        assert "?foo=bar" in has_driver_instance.current_url
+
+    def test_re_get_with_query_params_appends_to_existing(self, has_driver_instance, base_url):
+        """Test adding query params to URL with existing params."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html?existing=param")
+        has_driver_instance.re_get_with_query_params("foo=bar")
+        current_url = has_driver_instance.current_url
+        assert "existing=param" in current_url
+        assert "foo=bar" in current_url
+
+    def test_prepend_timeout_message(self, has_driver_instance, request):
+        """Test prepending message to timeout exception."""
+        backend = request.node.callspec.params.get("has_driver_instance")
+        if backend == "selenium":
+            original_selenium_exc = SeleniumTimeoutException(msg="original message")
+            new_selenium_exception = has_driver_instance.prepend_timeout_message(original_selenium_exc, "New prefix:")
+            assert "New prefix:" in new_selenium_exception.msg
+            assert "original message" in new_selenium_exception.msg
+        else:  # playwright
+            original_playwright_exc = PlaywrightTimeoutException("original message")
+            new_playwright_exception = has_driver_instance.prepend_timeout_message(
+                original_playwright_exc, "New prefix:"
+            )
+            assert "New prefix:" in str(new_playwright_exception)
+            assert "original message" in str(new_playwright_exception)
+
+
+class TestJavaScriptExecution:
+    """Tests for JavaScript execution methods."""
+
+    def test_execute_script_returns_value(self, has_driver_instance, base_url):
+        """Test executing JavaScript and returning value."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        result = has_driver_instance.execute_script("return 42;")
+        assert result == 42
+
+    def test_execute_script_with_arguments(self, has_driver_instance, base_url):
+        """Test executing JavaScript with arguments."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        result = has_driver_instance.execute_script("return arguments[0] + arguments[1];", 10, 20)
+        assert result == 30
+
+    def test_execute_script_with_element(self, has_driver_instance, base_url):
+        """Test executing JavaScript with element argument."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("test-div")
+        result = has_driver_instance.execute_script("return arguments[0].textContent;", element)
+        assert result == "Test Div"
+
+    def test_set_local_storage(self, has_driver_instance, base_url):
+        """Test setting localStorage value."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        has_driver_instance.set_local_storage("testKey", '"testValue"')
+
+        # Verify localStorage was set
+        result = has_driver_instance.execute_script('return window.localStorage.getItem("testKey");')
+        assert result == "testValue"
+
+    def test_remove_local_storage(self, has_driver_instance, base_url):
+        """Test removing localStorage value."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        # First set a value
+        has_driver_instance.execute_script('window.localStorage.setItem("testKey", "testValue");')
+
+        # Now remove it
+        has_driver_instance.remove_local_storage("testKey")
+
+        # Verify it was removed
+        result = has_driver_instance.execute_script('return window.localStorage.getItem("testKey");')
+        assert result is None
+
+    def test_scroll_into_view(self, has_driver_instance, base_url):
+        """Test scrolling element into view."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("test-div")
+
+        # Scroll into view (should not raise exception)
+        has_driver_instance.scroll_into_view(element)
+
+        # Verify element is visible
+        assert element.is_displayed()
+
+    def test_set_element_value(self, has_driver_instance, base_url):
+        """Test setting element value directly."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        input_element = has_driver_instance.find_element_by_id("username")
+
+        # Set value using JavaScript
+        has_driver_instance.set_element_value(input_element, "newvalue")
+
+        # Verify value was set using the abstraction
+        value = has_driver_instance.get_input_value(input_element)
+        assert value == "newvalue"
+
+    def test_execute_script_click(self, has_driver_instance, base_url):
+        """Test clicking element via JavaScript."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        button = has_driver_instance.find_element_by_id("clickable-button")
+
+        # Click using JavaScript
+        has_driver_instance.execute_script_click(button)
+
+        # Verify button was clicked
+        assert button.text == "Clicked!"
+
+
+class TestExceptionHelpers:
+    """Tests for exception helper functions."""
+
+    def test_exception_indicates_click_intercepted(self):
+        """Test detecting click intercepted exceptions."""
+        exc = Exception("Element click intercepted")
+        assert exception_indicates_click_intercepted(exc)
+
+        exc = Exception("Something else")
+        assert not exception_indicates_click_intercepted(exc)
+
+    def test_exception_indicates_not_clickable(self):
+        """Test detecting not clickable exceptions."""
+        exc = Exception("Element is not clickable")
+        assert exception_indicates_not_clickable(exc)
+
+        exc = Exception("Something else")
+        assert not exception_indicates_not_clickable(exc)
+
+    def test_exception_indicates_stale_element(self):
+        """Test detecting stale element exceptions."""
+        exc = Exception("stale element reference")
+        assert exception_indicates_stale_element(exc)
+
+        exc = Exception("Something else")
+        assert not exception_indicates_stale_element(exc)
+
+
+class TestScreenshots:
+    """Tests for screenshot functionality."""
+
+    def test_save_screenshot(self, has_driver_instance, base_url, tmp_path):
+        """Test saving a screenshot to a file."""
+        import os
+
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Save screenshot to temp file
+        screenshot_path = str(tmp_path / "test_screenshot.png")
+        has_driver_instance.save_screenshot(screenshot_path)
+
+        # Verify file was created
+        assert os.path.exists(screenshot_path)
+
+        # Verify it's a PNG file (check magic bytes)
+        with open(screenshot_path, "rb") as f:
+            header = f.read(8)
+            # PNG magic bytes: 89 50 4E 47 0D 0A 1A 0A
+            assert header == b"\x89PNG\r\n\x1a\n"
+
+        # Verify file has content
+        assert os.path.getsize(screenshot_path) > 0
+
+    def test_get_screenshot_as_png(self, has_driver_instance, base_url):
+        """Test getting a screenshot as PNG bytes."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        # Get screenshot as bytes
+        screenshot_bytes = has_driver_instance.get_screenshot_as_png()
+
+        # Verify it's bytes
+        assert isinstance(screenshot_bytes, bytes)
+
+        # Verify it's non-empty
+        assert len(screenshot_bytes) > 0
+
+        # Verify it's a PNG file (check magic bytes)
+        # PNG magic bytes: 89 50 4E 47 0D 0A 1A 0A
+        assert screenshot_bytes[:8] == b"\x89PNG\r\n\x1a\n"
+
+
+class TestAccessibility:
+    """Tests for axe_eval accessibility testing."""
+
+    def test_axe_eval_basic(self, has_driver_instance, base_url):
+        """Test basic axe_eval functionality returns results."""
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+        results = has_driver_instance.axe_eval()
+
+        # Should have some violations in our test page
+        violations = results.violations()
+        assert len(violations) > 0
+
+    def test_axe_eval_with_context(self, has_driver_instance, base_url):
+        """Test axe_eval with context parameter to limit scope."""
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+
+        # Run axe on just the good section
+        results = has_driver_instance.axe_eval(context="#good-section")
+
+        # Good section should have fewer/no violations
+        violations = results.violations()
+        # We expect fewer violations when scoped to good section
+        assert isinstance(violations, list)
+
+    def test_axe_eval_assert_passes(self, has_driver_instance, base_url):
+        """Test axe_eval assert_passes for specific rules."""
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+        results = has_driver_instance.axe_eval()
+
+        # Test that we can check if a specific rule passed
+        # document-title should pass on our test page (we have a <title> element)
+        results.assert_passes("document-title")
+
+    def test_axe_eval_assert_does_not_violate(self, has_driver_instance, base_url):
+        """Test axe_eval assert_does_not_violate for specific rules."""
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+        results = has_driver_instance.axe_eval(context="#good-section")
+
+        # Good section should not violate certain rules
+        # This is a sanity check - if this fails, our test fixture needs adjustment
+        try:
+            results.assert_does_not_violate("aria-roles")
+        except AssertionError:
+            pytest.fail("Good section should not have aria-roles violations")
+
+    def test_axe_eval_violations_with_impact(self, has_driver_instance, base_url):
+        """Test filtering violations by impact level."""
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+        results = has_driver_instance.axe_eval()
+
+        # Get violations with at least moderate impact
+        moderate_violations = results.violations_with_impact_of_at_least("moderate")
+        all_violations = results.violations()
+
+        # moderate+ violations should be subset of all violations
+        assert len(moderate_violations) <= len(all_violations)
+        assert isinstance(moderate_violations, list)
+
+    def test_axe_eval_with_axe_skip(self, driver, base_url):
+        """Test that axe_eval returns NullAxeResults when axe_skip is True."""
+
+        # Create a test instance with axe_skip=True
+        class TestHasDriverSkipAxe(TestHasDriverImpl):
+            axe_skip = True
+
+        instance = TestHasDriverSkipAxe(driver)
+        instance.navigate_to(f"{base_url}/accessibility.html")
+        results = instance.axe_eval()
+
+        # Should return NullAxeResults which has no violations
+        violations = results.violations()
+        assert len(violations) == 0
+
+        # All assertions should pass silently with NullAxeResults
+        results.assert_passes("any-rule")
+        results.assert_does_not_violate("any-rule")
+        results.assert_no_violations_with_impact_of_at_least("critical")
+
+
+class TestPageSource:
+    """Test page_source property."""
+
+    def test_page_source_contains_content(self, has_driver_instance, base_url):
+        """Test that page_source contains actual page content."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        source = has_driver_instance.page_source
+
+        # Should contain the test div with known ID
+        assert 'id="test-div"' in source
+
+        # Should contain some visible text content
+        assert "Test Div" in source
+
+    def test_page_source_updates_after_navigation(self, has_driver_instance, base_url):
+        """Test that page_source updates when navigating to different pages."""
+        # Navigate to first page
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        source1 = has_driver_instance.page_source
+
+        # Navigate to different page
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+        source2 = has_driver_instance.page_source
+
+        # Sources should be different
+        assert source1 != source2
+
+        # Second source should contain content from accessibility page
+        assert "good-section" in source2 or "bad-section" in source2
+
+
+class TestPageTitle:
+    """Test page_title property."""
+
+    def test_page_title_basic(self, has_driver_instance, base_url):
+        """Test that page_title returns the page title."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+
+        title = has_driver_instance.page_title
+
+        # Should match the title from basic.html
+        assert title == "Basic Test Page"
+
+    def test_page_title_updates_after_navigation(self, has_driver_instance, base_url):
+        """Test that page_title updates when navigating to different pages."""
+        # Navigate to first page
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        title1 = has_driver_instance.page_title
+
+        # Navigate to different page
+        has_driver_instance.navigate_to(f"{base_url}/accessibility.html")
+        title2 = has_driver_instance.page_title
+
+        # Titles should be different
+        assert title1 != title2
+
+        # Verify titles match expected values
+        assert title1 == "Basic Test Page"
+        assert title2 == "Accessibility Test Page"
+
+
+class TestCSSProperties:
+    """Test CSS property retrieval via value_of_css_property."""
+
+    def test_value_of_css_property_display(self, has_driver_instance, base_url):
+        """Test getting the display CSS property of a visible element."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("visible-element")
+
+        # Get the display property
+        display_value = element.value_of_css_property("display")
+
+        # Should be a valid display value (not "none" for visible element)
+        assert display_value != ""
+        assert display_value != "none"
+
+    def test_value_of_css_property_color(self, has_driver_instance, base_url):
+        """Test getting the color CSS property."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("test-div")
+
+        # Get the color property
+        color_value = element.value_of_css_property("color")
+
+        # Should return some color value (format may vary between browsers)
+        assert color_value != ""
+        # Color could be in various formats: rgb(), rgba(), hex, or named color
+        assert isinstance(color_value, str)
+
+    def test_value_of_css_property_hidden_element(self, has_driver_instance, base_url):
+        """Test getting CSS property of a hidden element."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("hidden-element")
+
+        # Get the display property of hidden element
+        display_value = element.value_of_css_property("display")
+
+        # Hidden element should have display: none
+        assert display_value == "none"
+
+    def test_value_of_css_property_font_size(self, has_driver_instance, base_url):
+        """Test getting the font-size CSS property."""
+        has_driver_instance.navigate_to(f"{base_url}/basic.html")
+        element = has_driver_instance.find_element_by_id("header")
+
+        # Get the font-size property
+        font_size = element.value_of_css_property("font-size")
+
+        # Should return a font size (typically in px)
+        assert font_size != ""
+        # Font size should contain numeric value
+        assert any(char.isdigit() for char in font_size)
diff --git a/test/unit/selenium/test_server.py b/test/unit/selenium/test_server.py
new file mode 100644
index 000000000000..b0f23a1afe28
--- /dev/null
+++ b/test/unit/selenium/test_server.py
@@ -0,0 +1,83 @@
+"""Test server infrastructure for running selenium tests locally."""
+
+import http.server
+import socketserver
+import threading
+from pathlib import Path
+from typing import Optional
+
+
+class TestHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+    """Custom request handler for serving test HTML files."""
+
+    def __init__(self, *args, directory: Optional[str] = None, **kwargs):
+        """Initialize handler with custom directory."""
+        super().__init__(*args, directory=directory, **kwargs)
+
+    def log_message(self, format: str, *args):
+        """Suppress log messages during tests."""
+        pass
+
+    def end_headers(self):
+        """Override to add test cookies to all responses."""
+        self.send_header("Set-Cookie", "test_cookie=test_value; Path=/")
+        super().end_headers()
+
+
+class TestHTTPServer:
+    """Simple HTTP server for serving test HTML pages."""
+
+    def __init__(self, port: int = 0, directory: Optional[Path] = None):
+        """
+        Initialize test HTTP server.
+
+        Args:
+            port: Port to bind to (0 for random available port)
+            directory: Directory to serve files from
+        """
+        self.port = port
+        self.directory = directory or Path(__file__).parent / "fixtures"
+        self.server: Optional[socketserver.TCPServer] = None
+        self.thread: Optional[threading.Thread] = None
+
+    def start(self):
+        """Start the HTTP server in a background thread."""
+
+        def handler(*args, **kwargs):
+            return TestHTTPRequestHandler(*args, directory=str(self.directory), **kwargs)
+
+        self.server = socketserver.TCPServer(("localhost", self.port), handler)
+        self.port = self.server.server_address[1]  # Get actual port if 0 was specified
+
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        """Stop the HTTP server."""
+        if self.server:
+            self.server.shutdown()
+            self.server.server_close()
+        if self.thread:
+            self.thread.join(timeout=5)
+
+    def get_url(self, path: str = "") -> str:
+        """
+        Get full URL for a given path.
+
+        Args:
+            path: Path relative to served directory
+
+        Returns:
+            Full URL including protocol, host, port, and path
+        """
+        path = path.lstrip("/")
+        return f"http://localhost:{self.port}/{path}"
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.stop()
diff --git a/test/unit/selenium/test_smart_components.py b/test/unit/selenium/test_smart_components.py
new file mode 100644
index 000000000000..74ae6bea9fcd
--- /dev/null
+++ b/test/unit/selenium/test_smart_components.py
@@ -0,0 +1,305 @@
+"""Unit tests for smart_components.py - SmartComponent and SmartTarget classes.
+
+Tests the SmartComponent and SmartTarget wrapper classes that provide driver-aware
+methods for Galaxy's component locators.
+"""
+
+import pytest
+
+from galaxy.navigation.components import SelectorTemplate
+from galaxy.selenium.smart_components import (
+    SmartComponent,
+    SmartTarget,
+)
+from .test_has_driver import (
+    TestHasDriverImpl,
+    TestHasPlaywrightDriverImpl,
+)
+
+
+# Test component hierarchy for testing
+class TestComponent:
+    """Simple test component with selector attributes for testing SmartComponent."""
+
+    def __init__(self):
+        # Create Target objects that SmartComponent can wrap
+        self.button = SelectorTemplate("#test-button", "css")
+        self.input_field = SelectorTemplate("#test-input", "css")
+        self.items = SelectorTemplate(".item", "css")
+        self.hidden_element = SelectorTemplate("#hidden-element", "css")
+        self.delayed_element = SelectorTemplate("#delayed-element", "css")
+        self.data_element = SelectorTemplate("#data-element", "css")
+        self.class_element = SelectorTemplate("#class-element", "css")
+
+
+@pytest.fixture(params=["selenium", "playwright"])
+def has_driver_instance(request, driver, playwright_resources, base_url):
+    """
+    Create a driver instance based on the backend parameter.
+
+    Args:
+        request: Pytest request fixture for parametrization
+        driver: Selenium WebDriver fixture
+        playwright_resources: Playwright resources fixture
+        base_url: Base URL for test server
+
+    Returns:
+        HasDriver or HasPlaywrightDriver instance
+    """
+    if request.param == "selenium":
+        return TestHasDriverImpl(driver)
+    else:  # playwright
+        return TestHasPlaywrightDriverImpl(playwright_resources)
+
+
+@pytest.fixture
+def smart_component(has_driver_instance):
+    """Create a SmartComponent instance for testing."""
+    return SmartComponent(TestComponent(), has_driver_instance)
+
+
+class TestSmartComponentWrapping:
+    """Test SmartComponent wrapping behavior."""
+
+    def test_getattr_wraps_target(self, smart_component):
+        """Test that __getattr__ wraps Target objects in SmartTarget."""
+        button = smart_component.button
+        assert isinstance(button, SmartTarget)
+        # Check that the wrapped target has the same selector as the original
+        assert button._target.selector == "#test-button"
+        assert button._target.selector_type == "css"
+
+
+class TestSmartTargetBasicMethods:
+    """Test SmartTarget basic methods."""
+
+    def test_all_finds_multiple_elements(self, smart_component, has_driver_instance, base_url):
+        """Test that all() returns multiple elements."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        items = smart_component.items.all()
+        assert len(items) == 3
+
+    def test_all_returns_empty_list_when_no_matches(self, smart_component, has_driver_instance, base_url):
+        """Test that all() returns empty list when no elements match."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        no_match = SelectorTemplate(".nonexistent", "css")
+        smart_target = SmartTarget(no_match, has_driver_instance)
+        items = smart_target.all()
+        assert len(items) == 0
+
+    def test_wait_for_visible(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_visible returns visible element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        element = smart_component.button.wait_for_visible()
+        assert element is not None
+        assert element.text == "Click Me"
+
+    def test_wait_for_and_click(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_and_click clicks element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        smart_component.button.wait_for_and_click()
+        # Verify click worked by checking result
+        result = has_driver_instance.find_element_by_id("result")
+        assert result.text == "Button clicked!"
+
+    def test_wait_for_and_double_click(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_and_double_click double-clicks element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        smart_component.button.wait_for_and_double_click()
+        # Verify double-click worked
+        result = has_driver_instance.find_element_by_id("result")
+        assert result.text == "Button double-clicked!"
+
+    def test_wait_for_clickable(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_clickable returns clickable element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        element = smart_component.button.wait_for_clickable()
+        assert element is not None
+
+    def test_wait_for_text(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_text returns element text."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        text = smart_component.button.wait_for_text()
+        assert text == "Click Me"
+
+    def test_wait_for_present(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_present returns present element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        element = smart_component.button.wait_for_present()
+        assert element is not None
+
+    def test_is_displayed_property(self, smart_component, has_driver_instance, base_url):
+        """Test that is_displayed property returns visibility status."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        assert smart_component.button.is_displayed is True
+        assert smart_component.hidden_element.is_displayed is False
+
+    def test_is_absent_property(self, smart_component, has_driver_instance, base_url):
+        """Test that is_absent property returns absence status."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        assert smart_component.button.is_absent is False
+        nonexistent = SelectorTemplate("#nonexistent", "css")
+        smart_target = SmartTarget(nonexistent, has_driver_instance)
+        assert smart_target.is_absent is True
+
+
+class TestSmartTargetWaitMethods:
+    """Test SmartTarget wait methods."""
+
+    def test_wait_for_absent(self, has_driver_instance, base_url):
+        """Test that wait_for_absent waits for element to be absent."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        nonexistent = SelectorTemplate("#nonexistent", "css")
+        smart_target = SmartTarget(nonexistent, has_driver_instance)
+        # Element should already be absent - this should return quickly
+        smart_target.wait_for_absent()
+
+    def test_wait_for_absent_or_hidden(self, has_driver_instance, base_url):
+        """Test that wait_for_absent_or_hidden waits for element to be absent or hidden."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        hidden = SelectorTemplate("#hidden-element", "css")
+        smart_target = SmartTarget(hidden, has_driver_instance)
+        smart_target.wait_for_absent_or_hidden()
+
+
+class TestSmartTargetAssertionMethods:
+    """Test SmartTarget assertion methods."""
+
+    def test_assert_absent(self, has_driver_instance, base_url):
+        """Test that assert_absent asserts element is absent."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        nonexistent = SelectorTemplate("#nonexistent", "css")
+        smart_target = SmartTarget(nonexistent, has_driver_instance)
+        smart_target.assert_absent()  # Should not raise
+
+    def test_assert_absent_or_hidden(self, has_driver_instance, base_url):
+        """Test that assert_absent_or_hidden asserts element is absent or hidden."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        hidden = SelectorTemplate("#hidden-element", "css")
+        smart_target = SmartTarget(hidden, has_driver_instance)
+        smart_target.assert_absent_or_hidden()  # Should not raise
+
+    def test_assert_disabled(self, has_driver_instance, base_url):
+        """Test that assert_disabled asserts element is disabled."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        disabled_input = SelectorTemplate("#disabled-input", "css")
+        smart_target = SmartTarget(disabled_input, has_driver_instance)
+        smart_target.assert_disabled()  # Should not raise
+
+
+class TestSmartTargetDataMethods:
+    """Test SmartTarget data attribute methods."""
+
+    def test_data_value(self, has_driver_instance, base_url):
+        """Test that data_value retrieves data attributes."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        data_element = SelectorTemplate("#data-element", "css")
+        smart_target = SmartTarget(data_element, has_driver_instance)
+        value = smart_target.data_value("test")
+        assert value == "example-value"
+
+    def test_assert_data_value_passes(self, has_driver_instance, base_url):
+        """Test that assert_data_value passes when value matches."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        data_element = SelectorTemplate("#data-element", "css")
+        smart_target = SmartTarget(data_element, has_driver_instance)
+        smart_target.assert_data_value("test", "example-value")  # Should not raise
+
+    def test_assert_data_value_fails(self, has_driver_instance, base_url):
+        """Test that assert_data_value fails when value doesn't match."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        data_element = SelectorTemplate("#data-element", "css")
+        smart_target = SmartTarget(data_element, has_driver_instance)
+        with pytest.raises(AssertionError, match="Expected data-test to have value"):
+            smart_target.assert_data_value("test", "wrong-value")
+
+    def test_has_class_returns_true(self, has_driver_instance, base_url):
+        """Test that has_class returns True when class exists."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        class_element = SelectorTemplate("#class-element", "css")
+        smart_target = SmartTarget(class_element, has_driver_instance)
+        assert smart_target.has_class("active") is True
+
+    def test_has_class_returns_false(self, has_driver_instance, base_url):
+        """Test that has_class returns False when class doesn't exist."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        class_element = SelectorTemplate("#class-element", "css")
+        smart_target = SmartTarget(class_element, has_driver_instance)
+        assert smart_target.has_class("inactive") is False
+
+
+class TestSmartTargetInputMethods:
+    """Test SmartTarget input methods."""
+
+    def test_wait_for_and_send_keys(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_and_send_keys sends keys to element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        smart_component.input_field.wait_for_and_send_keys("test input")
+        # Verify input was sent
+        element = has_driver_instance.find_element_by_id("test-input")
+        # Note: Different backends may have different ways to get value
+        # We'll just verify the element exists for now
+        assert element is not None
+
+    def test_wait_for_and_clear_and_send_keys(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_and_clear_and_send_keys clears and sends keys."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        # First set some text
+        input_element = has_driver_instance.find_element_by_id("test-input")
+        input_element.send_keys("initial text")
+        # Now clear and send new text
+        smart_component.input_field.wait_for_and_clear_and_send_keys("new text")
+        # Verify input was cleared and new text sent
+        element = has_driver_instance.find_element_by_id("test-input")
+        assert element is not None
+
+    def test_wait_for_and_clear_aggressive_and_send_keys(self, smart_component, has_driver_instance, base_url):
+        """Test that wait_for_and_clear_aggressive_and_send_keys aggressively clears and sends keys."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        # First set some text
+        input_element = has_driver_instance.find_element_by_id("test-input")
+        input_element.send_keys("initial text that needs aggressive clearing")
+
+        # Now use aggressive clear and send new text
+        smart_component.input_field.wait_for_and_clear_aggressive_and_send_keys("new text after aggressive clear")
+
+        # Verify input was cleared and new text sent
+        # Use execute_script to verify the value reliably across both backends
+        value = has_driver_instance.execute_script("return arguments[0].value", input_element)
+        assert "new text after aggressive clear" in value
+        assert "initial text" not in value
+
+
+class TestSmartTargetAccessibilityMethods:
+    """Test SmartTarget accessibility methods."""
+
+    def test_axe_eval(self, has_driver_instance, base_url):
+        """Test that axe_eval runs accessibility scan on scoped element."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        # Test on the accessible form section
+        accessible_form = SelectorTemplate("#accessible-form", "css")
+        smart_target = SmartTarget(accessible_form, has_driver_instance)
+        results = smart_target.axe_eval()
+        # Just verify it returns results
+        assert results is not None
+
+    def test_assert_no_axe_violations_with_impact_of_at_least(self, has_driver_instance, base_url):
+        """Test that assert_no_axe_violations_with_impact_of_at_least works."""
+        has_driver_instance.navigate_to(f"{base_url}/smart_components.html")
+        # Test on the accessible form section (should have no critical violations)
+        accessible_form = SelectorTemplate("#accessible-form", "css")
+        smart_target = SmartTarget(accessible_form, has_driver_instance)
+        # This may raise if there are violations, which is expected behavior
+        # For now we just test that the method exists and runs
+        # Should not raise for accessible content
+        smart_target.assert_no_axe_violations_with_impact_of_at_least("critical")
+
+
+class TestSmartTargetStrRepresentation:
+    """Test SmartTarget string representation."""
+
+    def test_str_representation(self, smart_component):
+        """Test that SmartTarget has useful string representation."""
+        str_repr = str(smart_component.button)
+        assert "SmartTarget" in str_repr
+        assert "_target=" in str_repr
diff --git a/test/unit/selenium/util.py b/test/unit/selenium/util.py
new file mode 100644
index 000000000000..fa7f13dbe2f6
--- /dev/null
+++ b/test/unit/selenium/util.py
@@ -0,0 +1,92 @@
+"""Pytest-specific utility functions and decorators for selenium unit tests."""
+
+from typing import (
+    Callable,
+    TypeVar,
+    Union,
+)
+
+import pytest
+from typing_extensions import ParamSpec
+
+from galaxy.selenium.availability import (
+    check_playwright_cached,
+    check_selenium_cached,
+    is_playwright_browser_available,
+    is_selenium_browser_available,
+    PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE,
+    SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE,
+)
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def _identity(func: Callable[P, T]) -> Callable[P, T]:
+    """Identity function that returns the input function unchanged."""
+    return func
+
+
+def skip_unless_selenium_browser() -> Union[Callable[[Callable[P, T]], Callable[P, T]], pytest.MarkDecorator]:
+    """
+    Skip test if Selenium Chrome browser is not available.
+
+    Returns:
+        Either identity function (if browser available) or pytest skip marker with instructions
+    """
+    if is_selenium_browser_available():
+        return _identity
+    return pytest.mark.skip(SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE)
+
+
+def skip_unless_playwright_browser() -> Union[Callable[[Callable[P, T]], Callable[P, T]], pytest.MarkDecorator]:
+    """
+    Skip test if Playwright Chromium browser is not available.
+
+    Returns:
+        Either identity function (if browser available) or pytest skip marker with instructions
+    """
+    if is_playwright_browser_available():
+        return _identity
+    return pytest.mark.skip(PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE)
+
+
+def skip_unless_selenium_browser_cached() -> Union[Callable[[Callable[P, T]], Callable[P, T]], pytest.MarkDecorator]:
+    """
+    Skip test if Selenium Chrome browser is not available (cached check).
+
+    This version caches the browser availability check to avoid repeatedly
+    launching browsers during test collection.
+
+    Returns:
+        Either identity function (if browser available) or pytest skip marker with instructions
+    """
+    if check_selenium_cached():
+        return _identity
+    return pytest.mark.skip(SELENIUM_BROWSER_NOT_AVAILABLE_MESSAGE)
+
+
+def skip_unless_playwright_browser_cached() -> Union[Callable[[Callable[P, T]], Callable[P, T]], pytest.MarkDecorator]:
+    """
+    Skip test if Playwright Chromium browser is not available (cached check).
+
+    This version caches the browser availability check to avoid repeatedly
+    launching browsers during test collection.
+
+    Returns:
+        Either identity function (if browser available) or pytest skip marker with instructions
+    """
+    if check_playwright_cached():
+        return _identity
+    return pytest.mark.skip(PLAYWRIGHT_BROWSER_NOT_AVAILABLE_MESSAGE)
+
+
+# Re-export the cached check functions for use in conftest.py and test files
+__all__ = (
+    "skip_unless_selenium_browser",
+    "skip_unless_playwright_browser",
+    "skip_unless_selenium_browser_cached",
+    "skip_unless_playwright_browser_cached",
+    "check_selenium_cached",
+    "check_playwright_cached",
+)