Playwright: rename browsers_path → browser_cache_dir for parity with Puppeteer

Match the Puppeteer provider's field names so both browser-installing
providers expose the same API surface:

- writable field: ``browser_cache_dir`` (was ``browsers_path``)
- computed property: ``cache_dir``   (was ``resolved_browsers_path``)

Both still default-factory from their respective env vars
(``PUPPETEER_CACHE_DIR`` / ``PLAYWRIGHT_BROWSERS_PATH``) and use the
same three-tier precedence documented in the README.

Author: claude

README.md

@@ -1097,12 +1097,12 @@ INSTALLER_BIN = "playwright"
 PATH = ""
 install_root = None              # abxpkg-managed root dir for bin_dir / nested npm prefix
 bin_dir = <install_root>/bin     # symlink dir for resolved browsers
-browsers_path = None             # hydrated from PLAYWRIGHT_BROWSERS_PATH env; overrides install_root/cache
+browser_cache_dir = None         # hydrated from PLAYWRIGHT_BROWSERS_PATH env; overrides install_root/cache
 euid = 0                         # routes exec() through sudo-first-then-fallback
 ```
 
 - Install root: set `install_root` to pin the abxpkg-managed root dir (where `bin_dir` symlinks and the nested npm prefix live). Leave it unset to let playwright use its own OS-default browsers path (`~/.cache/ms-playwright` on Linux etc.) — in that case abxpkg maintains no symlink dir or npm prefix at all, the `playwright` npm CLI bootstraps against the host's npm default, and `load()` returns the resolved `executablePath()` directly. `bin_dir` overrides the symlink directory when `install_root` is pinned.
-- Browsers path / `PLAYWRIGHT_BROWSERS_PATH`: the actual browsers cache dir is resolved with three-tier precedence: explicit `browsers_path` / `PLAYWRIGHT_BROWSERS_PATH` env wins → else `<install_root>/cache` when an install root is pinned → else `None` (let playwright pick its OS default). The final value is exported as `PLAYWRIGHT_BROWSERS_PATH` to every subprocess the provider runs.
+- Cache dir / `PLAYWRIGHT_BROWSERS_PATH`: the actual browsers cache dir is resolved via the `cache_dir` computed property with three-tier precedence: explicit `browser_cache_dir` / `PLAYWRIGHT_BROWSERS_PATH` env wins → else `<install_root>/cache` when an install root is pinned → else `None` (let playwright pick its OS default). The final value is exported as `PLAYWRIGHT_BROWSERS_PATH` to every subprocess the provider runs.
 - Auto-switching: bootstraps the `playwright` npm package through `NpmProvider`, then runs `playwright install --with-deps <install_args>` against it. Resolves each installed browser's real executable via the `playwright-core` Node.js API (`chromium.executablePath()` etc.) and writes a symlink into `bin_dir` when one is configured.
 - `dry_run`: shared behavior — the install handler short-circuits to a placeholder without touching the host.
 - Privilege handling: `--with-deps` installs system packages and requires root on Linux. ``euid`` defaults to ``0``, which routes every ``exec()`` call through the base ``BinProvider.exec`` sudo-first-then-fallback path — it tries ``sudo -n -- playwright install --with-deps ...`` first on non-root hosts, falls back to running the command directly if sudo fails or isn't available, and merges both stderr outputs into the final error if both attempts fail.

abxpkg/binprovider_playwright.py

@@ -39,7 +39,7 @@ class PlaywrightProvider(BinProvider):
     finds it directly, and ``PLAYWRIGHT_BROWSERS_PATH`` defaults to
     ``<install_root>/cache`` for the actual browser downloads. Callers
     that want to pin the browsers path somewhere else can set the
-    ``browsers_path`` field (hydrated from ``PLAYWRIGHT_BROWSERS_PATH``
+    ``browser_cache_dir`` field (hydrated from ``PLAYWRIGHT_BROWSERS_PATH``
     env) — that override always wins over ``install_root/cache``.
     When ``playwright_root`` is left unset, playwright picks its own
     default browsers path, the npm CLI bootstraps against the host's
@@ -77,9 +77,9 @@ class PlaywrightProvider(BinProvider):
     # env var) when unset so callers can pin the cache dir the same way they
     # would for a vanilla ``playwright install``. When both this and
     # ``install_root`` are unset, playwright falls back to its OS default; when
-    # only ``install_root`` is set, ``browsers_path`` defaults to
+    # only ``install_root`` is set, ``cache_dir`` defaults to
     # ``<install_root>/cache`` (see ``ENV``).
-    browsers_path: Path | None = Field(
+    browser_cache_dir: Path | None = Field(
         default_factory=lambda: (
             Path(os.environ["PLAYWRIGHT_BROWSERS_PATH"]).expanduser()
             if os.environ.get("PLAYWRIGHT_BROWSERS_PATH")
@@ -95,26 +95,26 @@ class PlaywrightProvider(BinProvider):
     @computed_field
     @property
     def ENV(self) -> "dict[str, str]":
-        resolved = self.resolved_browsers_path
+        resolved = self.cache_dir
         if resolved is None:
             return {}
         return {"PLAYWRIGHT_BROWSERS_PATH": str(resolved)}
 
     @computed_field
     @property
-    def resolved_browsers_path(self) -> Path | None:
+    def cache_dir(self) -> Path | None:
         """PLAYWRIGHT_BROWSERS_PATH precedence:
 
-        1. Explicit ``browsers_path`` (field / ``PLAYWRIGHT_BROWSERS_PATH`` env)
+        1. Explicit ``browser_cache_dir`` (field / ``PLAYWRIGHT_BROWSERS_PATH`` env)
            wins — the more specific cache-dir override always beats the less
            specific install-root.
         2. Else, when ``install_root`` is pinned, default to
            ``<install_root>/cache`` so managed installs stay self-contained.
         3. Else leave it unset and let playwright pick its own OS-default
            browsers cache directory.
         """
-        if self.browsers_path is not None:
-            return self.browsers_path
+        if self.browser_cache_dir is not None:
+            return self.browser_cache_dir
         if self.install_root is not None:
             return self.install_root / "cache"
         return None
@@ -326,11 +326,11 @@ def exec(
         # contain our bin_dir.
         env = self.build_exec_env(base_env=(kwargs.pop("env", None) or os.environ))
         env_assignments: list[str] = []
-        resolved_browsers_path = self.resolved_browsers_path
-        if resolved_browsers_path is not None:
-            env["PLAYWRIGHT_BROWSERS_PATH"] = str(resolved_browsers_path)
+        cache_dir = self.cache_dir
+        if cache_dir is not None:
+            env["PLAYWRIGHT_BROWSERS_PATH"] = str(cache_dir)
             env_assignments.append(
-                f"PLAYWRIGHT_BROWSERS_PATH={resolved_browsers_path}",
+                f"PLAYWRIGHT_BROWSERS_PATH={cache_dir}",
             )
         needs_sudo_env_wrapper = os.geteuid() != 0 and self.EUID != os.geteuid()
         if env_assignments and needs_sudo_env_wrapper: