e2e 0.16.0 → 0.18.0

package/skills/e2e/references/running.md

@@ -11,7 +11,7 @@ npx e2e guide [topic]              # print this skill; topics: setup, writing-te
                                    # running, explore, debugging, mcp, bug-bash
 npx e2e cache ls|clear|stats       # inspect or empty the replay cache
 npx e2e login|logout|models [provider]  # e2e/oauth subscription logins: openai,
-                                   # github-copilot, spacexai
+                                   # github-copilot, opencode-console, spacexai
 npx e2e mcp [--target <name>]      # MCP server for a coding agent (topic mcp)
 npx e2e feedback -m <text> [opts]  # report a problem with e2e itself
 npx e2e telemetry [disable|enable] # anonymous usage telemetry: status or switch
@@ -27,7 +27,7 @@ npx e2e telemetry [disable|enable] # anonymous usage telemetry: status or switch
 | `--tag <tags>` | Any of the tags, comma-separated or repeated; all of them with `--tag-mode all`. An empty `--target`, `--tag`, or `--agent` value is a usage error, exit 2. |
 | `--exclude-tag <tags>` | Drop tests carrying any of these tags, however selected. |
 | `--grep <pattern>`, `--grep-invert <pattern>` | Keep, or drop, tests whose title (describe titles and test title joined by spaces, `checkout pays`; not file or tags) matches a regular expression. Bare pattern or `'/pattern/i'`; repeat for alternatives. |
-| `--last-failed` | The tests the previous run (`<output>/report.json`) did not pass, plus every test in a failed `beforeAll` or `afterAll` scope. No report is `NO_LAST_RUN`, exit 2. |
+| `--last-failed` | The tests the previous run (`<output>/report.json`) did not pass or never ran (`--max-failures` included), plus every test in a failed `beforeAll` or `afterAll` scope. A test another filter leaves out stays owed (`run.carried` in the report) until a rerun runs it. No report is `NO_LAST_RUN`, exit 2. |
 | `--shard <index/total>` | One contiguous slice of the selected tests (`--shard 2/3`), cut after every other filter; serial groups stay whole, each shard brings its own setup tests. |
 | `--headed` | Visible browser or simulator when the engine supports it. |
 | `--agent <names>` | Run unpinned tests as these `agents.<name>` entries (default `agents.default`), comma-separated or repeated; several names run each such test once per agent. |
@@ -67,6 +67,7 @@ npx e2e list tests/signup.e2e.ts --tag smoke --reporter json
 With a `package.json` script `"test:e2e": "e2e run"`, pnpm forwards `--`
 literally: `pnpm test:e2e -- --headed` reaches e2e as `run -- --headed` and
 exits 2. Write `pnpm test:e2e --headed` or `pnpm exec e2e run --headed`.
+With npm, use `npm exec -- e2e run --headed` to pass flags to e2e.
 
 ## The replay cache
 
@@ -87,7 +88,8 @@ its own tools.
 `summary.md`, `failures/`, `ai-trace.json`, `sessions/`, and `artifacts/`
 (screenshots, Playwright traces, videos, `--debug` transcripts, downloads).
 `artifacts/` is cleared once a run's tests start; a run stopping before
-leaves the last run's files. The report records every artifact path, a
+leaves the last run's files, and a `--last-failed` rerun keeps the files
+the report it reruns names and writes its own under `artifacts/rerun-<n>/`. The report records every artifact path, a
 hosted service's video by URL.
 
 - `list` (default): setup steps, one line per file and target, a `Failed
@@ -102,11 +104,14 @@ hosted service's video by URL.
   and `run.results[]`, one per test and target: `titlePath`, `file`,
   `source`, `tags` (`[]` when none), `agent`, `repeat` (0 unless
   `--repeat-each`), `selected`, `status`, `attempts[]` of `steps[]`,
-  `artifacts[]`, `error`.
+  `artifacts[]`, `error`. `run.summary` counts the selected results:
+  `passed`, `failed` (timed out included), `interrupted` (stopped by the
+  run: a signal, `--max-failures`, a run-level error; not a failure), `flaky`, and `skipped` add up
+  to `selected`; `discovered - selected` were left out.
 - `junit`: `junit.xml` for CI summaries; `--reporter list,junit` keeps the
   terminal output.
 - `markdown` (`--reporter list,markdown`): `summary.md` plus one page per
-  failed or flaky test under `failures/`. The summary holds counts and
+  failed or flaky test under `failures/` (an interrupted test gets none). The summary holds counts and
   spend, a block per failed test (error, facts, failing step, whether every
   attempt failed alike, last model turns, screen location and closest
   nodes, the line to look at, evidence paths), the flaky tests folded
@@ -142,8 +147,9 @@ interrupted workers keeps the failures' or the error's code. Exit 2 is
 deterministic, never retry it; only exit 3 is worth a job-level retry.
 
 The first SIGINT or SIGTERM interrupts and writes the report if any test
-had started; the second forces engine teardown; the third kills the app
-process groups and exits 130 at once.
+had started; the second forces engine teardown and still writes the
+report, plus `junit.xml` and `summary.md` when those reporters are on; the
+third kills the app process groups and exits 130 at once.
 
 ## Continuous integration
 
@@ -171,10 +177,10 @@ jobs:
       - uses: pnpm/action-setup@9fd676a19091d4595eefd76e4bd31c97133911f1 # v4.2.0
       - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
-          node-version: 26 # any Node >= 22.12
+          node-version: 26 # Node >= 24.8, or >= 22.22.3 on 22
           cache: pnpm
       - run: pnpm install --frozen-lockfile
-      - run: npx playwright install chromium --with-deps
+      - run: pnpm exec e2e-web install chromium --with-deps
       - run: npx e2e run --reporter list,junit
         env:
           AI_GATEWAY_API_KEY: ${{ secrets.AI_GATEWAY_API_KEY }}

package/skills/e2e/references/setup.md

@@ -2,17 +2,18 @@
 
 ## Requirements
 
-- Node.js 22.12 or newer.
+- Node.js 24.8 or newer, or 22.22.3 or newer on Node.js 22.
 - ES modules: `.ts` config, tests, helpers, and workspace packages exporting
   `.ts` source load as ESM regardless of the nearest `package.json` `type`
   (CommonJS packages need no change); never `require` or `module.exports`.
-- Browser tests: `@e2e-dev/web` plus `playwright` (`>=1.63.0 <2`), a peer the
-  engine does not install: an existing Playwright keeps its version and
-  browser cache, one out of range fails install as an unmet peer (npm's
-  `ERESOLVE`): upgrade `playwright` within the range. Missing
-  browsers download on first boot; in CI run `npx playwright install chromium
-  --with-deps`. Mobile tests: `@e2e-dev/mobile`, pinning `agent-device`
-  exactly; the pin moves with each engine release.
+  Imports follow TypeScript: `./x.js` or `./x` loads `x.ts`, and the nearest
+  `tsconfig.json` `paths` and `baseUrl` apply. Decorators need
+  `experimentalDecorators`; CommonJS TypeScript goes in `.cts`.
+- Browser tests: `@e2e-dev/web`, pinning `playwright-core` exactly; do not
+  add `playwright` for it. Missing browsers download on first boot; in CI run
+  `npx @e2e-dev/web install chromium --with-deps` (pnpm: `pnpm exec e2e-web
+  install chromium --with-deps`). Mobile tests: `@e2e-dev/mobile`, pinning
+  `agent-device` exactly; each pin moves with its engine release.
 
 ## Scaffold
 
@@ -41,7 +42,7 @@ MCP entries.
 Without the wizard (`ai`, Vercel AI SDK v7, only for `agent.*` steps):
 
 ```bash
-npm install --save-dev e2e @e2e-dev/web playwright ai@^7
+npm install --save-dev e2e @e2e-dev/web ai@^7
 ```
 
 ## Subscriptions and API keys
@@ -53,6 +54,7 @@ key, or a local endpoint. Authenticate:
 | --- | --- |
 | ChatGPT Plus or Pro | `npx e2e login openai` |
 | GitHub Copilot | `npx e2e login github-copilot` (GitHub CLI signed in, or your own `--client-id`) |
+| OpenCode Console (OpenCode Zen and OpenCode Go) | `npx e2e login opencode-console` (approve the device code, pick the workspace) |
 | SuperGrok or X Premium+ | `npx e2e login spacexai` |
 | Vercel AI Gateway | Set `AI_GATEWAY_API_KEY`, or sign in to the Vercel CLI and `npx vercel link`; without the key `gateway()` uses a Vercel OIDC token |
 | OpenRouter | Set `OPENROUTER_API_KEY` |
@@ -63,6 +65,22 @@ set `model: chatgpt('gpt-6-luna')` from `e2e/oauth/chatgpt`, run `npx e2e
 login openai`. `npx e2e models` lists the ids each login serves. Use API keys
 in CI.
 
+Switching to Copilot: install `ai`, `@ai-sdk/openai-compatible`, and
+`@ai-sdk/openai`, set `model: copilot('<id>')` from `e2e/oauth/copilot`, run
+`npx e2e login github-copilot`. `copilot()` calls a model over chat completions, or
+over Copilot's Responses API when the plan serves that model only there, choosing
+per model from the plan's listing. `npx e2e models github-copilot` marks the models
+it cannot call at all: those served only over an API `copilot()` does not speak, and
+those the plan has not enabled.
+
+Switching to OpenCode Console: install `ai`, `@ai-sdk/openai-compatible`,
+`@ai-sdk/openai`, `@ai-sdk/anthropic`, and `@ai-sdk/google`, set
+`model: opencodeConsole('<id>')` from `e2e/oauth/opencode-console`, run
+`npx e2e login opencode-console`. A bare id is an OpenCode Zen model; a `go/` id
+(`go/deepseek-v4.1-flash`) is an OpenCode Go model and needs the workspace's Go
+subscription. `npx e2e models opencode-console` lists the ids, tagged Zen or Go. In CI,
+set a Console service account key as `OPENCODE_API_KEY`.
+
 ## The config
 
 `e2e.config.ts` sits at the project root and default-exports an object literal
@@ -168,6 +186,8 @@ start a script that brings them up and serves the app.
 | `headers` | Sent to the app's site only (Vercel's `x-vercel-protection-bypass`, ngrok's `ngrok-skip-browser-warning`), `agent.act` included; disables the browser HTTP cache and service workers. |
 | `basicAuth` | `{ username, password }` for a `401` challenge; `password` may be `secrets.get('name')`, resolved per attempt and redacted like any secret, the base64 `Authorization` credential too. |
 | `userAgent` | The `User-Agent` every attempt sends and `navigator.userAgent` reports. |
+| `locale`, `timezoneId` | The language (`'de-DE'`: `navigator.language`, `Intl`, `Accept-Language`) and IANA time zone (`'Europe/Berlin'`) every attempt runs in. |
+| `initScripts` | Scripts every document runs before the page's own: source, `{ path }`, or a function with no closures. |
 | `testIdAttribute` | What `getByTestId` reads; default `data-testid`. |
 | `screencast` | `{ size?, quality? }` for the engine's own video: frame size (default the viewport's), JPEG quality 0 to 100. |
 
@@ -176,7 +196,7 @@ start a script that brings them up and serves the app.
   the handle (a reference, not the value) in `app.command.env`, a template
   literal, or `context`; read those from `process.env`.
 - `reconnectEndpoint` or an attempt-scoped provider rides one persistent
-  context without `headers`, `basicAuth`, `userAgent`, `app.clearState()`, or
+  context without `headers`, `basicAuth`, `userAgent`, `locale`, `timezoneId`, `app.clearState()`, or
   session state. Recovery never repeats a dispatched operation; exhausting
   the budget is `OPERATION_TIMEOUT`. Without `reconnectEndpoint` a dropped
   connection is reacquired at the next attempt.
@@ -246,16 +266,20 @@ For an app started elsewhere, point `app.url` at it, literally or via
 | --- | --- |
 | `AI_GATEWAY_API_KEY`, `OPENROUTER_API_KEY`, `OPENAI_API_KEY`, ... | Read by provider packages, not the runner. |
 | `E2E_USER_<NAME>_USERNAME`, `E2E_USER_<NAME>_PASSWORD` | Override `credentials.<name>`; `<NAME>` is the name uppercased, other characters `_`. |
-| `E2E_SECRET_<NAME>` | Overrides `secrets.<name>`, same rule. |
+| `E2E_SECRET_<NAME>` | Overrides `secrets.<name>`, same rule. Two entries of one namespace mapping to one variable are `INVALID_CONFIG`. |
 | `CI` | CI defaults; list in topic `running`. |
 | `E2E_TELEMETRY_DISABLED`, `DO_NOT_TRACK` | Disable anonymous telemetry, as does `e2e telemetry disable`; `E2E_TELEMETRY_DEBUG=1` prints events instead of sending. |
 
 ## Mobile targets
 
-`@e2e-dev/mobile` drives iOS simulators and Android emulators through
-[agent-device](https://github.com/callstack/agent-device); needs Xcode with a
-simulator runtime or the Android SDK with an emulator; run
-`npx agent-device doctor` once.
+`@e2e-dev/mobile` drives iOS simulators, Android emulators, and connected
+phones through [agent-device](https://github.com/callstack/agent-device);
+needs Xcode with a simulator runtime or the Android SDK with an emulator (a
+phone needs Xcode with Developer Mode and runner signing, or adb with USB
+debugging authorized); run `npx agent-device doctor` once. Name a phone in `device` by the name
+`npx agent-device devices` lists, not its UDID or serial. On an iPhone, device
+settings (permissions, `clearState`, network, location, appearance,
+biometrics, keychain) and the clipboard are simulator-only.
 
 ```ts
 import type { E2EConfig } from 'e2e';
@@ -292,7 +316,7 @@ export default {
   `app.command` (`npx expo start --port 8081`) with `readyUrl:
   'http://localhost:8081/status'` starts it.
 - One worker per device. No `device`: every booted simulator or emulator of
-  the platform is the pool, up to `workers` (none booted: agent-device boots
+  the platform, and every connected phone, is the pool, up to `workers` (none booted: agent-device boots
   one); one `device`: one worker whatever `workers` says; a list (`device:
   ['iPhone 17', 'iPhone 17 Pro']`): an explicit pool. Devices boot in
   `prepare`, before the run's clock. Two sessions on one device fight over
@@ -333,3 +357,8 @@ export default {
 - `.gitignore` lists the `.e2e/` outputs (init adds them); drop the
   `.e2e/cache/` line to commit replays.
 - CI runs the whole suite, agent steps included, on PRs; see `running`.
+
+### Existing MCP registration
+
+Re-running `init` preserves the e2e MCP server's environment and client settings
+while repairing its launch command. A current registration is left unchanged.

package/skills/e2e/references/writing-tests.md

@@ -168,7 +168,9 @@ substring; a `RegExp` matches as written.
   scoping under another locator. Any other `filter` key (`hasNot`,
   `hasNotText`) or an empty `filter({})` is `INVALID_LOCATOR`.
 - `visible: true` drops nodes the page hides (a closed drawer) before the
-  exactly-one rule.
+  exactly-one rule. Visibility is what renders, as `toBeVisible()` reads it:
+  an `aria-hidden` spinner that paints is visible, so `toBeHidden()` waits
+  for it to go.
 - On the web, queries reach open shadow roots and closed roots attached with
   `attachShadow`, not declarative closed roots. `browser.locator(css)`,
   `frameLocator`, and `filter({ hasText })` stop at a closed root; query the
@@ -201,7 +203,7 @@ field and types one character per `delay`, plain string only (a `Secret` is
 Coordinates are CSS pixels, for what the tree does not list: `tap({ position:
 { x, y } })` offsets from the node's top-left corner (with `modifiers` it is
 `INVALID_ARGUMENT`), `screen.tapAt({ x, y })` taps a viewport point,
-`screen.swipe({ from, to })` swipes along a path,
+`screen.swipe({ from, to, duration? })` swipes along a path,
 `screen.swipe({ direction, momentum? })` swipes the viewport. Prefer a
 locator; a point moves with the layout.
 
@@ -215,7 +217,7 @@ text, both `[]` at zero. Text is the rendered text, whitespace collapsed: on
 the web what `innerText` reads (`text-transform` applies, `display: none`
 drops out, `<br>` is a space); `toHaveText` reads the same. `isChecked()` is
 `false`, not an error, on a node with no checked state, so query checkable
-controls by role. `waitFor({ state?: 'visible' | 'hidden', timeout? })` waits
+controls by role. `waitFor({ state?: 'attached' | 'detached' | 'visible' | 'hidden', timeout? })` waits
 within `actionTimeout`, else `LOCATOR_NOT_FOUND`. For a value that has to
 settle use `expect`, not a read. Reading a password field's value or
 attributes is `POLICY_DENIED`, as is `toHaveAttribute` on one, negated too.
@@ -224,13 +226,20 @@ attributes is `POLICY_DENIED`, as is `toHaveAttribute` on one, negated too.
 
 `expect(locator)` polls up to `config.assertionTimeout` (5 s) or
 `{ timeout }`; `.not` inverts and passes once the negation has held 1 s
-continuously, so it never returns in under a second. `expect(value,
+continuously, or for the whole `timeout` when that is shorter, so it never
+returns sooner. `expect(value,
 message?)` is synchronous.
 `expect.poll(read, { timeout?, interval?, message? })` re-reads until a value
 matcher passes (`assertionTimeout` and 100 ms by default, stopping with the
-attempt); a throwing read keeps polling, and it is not a report step.
+attempt); a throwing read keeps polling, and it is not a report step. A
+poll that the body or a hook returns without awaiting is cancelled and fails
+that phase with `STEP_NOT_AWAITED`.
 `expect.soft(x)` keeps a failure instead of throwing; the attempt fails
-after the body with every soft failure listed.
+after the body with every soft failure listed. If the body calls `test.skip`,
+the test stays skipped and the failures remain in `secondaryErrors`. The CLI
+shows `Skipped After Failure`, also when a retry skips after an earlier
+failure. Set `failOnSkippedFailure: true` in the config to fail the run with
+exit code 1 in either case. The default is `false`; clean skips stay green.
 `expect.any(Class)`, `expect.anything()`, `expect.objectContaining(obj)`,
 `expect.arrayContaining(arr)`, `expect.stringContaining(s)`, and
 `expect.stringMatching(s | RegExp)` stand in for values inside `toEqual`,
@@ -265,8 +274,8 @@ list or tests a RegExp. A failed matcher is `ASSERTION_FAILED`, exit code 1.
 
 Playwright's `{ checked: false }`, `{ enabled: false }`, `{ visible: false }`,
 and `{ attached: false }` flip their matchers, and `{ ignoreCase: true }`
-works on `toHaveText`, `toContainText`, `toHaveAccessibleName`, and
-`toHaveAttribute(name, value)`. Any other option, `indeterminate` or
+works on `toHaveText`, `toContainText`, `toHaveAccessibleName`,
+`toHaveAttribute(name, value)`, and `expect(browser).toHaveURL`. Any other option, `indeterminate` or
 `useInnerText` included, is `INVALID_ARGUMENT`, in JavaScript too.
 
 ## Sign-in sessions
@@ -323,7 +332,9 @@ credentials: {
   A function is read at fill time and redacted only from that fill on.
 - `E2E_USER_<NAME>_USERNAME` and `E2E_USER_<NAME>_PASSWORD` override either
   field per run, even over a function; `<NAME>` is the credential name
-  uppercased, every character outside `[A-Z0-9]` as `_`.
+  uppercased, every character outside `[A-Z0-9]` as `_`. Two credentials (or
+  two secrets) mapping to one variable, `svc-a` and `svc_a`, are
+  `INVALID_CONFIG`.
 - `credentials.user('admin').password` is a `Secret` with no plaintext
   accessor, named `admin.password` to the agent and in reports; `secrets.get()`
   never returns it (separate namespaces). Only `fill()` and `agent.act` params accept it, stringifying it
@@ -360,14 +371,20 @@ the app opens itself (`target="_blank"`, `window.open`) is not followed:
 - `evaluate(fn | source, arg?)`: runs a function or source string in the
   page, JSON in and out, no closures; a throw in the page is
   `EVALUATE_FAILED`.
-- `route(pattern, handler)`, `unroute(pattern)`: intercept requests;
-  `route.request` has `url`, `method`, `headers`, `postData`. The handler
-  calls exactly one of `fulfill({ status?, headers?, json | body })`,
-  `continue()`, or `abort()`; none or two fails the next step with
-  `ACTION_FAILED`.
-- `waitForResponse(pattern, { timeout? })`: resolves with
-  `{ url, status, headers, json(), text() }`; `text()` and `json()` reject
-  with `ACTION_FAILED` when the body could not be read.
+- `addInitScript(source | { path } | fn)`, `addInitScript(fn, arg)`: runs
+  before the page's own scripts; call it before `app.open`. `arg` is JSON.
+- `route(pattern, handler)`, `unroute(pattern)`: intercept requests, newest
+  route first; `route.request` has `url`, `method`, `headers`, `postData`.
+  The handler calls exactly one of
+  `fulfill({ status?, headers?, contentType?, json | body | path })`,
+  `continue({ url?, method?, headers?, postData? })` (straight to the
+  network), `fallback()` (the route registered before it), or `abort()`;
+  none or two fails the next step with `ACTION_FAILED`, an unsupported
+  option with `INVALID_ARGUMENT`.
+- `waitForResponse(pattern, { timeout? })`: resolves once the headers
+  arrive, with `{ url, status, headers, json(), text() }`; `text()` and
+  `json()` wait for the body (up to the action timeout) and reject with
+  `ACTION_FAILED` when it could not be read.
 - `cookies()`, `setCookies([...])`: a target is an http(s) URL or a domain.
 - `setViewport({ width, height })`: resize.
 - `onDialog('accept' | 'dismiss' | handler)`: awaited; resolves to an async
@@ -396,5 +413,5 @@ A `route`, `unroute`, or `waitForResponse` pattern is a glob string or
   plus value matchers, in a `test.extend` fixture that reads `browser.cookies()`
   when the API needs the session.
 - No sleeps or polling loops; a matcher with a longer `timeout` instead.
-- `await` every step call, else `STEP_NOT_AWAITED` at the line of the call.
+- `await` every step call and `expect.poll`, else `STEP_NOT_AWAITED` at the line of the call.
 - Assert the fact a model produced with `toContain`, not its exact sentence.

package/docs/viewports.mdx

@@ -1,146 +0,0 @@
----
-title: Testing viewports
-description: Run a suite at several sizes, resize inside a test, and know what the agent sees at each.
----
-
-Set a viewport on the target to run a suite at that size. Use
-`browser.setViewport()` to resize during a test. The agent uses the current size
-and cannot resize it.
-
-## One size per target
-
-`viewport` sets the initial size of each attempt, in pixels. The default is
-1280 by 720. Add one target for each size you want to test:
-
-```ts title="e2e.config.ts"
-import type { E2EConfig } from 'e2e';
-import { web } from '@e2e-dev/web';
-
-const app = { url: 'http://localhost:3000' };
-
-export default {
-  targets: [
-    { name: 'desktop', engine: web(), app },
-    { name: 'tablet', engine: web({ viewport: { width: 820, height: 1180 } }), app },
-    { name: 'phone', engine: web({ browser: 'webkit', viewport: { width: 390, height: 844 } }), app },
-  ],
-} satisfies E2EConfig;
-```
-
-Each test runs once per target, with a separate result labeled `desktop`,
-`tablet`, or `phone`. Run one size with `npx e2e run --target phone`, or list
-the selected test-target pairs with `npx e2e list`.
-
-To have the runner start one dev server for every size, give every target
-the same `app.command`: targets declaring one command share one process; see
-[several targets](/starting-your-app#several-targets). Every retry starts at
-the target's configured size.
-
-## Fill the window
-
-`viewport: null` sets no size, so the page fills the browser window. The
-agent, screenshots, and videos use that size. Use it in a headed run, or
-with a hosted browser whose live view would show a fixed 1280 by 720 page
-in one corner:
-
-```ts title="e2e.config.ts"
-{ name: 'window', engine: web({ viewport: null }), app }
-```
-
-The page takes the window's size, minus the toolbar in a headed browser. A
-local headed launch opens a small window; a hosted browser uses the window
-size you requested from the service. `browser.setViewport` still works.
-
-## Resize inside a test
-
-`browser.setViewport` resizes the page for the rest of the attempt, through
-`app.restart()` and `app.clearState()`:
-
-```ts
-import { test } from '@e2e-dev/web';
-import { expect } from 'e2e';
-
-test('the menu collapses on a narrow screen', async ({ app, screen, browser }) => {
-  await app.open('/');
-  await expect(screen.getByRole('navigation')).toBeVisible();
-
-  await browser.setViewport({ width: 390, height: 844 });
-  await expect(screen.getByRole('button', 'Menu')).toBeVisible();
-  await expect(screen.getByRole('navigation')).toBeHidden();
-});
-```
-
-Use this when one test needs to check a layout before and after resizing.
-For a whole suite, configure separate targets instead.
-
-Call it before `app.open` to load the first page at that size, so the app
-never renders its desktop layout first:
-
-```ts
-await browser.setViewport({ width: 390, height: 844 });
-await app.open('/');
-```
-
-The resize appears as a step in the report. To check the exact width, read
-it from the page:
-
-```ts
-const width = await browser.evaluate(() => window.innerWidth);
-expect(width).toBe(390);
-```
-
-## What the agent sees
-
-The agent receives the current viewport size with each observation.
-Screenshots cover that viewport. Off-screen elements can still appear in
-the tree, and tapping them scrolls them into view. The agent can scroll to
-reveal lazy-loaded content.
-
-Resize before calling `agent.act`:
-
-```ts
-test('the mobile menu reaches pricing', async ({ app, agent, browser }) => {
-  await browser.setViewport({ width: 390, height: 844 });
-  await app.open('/');
-  await agent.act('open the navigation menu and go to Pricing');
-  await expect(browser).toHaveURL('/pricing');
-});
-```
-
-## Scoping a test to one size
-
-`platforms` and `requires` cannot select a viewport; all Playwright targets
-use platform `web`. To skip a test at some sizes, check the width in the
-test:
-
-```ts
-test('the sidebar stays open', async ({ app, screen, browser }) => {
-  await app.open('/');
-  test.skip((await browser.evaluate(() => window.innerWidth)) < 768, 'desktop layout only');
-  await expect(screen.getByRole('complementary')).toBeVisible();
-});
-```
-
-To keep a whole group of size-specific tests apart, give them their own
-config and run it with `--config`.
-
-## Limits
-
-A narrow viewport tests responsive layout. It still uses a desktop browser
-with a scale factor of 1, desktop pointer behavior, and its usual user agent.
-It does not emulate touch, color scheme, or reduced-motion preferences.
-Use the [device engine](/mobile) for tests on a simulator or emulator.
-
-A video keeps the size the page had when it started recording; set
-`web({ screencast: { size } })` for one fixed size. A browser provider that
-records, such as [Kernel](/integrations/kernel#recordings), records the whole
-screen instead.
-
-<CardGroup cols={2}>
-  <Card title="Working with the browser" icon="globe" href="/browser">
-    Routes, cookies, dialogs, downloads, and the rest of the `browser` fixture.
-  </Card>
-  <Card title="Web engine reference" icon="masks-theater" href="/reference/web">
-    Every engine option and `browser` method, with timeouts and errors.
-  </Card>
-</CardGroup>