diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
index a2757e433..ca442079e 100644
--- a/COMPATIBILITY.md
+++ b/COMPATIBILITY.md
@@ -162,7 +162,7 @@ Differences:
- Upstream's docs site pages that have no counterpart in the port: the page objects page (`docs/page-objects.mdx`, moved to `/page-object-model` in `d30114a`), `e2e feedback` and the `docs/reference/cli.mdx` text about its opt-out variables (`4c1e2e8`), and `examples/` with its registry (`b3ae3a4`, `38b802d`, `a29edcb`, `b54646f`). The migration guides (`docs/migrate/*.mdx`, `8537abc`) are ported: see [Migration guides](#migration-guides). The docs site has .NET-only guides for upstream's five example apps of `caf51eb` (tester-army/e2e#1497: i18n, file upload, location, biometrics, deep links), under [Examples](docs-site/src/content/docs/examples/index.mdx). They are not ports: that commit only adds registry entries that link to separate repositories, so there was no guide text. Each page writes C# tests for the upstream app. The self-healing deep dive (`6fa99ea`) is ported as the [Self-healing tests](README.md#self-healing-tests) section of the guide, since the port has no docs pages for the cache, the trace page, or executors to link to. Known gap: only `e2e explore` prints a run summary, since it is the one command that feeds a run to `ListReporter` (see [List reporter](#list-reporter)): the `Cache 4 replayed · 1 handed off · 1 missed` row is `Format.CacheText` over `Format.StepsCacheTally` (`E2E.Cli`, upstream's `cacheText` and `stepsCacheTally` of `report/format.ts`), which an exploration, with its cache off, never fills, and a test run does not print ([#799](https://github.com/hardkoded/e2e-dotnet/issues/799))
- Parallel workers and serial suites
- `test.fail` and the `fail` test option (tester-army/e2e#1539, `732ea8a`): a test expected to fail, whose product failure passes and whose pass fails with `UNEXPECTED_PASS`. It lives in upstream's test registry, scheduler, retry, and reporters (`settleExpectedFailure` runs on a finished attempt), and the port has none of them. NUnit and xUnit v3 own the verdict and the retries, and neither has an expected-failure outcome, so a port would need a new public API of its own
-- Playwright's page tests in the testbed suite (tester-army/e2e#1505, `bdf769b`) are ported in slices (hardkoded/e2e-dotnet#1060), as the `playwright` category of `tests/E2E.NUnit.Tests`, against the playground's `/content` route and Playwright's test assets (Apache-2.0, `Testbed/playwright/`, with Playwright's `LICENSE` and `NOTICE`). A test upstream marks `{ fail: 'reason' }` keeps its assertions inside the test-only `Helpers.ExpectedToFailAsync`, which passes while the body fails and fails once it passes. Ported so far: `check`, `wait-for-url`, `locator-list`, `selectors-text`, `fill`, `select-option`, `set-input-files`, and `filechooser`. Upstream's `select-option` test marked `fail` (a bare string selects by label only) passes in the port, which matches a value or a label, so it has no marker. A missing file reports .NET's `Could not find file`, where upstream shows Node's `ENOENT`.
+- Playwright's page tests in the testbed suite (tester-army/e2e#1505, `bdf769b`) are ported in slices (hardkoded/e2e-dotnet#1060), as the `playwright` category of `tests/E2E.NUnit.Tests`, against the playground's `/content` route and Playwright's test assets (Apache-2.0, `Testbed/playwright/`, with Playwright's `LICENSE` and `NOTICE`). A test upstream marks `{ fail: 'reason' }` keeps its assertions inside the test-only `Helpers.ExpectedToFailAsync`, which passes while the body fails and fails once it passes. Ported so far: `check`, `wait-for-url`, `locator-list`, `selectors-text`, `fill`, `select-option`, `set-input-files`, `filechooser`, `click`, `click-scroll`, and `elementhandle-scroll-into-view` (three known differences: hardkoded/e2e-dotnet#1079, #1080, #1081). Upstream's `select-option` test marked `fail` (a bare string selects by label only) passes in the port, which matches a value or a label, so it has no marker. A missing file reports .NET's `Could not find file`, where upstream shows Node's `ENOENT`.
- Serial groups (upstream tester-army/e2e#1056, #1470): serial runs, group retries, and skipping the rest of a group after a failure belong to the test runner, which is NUnit or xUnit here, so the port keeps no serial groups. The schema has `serialAttempt.cutRetry` and the serial verdict is read from it, but nothing in the port writes a serial attempt: see [Report document](#report-document)
- The out-of-process engine protocol (upstream tester-army/e2e#1232, [#873](https://github.com/hardkoded/e2e-dotnet/issues/873)): the port has no runner and no worker pool, so there is no engine process to talk to. An engine is written in .NET against `IEngine`
- Diff-only observations for a custom executor's own model turns. The built-in agent has them (#1022): `#id` lines on the opening screen and on `observe`, and a diff after each action (see [MCP server](#mcp-server) for the presenter). `ExecutorObservation.Text`, which an executor reads from `Observe`, keeps the full `[ref=…]` snapshot, cut at the observation byte budget (see [Agents](#agents)), and a node is addressed by its ref there (`new ExecutorTarget("e12")`), so a custom executor has no presenter of its own. Upstream gives every executor the `#id` view.
diff --git a/tests/E2E.NUnit.Tests/Click/PageClickTests.cs b/tests/E2E.NUnit.Tests/Click/PageClickTests.cs
new file mode 100644
index 000000000..7f340513a
--- /dev/null
+++ b/tests/E2E.NUnit.Tests/Click/PageClickTests.cs
@@ -0,0 +1,708 @@
+// Copyright 2026 TesterArmy.
+// Modified by Dario Kondratiuk.
+// SPDX-License-Identifier: Apache-2.0
+
+using E2E.Engine;
+using static E2E.NUnit.Tests.Helpers;
+
+namespace E2E.NUnit.Tests.Click;
+
+///
+/// test.describe('page click') of upstream's apps/testbed/tests/click.e2e.ts (Playwright's page-click.spec.ts).
+/// TapAsync stands for page.click. Not ported, as upstream: should click button inside frameset; should issue clicks in
+/// parallel in page and popup; should select the text by triple clicking; should waitFor visible when already visible; should not wait with
+/// force; should click the button with fixed position inside an iframe; should click the button with px border with offset; should click the
+/// button with em border with offset; should click a very large button with offset; should click a button in scrolling container with
+/// offset; should wait for becoming hit target with trial run; trial run should work with short timeout; trial run should not click; trial
+/// run should not double click; should fail when obscured and not waiting for hit target; should wait for LABEL to be clickable when it has
+/// pointer-events:none; should report nice error when element is detached and force-clicked; should fail when element detaches after
+/// animation; should retry when element detaches after animation; should retry when element is animating from outside the viewport; should
+/// fail when element is animating from outside the viewport with force; should dispatch microtasks in order; should not throw protocol error
+/// when navigating during the click; should retry when navigating during the click; should not hang when frame is detached; should click in
+/// an iframe with border 2; should not retain removed iframe after clicking inside it; should click a button that is overlaid by a
+/// permission popup; should click in a transformed iframe with force; ensure events are dispatched in the individual tasks; should set
+/// PointerEvent.pressure on pointerdown; should set PointerEvent.pressure on pointermove; should click with tweened mouse movement; should
+/// abort via signal; should throw an Error when aborted in-flight with a string reason; should abort via already-aborted signal; should
+/// throw an Error when aborted via an already-aborted signal with a string reason (no force, trial, position scrolling,
+/// clickCount, steps, element handles, Frame objects, events, or abort signals; some upstream left undone).
+///
+public sealed class PageClickTests : PlaywrightTest
+{
+ /// Two animation frames and a task, Playwright's rafraf, so a pending tap has had its chance.
+ private const string GiveItAChanceToClick =
+ "() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => setTimeout(resolve, 0))))";
+
+ private static readonly ActionOptions Ten = new() { Timeout = TimeSpan.FromSeconds(10) };
+
+ private async Task ResultAsync() => (await Browser.EvaluateAsync("result"))!;
+
+ [Test]
+ public async Task Should_click_the_button()
+ {
+ await Browser.GotoAsync("/input/button.html");
+ await Browser.Locator("button").TapAsync();
+ Assert.That(await ResultAsync(), Is.EqualTo("Clicked"));
+ }
+
+ [Test]
+ public async Task Should_click_svg()
+ {
+ await Browser.GotoAsync(Content("""
+
+ """));
+ await Browser.Locator("circle").TapAsync();
+ Assert.That(await Browser.EvaluateAsync("__CLICKED"), Is.EqualTo(42));
+ }
+
+ [Test]
+ public async Task Should_click_the_button_if_window_Node_is_removed()
+ {
+ // Known difference (hardkoded/e2e-dotnet#1079): the page script reads window.Node.
+ await ExpectedToFailAsync("Node is not defined", async () =>
+ {
+ await Browser.GotoAsync("/input/button.html");
+ await Browser.EvaluateAsync