This PR adds a native Playwright-style Locator query + action + assertion API to Rstest browser mode. The core design uses an IR (Intermediate Representation) + RPC + Provider abstraction architecture, ensuring future extensibility to multiple browser drivers without changing test code.

User API (Playwright-style surface)

import { page } from "@rstest/browser";
import { expect, test } from "@rstest/core";

test("login", async () => {
  await page.getByRole("textbox", { name: "Username" }).fill("alice");
  await page.getByLabel("Password").fill("123456");
  await page.getByRole("button", { name: "Sign in" }).click();

  await expect.element(page.getByText("Welcome")).toBeVisible();
});

Design goal: zero learning curve for users already familiar with Playwright.

Core Architecture: IR-Driven Client/Host Communication

┌─────────────────────────── Browser (iframe) ───────────────────────────┐
│                                                                        │
│  Test Code                                                             │
│    │  page.getByRole("button", { name: "Save" }).click()               │
│    ▼                                                                   │
│  Locator Class ─── does NOT query DOM directly; builds IR instead ──── │
│    │  IR = { steps: [{ type: "getByRole", role: "button", ... }] }     │
│    ▼                                                                   │
│  browserRpc ─── serializes IR + method + args into BrowserRpcRequest ─ │
│    │                                                                   │
└────┼───────────────────────────────────────────────────────────────────┘
     │  postMessage / page.exposeFunction bridge
     ▼
┌─────────────────────────── Host (Node.js) ─────────────────────────────┐
│                                                                        │
│  DispatchRouter ─── namespace routing (transport-agnostic)             │
│    │                                                                   │
│    ▼                                                                   │
│  BrowserRpcRegistry ─── API allowlist + provider dispatch              │
│    │                                                                   │
│    ▼                                                                   │
│  Provider: Playwright                                                  │
│    ├── compileLocator(IR) ─── IR → real Playwright Locator chain       │
│    └── dispatchBrowserRpc  ─── execute action / _expect() assertion    │
│         │                                                              │
│         ▼                                                              │
│    Playwright Page/Locator ─── native execution                        │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘
     │  result / error
     ▼
  Browser-side resolve/reject → test case gets the result

Why IR?

• The browser runner (iframe) and the host (Node.js + Playwright) are naturally isolated — locator descriptions must be serializable for cross-process transport
• IR decouples the locator description from the provider implementation — the same IR can be compiled into native calls by different providers
• A serializable step list enables tracing, debugging, and potential record/replay in the future

Provider Abstraction: Multi-Provider Architecture

A BrowserProviderImplementation interface is introduced:

type BrowserProviderImplementation = {
  name: BrowserProvider;
  launchRuntime: (input: LaunchBrowserInput) => Promise<BrowserProviderRuntime>;
  dispatchRpc: (input: DispatchBrowserRpcInput) => Promise<unknown>;
};

A structural type BrowserProviderPage (a subset mirror of Playwright's Page) is also defined to avoid leaking Playwright types into the framework core. Adding a new provider (e.g., WebDriver BiDi) only requires implementing this interface and registering it in the providerImplementations map — no changes needed on the test-side API.

Current Playwright Provider Support

Key Code Locations

Browser side (build IR + send RPC):

• browser/src/client/locator.ts — Locator class, chained step/IR generation
• browser/src/rpcProtocol.ts — IR type definitions (serialization protocol core)
• browser/src/client/browserRpc.ts — RPC transport
• browser/src/client/api.ts — expect.element / page entry points
• browser/src/augmentExpect.ts — expect type augmentation

Host/Provider side (routing + compilation + execution):

• browser/src/providers/index.ts — provider abstraction and registration
• browser/src/browserRpcRegistry.ts — supported API registry (single source of truth)
• browser/src/providers/playwright/compileLocator.ts — IR → Playwright Locator
• browser/src/providers/playwright/dispatchBrowserRpc.ts — action/assertion execution

Compatibility

• Purely additive capability; does not affect existing tests
• Reuses existing dispatch envelope channel (dispatchRouter + namespace) — no protocol bloat

Checklist

• Tests updated (or not required).
• Documentation updated (or not required).